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

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

kim_interactions Cu

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

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


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

variable temp_converted equal 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14029.144     -14029.144     -14160         -14160          253.15         253.15         47437.927      47437.927      2946.3944      2946.3944    
      1000  -13888.855     -13888.855     -14018.967     -14018.967      251.71084      251.71084      48001.327      48001.327      2296.8844      2296.8844    
Loop time of 351.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.245 ns/day, 97.770 hours/ns, 2.841 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    | 351        | 351        | 351        |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15073    | 0.15073    | 0.15073    |   0.0 |  0.04
Output  | 0.00028457 | 0.00028457 | 0.00028457 |   0.0 |  0.00
Modify  | 0.71509    | 0.71509    | 0.71509    |   0.0 |  0.20
Other   |            | 0.1007     |            |       |  0.03

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 380.73     | 380.73     | 380.73     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15471    | 0.15471    | 0.15471    |   0.0 |  0.04
Output  | 0.00027673 | 0.00027673 | 0.00027673 |   0.0 |  0.00
Modify  | 0.76053    | 0.76053    | 0.76053    |   0.0 |  0.20
Other   |            | 0.1033     |            |       |  0.03

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

Total # of neighbors = 311170
Ave neighs/atom = 77.7925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13899.952     -13899.952     -14027.793     -14027.793      247.31796      247.31796      48013.721      48013.721      827.53655      827.53655    
      3000  -13892.932     -13892.932     -14027.816     -14027.816      260.94233      260.94233      48058.236      48058.236     -137.69324     -137.69324    
Loop time of 384.131 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.703 hours/ns, 2.603 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    | 383.11     | 383.11     | 383.11     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1558     | 0.1558     | 0.1558     |   0.0 |  0.04
Output  | 0.00026124 | 0.00026124 | 0.00026124 |   0.0 |  0.00
Modify  | 0.75786    | 0.75786    | 0.75786    |   0.0 |  0.20
Other   |            | 0.1036     |            |       |  0.03

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

Total # of neighbors = 311286
Ave neighs/atom = 77.8215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13892.932     -13892.932     -14027.816     -14027.816      260.94233      260.94233      48058.236      48058.236     -137.69324     -137.69324    
      4000  -13899.251     -13899.251     -14027.105     -14027.105      247.34199      247.34199      48045.225      48045.225      6.5769104      6.5769104    
Loop time of 384.71 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.864 hours/ns, 2.599 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.69     | 383.69     | 383.69     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15575    | 0.15575    | 0.15575    |   0.0 |  0.04
Output  | 0.00027796 | 0.00027796 | 0.00027796 |   0.0 |  0.00
Modify  | 0.75606    | 0.75606    | 0.75606    |   0.0 |  0.20
Other   |            | 0.103      |            |       |  0.03

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

Total # of neighbors = 311276
Ave neighs/atom = 77.819
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13899.251     -13899.251     -14027.105     -14027.105      247.34199      247.34199      48045.225      48045.225      6.5769104      6.5769104    
      5000  -13894.891     -13894.891     -14024.717     -14024.717      251.15762      251.15762      48050.071      48050.071      100.38538      100.38538    
Loop time of 385.448 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.069 hours/ns, 2.594 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.42     | 384.42     | 384.42     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15631    | 0.15631    | 0.15631    |   0.0 |  0.04
Output  | 0.00019094 | 0.00019094 | 0.00019094 |   0.0 |  0.00
Modify  | 0.76653    | 0.76653    | 0.76653    |   0.0 |  0.20
Other   |            | 0.1042     |            |       |  0.03

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

Total # of neighbors = 311226
Ave neighs/atom = 77.8065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 256.481504752098, Press = -134.050951105363
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13894.891     -13894.891     -14024.717     -14024.717      251.15762      251.15762      48050.071      48050.071      100.38538      100.38538    
      6000  -13895.533     -13895.533     -14026.119     -14026.119      252.626        252.626        48083.457      48083.457     -889.16413     -889.16413    
Loop time of 390.791 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.553 hours/ns, 2.559 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.72     | 389.72     | 389.72     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15925    | 0.15925    | 0.15925    |   0.0 |  0.04
Output  | 0.00022841 | 0.00022841 | 0.00022841 |   0.0 |  0.00
Modify  | 0.81162    | 0.81162    | 0.81162    |   0.0 |  0.21
Other   |            | 0.1042     |            |       |  0.03

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

Total # of neighbors = 311112
Ave neighs/atom = 77.778
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.901467162013, Press = 27.3480348222209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.533     -13895.533     -14026.119     -14026.119      252.626        252.626        48083.457      48083.457     -889.16413     -889.16413    
      7000  -13898.609     -13898.609     -14030.011     -14030.011      254.2063       254.2063       48066.752      48066.752     -853.03825     -853.03825    
Loop time of 383.34 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.483 hours/ns, 2.609 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.3      | 382.3      | 382.3      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15551    | 0.15551    | 0.15551    |   0.0 |  0.04
Output  | 0.00018644 | 0.00018644 | 0.00018644 |   0.0 |  0.00
Modify  | 0.77926    | 0.77926    | 0.77926    |   0.0 |  0.20
Other   |            | 0.1028     |            |       |  0.03

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

Total # of neighbors = 311248
Ave neighs/atom = 77.812
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.318972587982, Press = 19.6605446251011
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13898.609     -13898.609     -14030.011     -14030.011      254.2063       254.2063       48066.752      48066.752     -853.03825     -853.03825    
      8000  -13892.328     -13892.328     -14024.976     -14024.976      256.61684      256.61684      48067.58       48067.58      -307.51499     -307.51499    
Loop time of 382.297 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.26     | 381.26     | 381.26     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15533    | 0.15533    | 0.15533    |   0.0 |  0.04
Output  | 0.00018664 | 0.00018664 | 0.00018664 |   0.0 |  0.00
Modify  | 0.77334    | 0.77334    | 0.77334    |   0.0 |  0.20
Other   |            | 0.1031     |            |       |  0.03

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

Total # of neighbors = 311254
Ave neighs/atom = 77.8135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.288554089944, Press = 6.64408388428153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13892.328     -13892.328     -14024.976     -14024.976      256.61684      256.61684      48067.58       48067.58      -307.51499     -307.51499    
      9000  -13895.181     -13895.181     -14024.977     -14024.977      251.09788      251.09788      48084.703      48084.703     -793.27856     -793.27856    
Loop time of 384.12 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.700 hours/ns, 2.603 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.08     | 383.08     | 383.08     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15716    | 0.15716    | 0.15716    |   0.0 |  0.04
Output  | 0.000241   | 0.000241   | 0.000241   |   0.0 |  0.00
Modify  | 0.78416    | 0.78416    | 0.78416    |   0.0 |  0.20
Other   |            | 0.1036     |            |       |  0.03

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

Total # of neighbors = 311194
Ave neighs/atom = 77.7985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.480639723589, Press = 3.72355777654384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.181     -13895.181     -14024.977     -14024.977      251.09788      251.09788      48084.703      48084.703     -793.27856     -793.27856    
     10000  -13897.106     -13897.106     -14029.316     -14029.316      255.76965      255.76965      48063.785      48063.785     -633.33961     -633.33961    
Loop time of 385.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.119 hours/ns, 2.593 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.59     | 384.59     | 384.59     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15619    | 0.15619    | 0.15619    |   0.0 |  0.04
Output  | 0.00019243 | 0.00019243 | 0.00019243 |   0.0 |  0.00
Modify  | 0.78247    | 0.78247    | 0.78247    |   0.0 |  0.20
Other   |            | 0.1031     |            |       |  0.03

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

Total # of neighbors = 311152
Ave neighs/atom = 77.788
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.40968000567, Press = 1.36723291233774
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13897.106     -13897.106     -14029.316     -14029.316      255.76965      255.76965      48063.785      48063.785     -633.33961     -633.33961    
     11000  -13899.977     -13899.977     -14029.964     -14029.964      251.46778      251.46778      48055.248      48055.248     -524.56847     -524.56847    
Loop time of 387.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.618 hours/ns, 2.581 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 386.36     | 386.36     | 386.36     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15677    | 0.15677    | 0.15677    |   0.0 |  0.04
Output  | 0.00024317 | 0.00024317 | 0.00024317 |   0.0 |  0.00
Modify  | 0.80257    | 0.80257    | 0.80257    |   0.0 |  0.21
Other   |            | 0.1046     |            |       |  0.03

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

Total # of neighbors = 311216
Ave neighs/atom = 77.804
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.098235075007, Press = 0.459023822475898
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13899.977     -13899.977     -14029.964     -14029.964      251.46778      251.46778      48055.248      48055.248     -524.56847     -524.56847    
     12000  -13895.21      -13895.21      -14027.002     -14027.002      254.96101      254.96101      48124.466      48124.466     -2200.7159     -2200.7159    
Loop time of 386.471 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.353 hours/ns, 2.588 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 385.41     | 385.41     | 385.41     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15606    | 0.15606    | 0.15606    |   0.0 |  0.04
Output  | 0.00018802 | 0.00018802 | 0.00018802 |   0.0 |  0.00
Modify  | 0.79691    | 0.79691    | 0.79691    |   0.0 |  0.21
Other   |            | 0.1042     |            |       |  0.03

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

Total # of neighbors = 311240
Ave neighs/atom = 77.81
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.123364352744, Press = -0.805443267483052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.21      -13895.21      -14027.002     -14027.002      254.96101      254.96101      48124.466      48124.466     -2200.7159     -2200.7159    
     13000  -13899.478     -13899.478     -14026.829     -14026.829      246.36962      246.36962      48111.549      48111.549     -1919.0411     -1919.0411    
Loop time of 386.754 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.432 hours/ns, 2.586 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 385.69     | 385.69     | 385.69     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15781    | 0.15781    | 0.15781    |   0.0 |  0.04
Output  | 0.0001862  | 0.0001862  | 0.0001862  |   0.0 |  0.00
Modify  | 0.79711    | 0.79711    | 0.79711    |   0.0 |  0.21
Other   |            | 0.1038     |            |       |  0.03

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

Total # of neighbors = 311120
Ave neighs/atom = 77.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 = 253.109237606243, Press = 0.291572460626834
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13899.478     -13899.478     -14026.829     -14026.829      246.36962      246.36962      48111.549      48111.549     -1919.0411     -1919.0411    
     14000  -13893.454     -13893.454     -14026.335     -14026.335      257.06816      257.06816      48087.192      48087.192     -1012.5254     -1012.5254    
Loop time of 381.05 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 380.01     | 380.01     | 380.01     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15686    | 0.15686    | 0.15686    |   0.0 |  0.04
Output  | 0.00046502 | 0.00046502 | 0.00046502 |   0.0 |  0.00
Modify  | 0.77908    | 0.77908    | 0.77908    |   0.0 |  0.20
Other   |            | 0.1034     |            |       |  0.03

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

Total # of neighbors = 311226
Ave neighs/atom = 77.8065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.118597016329, Press = -0.386947721843373
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13893.454     -13893.454     -14026.335     -14026.335      257.06816      257.06816      48087.192      48087.192     -1012.5254     -1012.5254    
     15000  -13898.628     -13898.628     -14028.072     -14028.072      250.41712      250.41712      48052.658      48052.658     -228.24031     -228.24031    
Loop time of 384.014 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.671 hours/ns, 2.604 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.97     | 382.97     | 382.97     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15537    | 0.15537    | 0.15537    |   0.0 |  0.04
Output  | 0.000229   | 0.000229   | 0.000229   |   0.0 |  0.00
Modify  | 0.78517    | 0.78517    | 0.78517    |   0.0 |  0.20
Other   |            | 0.1034     |            |       |  0.03

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

Total # of neighbors = 311186
Ave neighs/atom = 77.7965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.150000023102, Press = -0.571139398571769
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13898.628     -13898.628     -14028.072     -14028.072      250.41712      250.41712      48052.658      48052.658     -228.24031     -228.24031    
     16000  -13899.653     -13899.653     -14030.047     -14030.047      252.25495      252.25495      48058.512      48058.512     -626.4475      -626.4475     
Loop time of 385.775 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.160 hours/ns, 2.592 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.72     | 384.72     | 384.72     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15688    | 0.15688    | 0.15688    |   0.0 |  0.04
Output  | 0.000192   | 0.000192   | 0.000192   |   0.0 |  0.00
Modify  | 0.79013    | 0.79013    | 0.79013    |   0.0 |  0.20
Other   |            | 0.1041     |            |       |  0.03

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

Total # of neighbors = 311294
Ave neighs/atom = 77.8235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.164049282146, Press = -2.42237877646413
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13899.653     -13899.653     -14030.047     -14030.047      252.25495      252.25495      48058.512      48058.512     -626.4475      -626.4475     
     17000  -13895.532     -13895.532     -14026.424     -14026.424      253.2191       253.2191       48088.912      48088.912     -1035.8374     -1035.8374    
Loop time of 384.898 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.916 hours/ns, 2.598 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.85     | 383.85     | 383.85     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15617    | 0.15617    | 0.15617    |   0.0 |  0.04
Output  | 0.0002269  | 0.0002269  | 0.0002269  |   0.0 |  0.00
Modify  | 0.78655    | 0.78655    | 0.78655    |   0.0 |  0.20
Other   |            | 0.1039     |            |       |  0.03

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

Total # of neighbors = 311270
Ave neighs/atom = 77.8175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.030639120148, Press = -1.70042089817183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.532     -13895.532     -14026.424     -14026.424      253.2191       253.2191       48088.912      48088.912     -1035.8374     -1035.8374    
     18000  -13899.486     -13899.486     -14026.341     -14026.341      245.41023      245.41023      48094.793      48094.793     -1305.5505     -1305.5505    
Loop time of 380.578 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 379.55     | 379.55     | 379.55     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15517    | 0.15517    | 0.15517    |   0.0 |  0.04
Output  | 0.00019148 | 0.00019148 | 0.00019148 |   0.0 |  0.00
Modify  | 0.77004    | 0.77004    | 0.77004    |   0.0 |  0.20
Other   |            | 0.1023     |            |       |  0.03

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

Total # of neighbors = 311220
Ave neighs/atom = 77.805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.941773122061, Press = -1.02941088992541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13899.486     -13899.486     -14026.341     -14026.341      245.41023      245.41023      48094.793      48094.793     -1305.5505     -1305.5505    
     19000  -13895.846     -13895.846     -14026.212     -14026.212      252.20191      252.20191      48113.038      48113.038     -1728.1936     -1728.1936    
Loop time of 379.434 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.4      | 378.4      | 378.4      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15422    | 0.15422    | 0.15422    |   0.0 |  0.04
Output  | 0.00030798 | 0.00030798 | 0.00030798 |   0.0 |  0.00
Modify  | 0.7751     | 0.7751     | 0.7751     |   0.0 |  0.20
Other   |            | 0.102      |            |       |  0.03

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

Total # of neighbors = 311140
Ave neighs/atom = 77.785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.868365973953, Press = 0.857625224176616
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.846     -13895.846     -14026.212     -14026.212      252.20191      252.20191      48113.038      48113.038     -1728.1936     -1728.1936    
     20000  -13898.22      -13898.22      -14028.894     -14028.894      252.79715      252.79715      48105.842      48105.842     -1892.6755     -1892.6755    
Loop time of 383.423 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.506 hours/ns, 2.608 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.37     | 382.37     | 382.37     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15565    | 0.15565    | 0.15565    |   0.0 |  0.04
Output  | 0.00024018 | 0.00024018 | 0.00024018 |   0.0 |  0.00
Modify  | 0.79617    | 0.79617    | 0.79617    |   0.0 |  0.21
Other   |            | 0.1043     |            |       |  0.03

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

Total # of neighbors = 311150
Ave neighs/atom = 77.7875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.902251015141, Press = -0.27545193995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13898.22      -13898.22      -14028.894     -14028.894      252.79715      252.79715      48105.842      48105.842     -1892.6755     -1892.6755    
     21000  -13898.738     -13898.738     -14026.684     -14026.684      247.52031      247.52031      48073.559      48073.559     -747.52484     -747.52484    
Loop time of 381.441 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 380.41     | 380.41     | 380.41     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15523    | 0.15523    | 0.15523    |   0.0 |  0.04
Output  | 0.00018859 | 0.00018859 | 0.00018859 |   0.0 |  0.00
Modify  | 0.77524    | 0.77524    | 0.77524    |   0.0 |  0.20
Other   |            | 0.1027     |            |       |  0.03

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

Total # of neighbors = 311112
Ave neighs/atom = 77.778
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.810182979755, Press = 1.26577976776026
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13898.738     -13898.738     -14026.684     -14026.684      247.52031      247.52031      48073.559      48073.559     -747.52484     -747.52484    
     22000  -13897.925     -13897.925     -14030.841     -14030.841      257.13506      257.13506      48095.48       48095.48      -1728.1192     -1728.1192    
Loop time of 378.698 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 377.67     | 377.67     | 377.67     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15378    | 0.15378    | 0.15378    |   0.0 |  0.04
Output  | 0.00021964 | 0.00021964 | 0.00021964 |   0.0 |  0.00
Modify  | 0.77487    | 0.77487    | 0.77487    |   0.0 |  0.20
Other   |            | 0.1032     |            |       |  0.03

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

Total # of neighbors = 311204
Ave neighs/atom = 77.801
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.839283830841, Press = 0.291419032759012
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13897.925     -13897.925     -14030.841     -14030.841      257.13506      257.13506      48095.48       48095.48      -1728.1192     -1728.1192    
     23000  -13896.733     -13896.733     -14028.545     -14028.545      254.99953      254.99953      48069.942      48069.942     -773.44358     -773.44358    
Loop time of 381.884 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 380.84     | 380.84     | 380.84     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15614    | 0.15614    | 0.15614    |   0.0 |  0.04
Output  | 0.00023079 | 0.00023079 | 0.00023079 |   0.0 |  0.00
Modify  | 0.78697    | 0.78697    | 0.78697    |   0.0 |  0.21
Other   |            | 0.1038     |            |       |  0.03

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

Total # of neighbors = 311292
Ave neighs/atom = 77.823
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.790959762669, Press = -1.18803806134869
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13896.733     -13896.733     -14028.545     -14028.545      254.99953      254.99953      48069.942      48069.942     -773.44358     -773.44358    
     24000  -13896.845     -13896.845     -14027.808     -14027.808      253.35794      253.35794      48070.358      48070.358     -728.6997      -728.6997     
Loop time of 383.01 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.96     | 381.96     | 381.96     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15677    | 0.15677    | 0.15677    |   0.0 |  0.04
Output  | 0.00019158 | 0.00019158 | 0.00019158 |   0.0 |  0.00
Modify  | 0.78727    | 0.78727    | 0.78727    |   0.0 |  0.21
Other   |            | 0.1038     |            |       |  0.03

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

Total # of neighbors = 311194
Ave neighs/atom = 77.7985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.822412366038, Press = -0.200567307684052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13896.845     -13896.845     -14027.808     -14027.808      253.35794      253.35794      48070.358      48070.358     -728.6997      -728.6997     
     25000  -13891.035     -13891.035     -14024.079     -14024.079      257.38395      257.38395      48118.565      48118.565     -1664.0412     -1664.0412    
Loop time of 389.162 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.1      | 388.1      | 388.1      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15652    | 0.15652    | 0.15652    |   0.0 |  0.04
Output  | 0.00028552 | 0.00028552 | 0.00028552 |   0.0 |  0.00
Modify  | 0.79751    | 0.79751    | 0.79751    |   0.0 |  0.20
Other   |            | 0.1046     |            |       |  0.03

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

Total # of neighbors = 311206
Ave neighs/atom = 77.8015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.883731863822, Press = -0.834675697630702
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13891.035     -13891.035     -14024.079     -14024.079      257.38395      257.38395      48118.565      48118.565     -1664.0412     -1664.0412    
     26000  -13899.996     -13899.996     -14028.842     -14028.842      249.26172      249.26172      48135.901      48135.901     -2709.9449     -2709.9449    
Loop time of 378.285 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 377.25     | 377.25     | 377.25     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15452    | 0.15452    | 0.15452    |   0.0 |  0.04
Output  | 0.00018761 | 0.00018761 | 0.00018761 |   0.0 |  0.00
Modify  | 0.77684    | 0.77684    | 0.77684    |   0.0 |  0.21
Other   |            | 0.1031     |            |       |  0.03

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

Total # of neighbors = 311070
Ave neighs/atom = 77.7675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.924209387076, Press = -0.943710071323469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13899.996     -13899.996     -14028.842     -14028.842      249.26172      249.26172      48135.901      48135.901     -2709.9449     -2709.9449    
     27000  -13896.017     -13896.017     -14027.405     -14027.405      254.1797       254.1797       48096.58       48096.58      -1422.3688     -1422.3688    
Loop time of 381.466 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 380.43     | 380.43     | 380.43     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15475    | 0.15475    | 0.15475    |   0.0 |  0.04
Output  | 0.0001878  | 0.0001878  | 0.0001878  |   0.0 |  0.00
Modify  | 0.77452    | 0.77452    | 0.77452    |   0.0 |  0.20
Other   |            | 0.1027     |            |       |  0.03

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

Total # of neighbors = 311122
Ave neighs/atom = 77.7805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.970632856774, Press = -0.685255892371992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13896.017     -13896.017     -14027.405     -14027.405      254.1797       254.1797       48096.58       48096.58      -1422.3688     -1422.3688    
     28000  -13898.053     -13898.053     -14026.209     -14026.209      247.92657      247.92657      48064.348      48064.348     -333.3637      -333.3637     
Loop time of 382.969 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.92     | 381.92     | 381.92     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15709    | 0.15709    | 0.15709    |   0.0 |  0.04
Output  | 0.00026182 | 0.00026182 | 0.00026182 |   0.0 |  0.00
Modify  | 0.78931    | 0.78931    | 0.78931    |   0.0 |  0.21
Other   |            | 0.1034     |            |       |  0.03

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

Total # of neighbors = 311092
Ave neighs/atom = 77.773
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.013609516746, Press = -0.200198777934728
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13898.053     -13898.053     -14026.209     -14026.209      247.92657      247.92657      48064.348      48064.348     -333.3637      -333.3637     
     29000  -13896.181     -13896.181     -14029.582     -14029.582      258.073        258.073        48084.089      48084.089     -1272.3905     -1272.3905    
Loop time of 385.518 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.088 hours/ns, 2.594 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.47     | 384.47     | 384.47     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15717    | 0.15717    | 0.15717    |   0.0 |  0.04
Output  | 0.00020677 | 0.00020677 | 0.00020677 |   0.0 |  0.00
Modify  | 0.78931    | 0.78931    | 0.78931    |   0.0 |  0.20
Other   |            | 0.1034     |            |       |  0.03

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

Total # of neighbors = 311122
Ave neighs/atom = 77.7805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.032142146179, Press = -0.662001218456205
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13896.181     -13896.181     -14029.582     -14029.582      258.073        258.073        48084.089      48084.089     -1272.3905     -1272.3905    
     30000  -13898.216     -13898.216     -14027.047     -14027.047      249.23173      249.23173      48093.051      48093.051     -1361.7758     -1361.7758    
Loop time of 377.909 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 376.89     | 376.89     | 376.89     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15423    | 0.15423    | 0.15423    |   0.0 |  0.04
Output  | 0.00018696 | 0.00018696 | 0.00018696 |   0.0 |  0.00
Modify  | 0.76776    | 0.76776    | 0.76776    |   0.0 |  0.20
Other   |            | 0.1019     |            |       |  0.03

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

Total # of neighbors = 311168
Ave neighs/atom = 77.792
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.016272920736, Press = -1.35329922096966
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13898.216     -13898.216     -14027.047     -14027.047      249.23173      249.23173      48093.051      48093.051     -1361.7758     -1361.7758    
     31000  -13897.252     -13897.252     -14026.534     -14026.534      250.10473      250.10473      48156.416      48156.416     -3126.1091     -3126.1091    
Loop time of 382.182 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.14     | 381.14     | 381.14     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15507    | 0.15507    | 0.15507    |   0.0 |  0.04
Output  | 0.00028732 | 0.00028732 | 0.00028732 |   0.0 |  0.00
Modify  | 0.77983    | 0.77983    | 0.77983    |   0.0 |  0.20
Other   |            | 0.1027     |            |       |  0.03

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

Total # of neighbors = 311064
Ave neighs/atom = 77.766
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.943110783334, Press = -0.797444221109493
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13897.252     -13897.252     -14026.534     -14026.534      250.10473      250.10473      48156.416      48156.416     -3126.1091     -3126.1091    
     32000  -13898.488     -13898.488     -14027.466     -14027.466      249.51646      249.51646      48083.845      48083.845     -1166.0132     -1166.0132    
Loop time of 388.853 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.8      | 387.8      | 387.8      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15745    | 0.15745    | 0.15745    |   0.0 |  0.04
Output  | 0.0002602  | 0.0002602  | 0.0002602  |   0.0 |  0.00
Modify  | 0.79297    | 0.79297    | 0.79297    |   0.0 |  0.20
Other   |            | 0.1038     |            |       |  0.03

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

Total # of neighbors = 311072
Ave neighs/atom = 77.768
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.94918788878, Press = -0.855372940598833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13898.488     -13898.488     -14027.466     -14027.466      249.51646      249.51646      48083.845      48083.845     -1166.0132     -1166.0132    
     33000  -13895.494     -13895.494     -14024.713     -14024.713      249.98393      249.98393      48090.387      48090.387     -1041.257      -1041.257     
Loop time of 378.307 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 377.28     | 377.28     | 377.28     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15446    | 0.15446    | 0.15446    |   0.0 |  0.04
Output  | 0.00019211 | 0.00019211 | 0.00019211 |   0.0 |  0.00
Modify  | 0.77275    | 0.77275    | 0.77275    |   0.0 |  0.20
Other   |            | 0.1022     |            |       |  0.03

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

Total # of neighbors = 311134
Ave neighs/atom = 77.7835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.907736282902, Press = -0.639766934118791
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.494     -13895.494     -14024.713     -14024.713      249.98393      249.98393      48090.387      48090.387     -1041.257      -1041.257     
     34000  -13901.3       -13901.3       -14029.529     -14029.529      248.06835      248.06835      48062.964      48062.964     -761.15419     -761.15419    
Loop time of 383.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.489 hours/ns, 2.609 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.32     | 382.32     | 382.32     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15574    | 0.15574    | 0.15574    |   0.0 |  0.04
Output  | 0.00018833 | 0.00018833 | 0.00018833 |   0.0 |  0.00
Modify  | 0.78133    | 0.78133    | 0.78133    |   0.0 |  0.20
Other   |            | 0.1035     |            |       |  0.03

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

Total # of neighbors = 311084
Ave neighs/atom = 77.771
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.883679478152, Press = -0.400282835655107
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13901.3       -13901.3       -14029.529     -14029.529      248.06835      248.06835      48062.964      48062.964     -761.15419     -761.15419    
     35000  -13898.513     -13898.513     -14027.257     -14027.257      249.06375      249.06375      48078.613      48078.613     -929.86921     -929.86921    
Loop time of 382.208 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.17     | 381.17     | 381.17     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15538    | 0.15538    | 0.15538    |   0.0 |  0.04
Output  | 0.00019361 | 0.00019361 | 0.00019361 |   0.0 |  0.00
Modify  | 0.78006    | 0.78006    | 0.78006    |   0.0 |  0.20
Other   |            | 0.1028     |            |       |  0.03

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

Total # of neighbors = 311090
Ave neighs/atom = 77.7725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.886876789589, Press = 0.533536367461426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13898.513     -13898.513     -14027.257     -14027.257      249.06375      249.06375      48078.613      48078.613     -929.86921     -929.86921    
     36000  -13895.254     -13895.254     -14027.59      -14027.59       256.01374      256.01374      48142.78       48142.78      -2739.4103     -2739.4103    
Loop time of 385.841 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.178 hours/ns, 2.592 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.79     | 384.79     | 384.79     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15816    | 0.15816    | 0.15816    |   0.0 |  0.04
Output  | 0.00023691 | 0.00023691 | 0.00023691 |   0.0 |  0.00
Modify  | 0.79107    | 0.79107    | 0.79107    |   0.0 |  0.21
Other   |            | 0.104      |            |       |  0.03

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

Total # of neighbors = 311172
Ave neighs/atom = 77.793
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.915865476123, Press = 0.928217988037105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.254     -13895.254     -14027.59      -14027.59       256.01374      256.01374      48142.78       48142.78      -2739.4103     -2739.4103    
     37000  -13899.565     -13899.565     -14028.518     -14028.518      249.46683      249.46683      48086.358      48086.358     -1326.2408     -1326.2408    
Loop time of 379.348 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.32     | 378.32     | 378.32     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15463    | 0.15463    | 0.15463    |   0.0 |  0.04
Output  | 0.00019163 | 0.00019163 | 0.00019163 |   0.0 |  0.00
Modify  | 0.76983    | 0.76983    | 0.76983    |   0.0 |  0.20
Other   |            | 0.1028     |            |       |  0.03

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

Total # of neighbors = 311032
Ave neighs/atom = 77.758
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.922120954732, Press = 0.894673749762526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13899.565     -13899.565     -14028.518     -14028.518      249.46683      249.46683      48086.358      48086.358     -1326.2408     -1326.2408    
     38000  -13894.712     -13894.712     -14026.985     -14026.985      255.89096      255.89096      48067.411      48067.411     -431.90815     -431.90815    
Loop time of 374.933 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.91     | 373.91     | 373.91     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15189    | 0.15189    | 0.15189    |   0.0 |  0.04
Output  | 0.00023358 | 0.00023358 | 0.00023358 |   0.0 |  0.00
Modify  | 0.76582    | 0.76582    | 0.76582    |   0.0 |  0.20
Other   |            | 0.1018     |            |       |  0.03

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

Total # of neighbors = 311178
Ave neighs/atom = 77.7945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.866999821082, Press = 0.115217773588999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13894.712     -13894.712     -14026.985     -14026.985      255.89096      255.89096      48067.411      48067.411     -431.90815     -431.90815    
     39000  -13900.357     -13900.357     -14031.111     -14031.111      252.95244      252.95244      48055.308      48055.308     -600.79443     -600.79443    
Loop time of 382.043 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.02     | 381.02     | 381.02     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15254    | 0.15254    | 0.15254    |   0.0 |  0.04
Output  | 0.0001899  | 0.0001899  | 0.0001899  |   0.0 |  0.00
Modify  | 0.77171    | 0.77171    | 0.77171    |   0.0 |  0.20
Other   |            | 0.102      |            |       |  0.03

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

Total # of neighbors = 311136
Ave neighs/atom = 77.784
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.862230140442, Press = 0.0846119089738852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13900.357     -13900.357     -14031.111     -14031.111      252.95244      252.95244      48055.308      48055.308     -600.79443     -600.79443    
     40000  -13895.867     -13895.867     -14027.441     -14027.441      254.53957      254.53957      48077.01       48077.01      -918.65126     -918.65126    
Loop time of 379.553 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.54     | 378.54     | 378.54     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15124    | 0.15124    | 0.15124    |   0.0 |  0.04
Output  | 0.00024164 | 0.00024164 | 0.00024164 |   0.0 |  0.00
Modify  | 0.76375    | 0.76375    | 0.76375    |   0.0 |  0.20
Other   |            | 0.101      |            |       |  0.03

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

Total # of neighbors = 311294
Ave neighs/atom = 77.8235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.861749749823, Press = 0.482029683830677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.867     -13895.867     -14027.441     -14027.441      254.53957      254.53957      48077.01       48077.01      -918.65126     -918.65126    
     41000  -13893.315     -13893.315     -14028.043     -14028.043      260.64176      260.64176      48057.99       48057.99      -300.59707     -300.59707    
Loop time of 378.25 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 377.23     | 377.23     | 377.23     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15213    | 0.15213    | 0.15213    |   0.0 |  0.04
Output  | 0.00023449 | 0.00023449 | 0.00023449 |   0.0 |  0.00
Modify  | 0.76857    | 0.76857    | 0.76857    |   0.0 |  0.20
Other   |            | 0.1007     |            |       |  0.03

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

Total # of neighbors = 311112
Ave neighs/atom = 77.778
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.89523814216, Press = 1.16837129353737
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13893.315     -13893.315     -14028.043     -14028.043      260.64176      260.64176      48057.99       48057.99      -300.59707     -300.59707    
     42000  -13897.74      -13897.74      -14024.563     -14024.563      245.34772      245.34772      48058.385      48058.385     -37.713759     -37.713759    
Loop time of 377.532 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 376.52     | 376.52     | 376.52     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1513     | 0.1513     | 0.1513     |   0.0 |  0.04
Output  | 0.00018917 | 0.00018917 | 0.00018917 |   0.0 |  0.00
Modify  | 0.76301    | 0.76301    | 0.76301    |   0.0 |  0.20
Other   |            | 0.1008     |            |       |  0.03

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

Total # of neighbors = 311160
Ave neighs/atom = 77.79
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.90681812492, Press = 1.4718160230338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13897.74      -13897.74      -14024.563     -14024.563      245.34772      245.34772      48058.385      48058.385     -37.713759     -37.713759    
     43000  -13894.748     -13894.748     -14026.476     -14026.476      254.83665      254.83665      48049.493      48049.493      101.01496      101.01496    
Loop time of 376.15 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 375.14     | 375.14     | 375.14     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14974    | 0.14974    | 0.14974    |   0.0 |  0.04
Output  | 0.00018957 | 0.00018957 | 0.00018957 |   0.0 |  0.00
Modify  | 0.75884    | 0.75884    | 0.75884    |   0.0 |  0.20
Other   |            | 0.1006     |            |       |  0.03

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

Total # of neighbors = 311152
Ave neighs/atom = 77.788
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.903170199058, Press = 0.733201554472631
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13894.748     -13894.748     -14026.476     -14026.476      254.83665      254.83665      48049.493      48049.493      101.01496      101.01496    
     44000  -13895.319     -13895.319     -14025.266     -14025.266      251.39028      251.39028      48030.375      48030.375      690.91123      690.91123    
Loop time of 378.082 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 377.06     | 377.06     | 377.06     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15273    | 0.15273    | 0.15273    |   0.0 |  0.04
Output  | 0.00019084 | 0.00019084 | 0.00019084 |   0.0 |  0.00
Modify  | 0.77007    | 0.77007    | 0.77007    |   0.0 |  0.20
Other   |            | 0.1024     |            |       |  0.03

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

Total # of neighbors = 311264
Ave neighs/atom = 77.816
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.89100726209, Press = 0.746239197046149
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.319     -13895.319     -14025.266     -14025.266      251.39028      251.39028      48030.375      48030.375      690.91123      690.91123    
     45000  -13899.07      -13899.07      -14031.371     -14031.371      255.94469      255.94469      48017.4        48017.4        490.53727      490.53727    
Loop time of 385.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.016 hours/ns, 2.596 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.21     | 384.21     | 384.21     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15487    | 0.15487    | 0.15487    |   0.0 |  0.04
Output  | 0.00019081 | 0.00019081 | 0.00019081 |   0.0 |  0.00
Modify  | 0.78802    | 0.78802    | 0.78802    |   0.0 |  0.20
Other   |            | 0.1029     |            |       |  0.03

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

Total # of neighbors = 311116
Ave neighs/atom = 77.779
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.878516937898, Press = 0.718265498290034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13899.07      -13899.07      -14031.371     -14031.371      255.94469      255.94469      48017.4        48017.4        490.53727      490.53727    
     46000  -13895.046     -13895.046     -14028.221     -14028.221      257.63664      257.63664      48019.789      48019.789      747.14019      747.14019    
Loop time of 379.166 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.13     | 378.13     | 378.13     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15295    | 0.15295    | 0.15295    |   0.0 |  0.04
Output  | 0.00018955 | 0.00018955 | 0.00018955 |   0.0 |  0.00
Modify  | 0.77766    | 0.77766    | 0.77766    |   0.0 |  0.21
Other   |            | 0.1016     |            |       |  0.03

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

Total # of neighbors = 311306
Ave neighs/atom = 77.8265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.887235095768, Press = 0.899502443902666
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13895.046     -13895.046     -14028.221     -14028.221      257.63664      257.63664      48019.789      48019.789      747.14019      747.14019    
     47000  -13896.824     -13896.824     -14027.713     -14027.713      253.21391      253.21391      48032.184      48032.184      409.16045      409.16045    
Loop time of 376.467 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 375.45     | 375.45     | 375.45     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15215    | 0.15215    | 0.15215    |   0.0 |  0.04
Output  | 0.00029114 | 0.00029114 | 0.00029114 |   0.0 |  0.00
Modify  | 0.76566    | 0.76566    | 0.76566    |   0.0 |  0.20
Other   |            | 0.1004     |            |       |  0.03

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

Total # of neighbors = 311284
Ave neighs/atom = 77.821
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.920960829148, Press = 0.400355405511802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13896.824     -13896.824     -14027.713     -14027.713      253.21391      253.21391      48032.184      48032.184      409.16045      409.16045    
     48000  -13897.044     -13897.044     -14028.39      -14028.39       254.09837      254.09837      48054.612      48054.612     -249.85781     -249.85781    
Loop time of 374.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 104.030 hours/ns, 2.670 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.48     | 373.48     | 373.48     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15297    | 0.15297    | 0.15297    |   0.0 |  0.04
Output  | 0.00019121 | 0.00019121 | 0.00019121 |   0.0 |  0.00
Modify  | 0.76988    | 0.76988    | 0.76988    |   0.0 |  0.21
Other   |            | 0.1015     |            |       |  0.03

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

Total # of neighbors = 311206
Ave neighs/atom = 77.8015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
48046.9645546873

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0