# 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.613315634429455*${_u_distance}
variable latticeconst_converted equal 3.613315634429455*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331563442945
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.133156 36.133156 36.133156)
  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.133156 36.133156 36.133156)
  create_atoms CPU = 0.007 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_LeeWirthShim_2005_FeCu__MO_063626065437_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 47175.6291336593    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6291336593/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6291336593/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6291336593/(1*1*${_u_distance})
variable      V0_metal equal 47175.6291336593/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 47175.6291336593*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

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

Performance: 0.446 ns/day, 53.815 hours/ns, 5.162 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    | 192.81     | 192.81     | 192.81     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14897    | 0.14897    | 0.14897    |   0.0 |  0.08
Output  | 0.00029427 | 0.00029427 | 0.00029427 |   0.0 |  0.00
Modify  | 0.67514    | 0.67514    | 0.67514    |   0.0 |  0.35
Other   |            | 0.09908    |            |       |  0.05

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

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

Performance: 0.436 ns/day, 55.103 hours/ns, 5.041 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.49     | 197.49     | 197.49     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14042    | 0.14042    | 0.14042    |   0.0 |  0.07
Output  | 0.0002823  | 0.0002823  | 0.0002823  |   0.0 |  0.00
Modify  | 0.6446     | 0.6446     | 0.6446     |   0.0 |  0.32
Other   |            | 0.09861    |            |       |  0.05

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

Total # of neighbors = 310910
Ave neighs/atom = 77.7275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13859.305     -13859.305     -14012.236     -14012.236      295.85458      295.85458      47901.143      47901.143      142.62912      142.62912    
      3000  -13856.435     -13856.435     -14011.373     -14011.373      299.73786      299.73786      47942.165      47942.165     -746.16494     -746.16494    
Loop time of 198.765 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.213 hours/ns, 5.031 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.88     | 197.88     | 197.88     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14077    | 0.14077    | 0.14077    |   0.0 |  0.07
Output  | 0.00023476 | 0.00023476 | 0.00023476 |   0.0 |  0.00
Modify  | 0.64492    | 0.64492    | 0.64492    |   0.0 |  0.32
Other   |            | 0.09858    |            |       |  0.05

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

Total # of neighbors = 311262
Ave neighs/atom = 77.8155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13856.435     -13856.435     -14011.373     -14011.373      299.73786      299.73786      47942.165      47942.165     -746.16494     -746.16494    
      4000  -13856.343     -13856.343     -14007.995     -14007.995      293.38063      293.38063      47939.837      47939.837     -455.49647     -455.49647    
Loop time of 198.621 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.172 hours/ns, 5.035 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.73     | 197.73     | 197.73     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14036    | 0.14036    | 0.14036    |   0.0 |  0.07
Output  | 0.00023687 | 0.00023687 | 0.00023687 |   0.0 |  0.00
Modify  | 0.64763    | 0.64763    | 0.64763    |   0.0 |  0.33
Other   |            | 0.09899    |            |       |  0.05

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

Total # of neighbors = 311158
Ave neighs/atom = 77.7895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13856.343     -13856.343     -14007.995     -14007.995      293.38063      293.38063      47939.837      47939.837     -455.49647     -455.49647    
      5000  -13859.978     -13859.978     -14007.154     -14007.154      284.72245      284.72245      47898.374      47898.374      826.36691      826.36691    
Loop time of 198.456 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.127 hours/ns, 5.039 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.57     | 197.57     | 197.57     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14146    | 0.14146    | 0.14146    |   0.0 |  0.07
Output  | 0.00024275 | 0.00024275 | 0.00024275 |   0.0 |  0.00
Modify  | 0.64773    | 0.64773    | 0.64773    |   0.0 |  0.33
Other   |            | 0.09839    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.810508993578, Press = 334.948807494553
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13859.978     -13859.978     -14007.154     -14007.154      284.72245      284.72245      47898.374      47898.374      826.36691      826.36691    
      6000  -13853.348     -13853.348     -14008.924     -14008.924      300.97202      300.97202      47960.439      47960.439     -939.92875     -939.92875    
Loop time of 198.905 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.251 hours/ns, 5.028 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.99     | 197.99     | 197.99     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14179    | 0.14179    | 0.14179    |   0.0 |  0.07
Output  | 0.00019217 | 0.00019217 | 0.00019217 |   0.0 |  0.00
Modify  | 0.67098    | 0.67098    | 0.67098    |   0.0 |  0.34
Other   |            | 0.09911    |            |       |  0.05

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

Total # of neighbors = 311282
Ave neighs/atom = 77.8205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.542087642, Press = -15.9123609654773
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13853.348     -13853.348     -14008.924     -14008.924      300.97202      300.97202      47960.439      47960.439     -939.92875     -939.92875    
      7000  -13859.988     -13859.988     -14009.647     -14009.647      289.52612      289.52612      47858.292      47858.292      1789.3878      1789.3878    
Loop time of 198.747 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.207 hours/ns, 5.032 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    | 197.83     | 197.83     | 197.83     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1418     | 0.1418     | 0.1418     |   0.0 |  0.07
Output  | 0.00019375 | 0.00019375 | 0.00019375 |   0.0 |  0.00
Modify  | 0.67331    | 0.67331    | 0.67331    |   0.0 |  0.34
Other   |            | 0.09847    |            |       |  0.05

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

Total # of neighbors = 311234
Ave neighs/atom = 77.8085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.973491998696, Press = 30.9872764708818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13859.988     -13859.988     -14009.647     -14009.647      289.52612      289.52612      47858.292      47858.292      1789.3878      1789.3878    
      8000  -13858.608     -13858.608     -14007.995     -14007.995      289.0005       289.0005       47971.786      47971.786     -1397.5408     -1397.5408    
Loop time of 198.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.175 hours/ns, 5.034 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.72     | 197.72     | 197.72     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1418     | 0.1418     | 0.1418     |   0.0 |  0.07
Output  | 0.00019557 | 0.00019557 | 0.00019557 |   0.0 |  0.00
Modify  | 0.67297    | 0.67297    | 0.67297    |   0.0 |  0.34
Other   |            | 0.09809    |            |       |  0.05

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

Total # of neighbors = 311362
Ave neighs/atom = 77.8405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.062142294754, Press = -12.2121170408089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13858.608     -13858.608     -14007.995     -14007.995      289.0005       289.0005       47971.786      47971.786     -1397.5408     -1397.5408    
      9000  -13855.399     -13855.399     -14005.368     -14005.368      290.12677      290.12677      47901.193      47901.193      1019.3201      1019.3201    
Loop time of 198.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.141 hours/ns, 5.038 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.59     | 197.59     | 197.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14099    | 0.14099    | 0.14099    |   0.0 |  0.07
Output  | 0.00019446 | 0.00019446 | 0.00019446 |   0.0 |  0.00
Modify  | 0.67429    | 0.67429    | 0.67429    |   0.0 |  0.34
Other   |            | 0.09902    |            |       |  0.05

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

Total # of neighbors = 311002
Ave neighs/atom = 77.7505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743707703251, Press = 11.5909773835031
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13855.399     -13855.399     -14005.368     -14005.368      290.12677      290.12677      47901.193      47901.193      1019.3201      1019.3201    
     10000  -13858.393     -13858.393     -14007.834     -14007.834      289.10442      289.10442      47922.369      47922.369      94.849136      94.849136    
Loop time of 198.965 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.268 hours/ns, 5.026 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.05     | 198.05     | 198.05     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14112    | 0.14112    | 0.14112    |   0.0 |  0.07
Output  | 0.00019408 | 0.00019408 | 0.00019408 |   0.0 |  0.00
Modify  | 0.67411    | 0.67411    | 0.67411    |   0.0 |  0.34
Other   |            | 0.09891    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 292.911949299365, Press = -0.976276157609033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13858.393     -13858.393     -14007.834     -14007.834      289.10442      289.10442      47922.369      47922.369      94.849136      94.849136    
     11000  -13858.435     -13858.435     -14007.175     -14007.175      287.7478       287.7478       47929.488      47929.488     -88.880502     -88.880502    
Loop time of 198.802 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.223 hours/ns, 5.030 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.89     | 197.89     | 197.89     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14125    | 0.14125    | 0.14125    |   0.0 |  0.07
Output  | 0.00019438 | 0.00019438 | 0.00019438 |   0.0 |  0.00
Modify  | 0.67257    | 0.67257    | 0.67257    |   0.0 |  0.34
Other   |            | 0.09883    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.23690621557, Press = 3.67587798032443
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13858.435     -13858.435     -14007.175     -14007.175      287.7478       287.7478       47929.488      47929.488     -88.880502     -88.880502    
     12000  -13854.763     -13854.763     -14006.924     -14006.924      294.36501      294.36501      47909.754      47909.754      638.54205      638.54205    
Loop time of 198.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.122 hours/ns, 5.039 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.53     | 197.53     | 197.53     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14157    | 0.14157    | 0.14157    |   0.0 |  0.07
Output  | 0.00019366 | 0.00019366 | 0.00019366 |   0.0 |  0.00
Modify  | 0.67166    | 0.67166    | 0.67166    |   0.0 |  0.34
Other   |            | 0.0986     |            |       |  0.05

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

Total # of neighbors = 311196
Ave neighs/atom = 77.799
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.033790824251, Press = -0.697373981630589
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13854.763     -13854.763     -14006.924     -14006.924      294.36501      294.36501      47909.754      47909.754      638.54205      638.54205    
     13000  -13859.427     -13859.427     -14009.661     -14009.661      290.63892      290.63892      47968.388      47968.388     -1362.5354     -1362.5354    
Loop time of 198.681 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.189 hours/ns, 5.033 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.77     | 197.77     | 197.77     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14232    | 0.14232    | 0.14232    |   0.0 |  0.07
Output  | 0.000196   | 0.000196   | 0.000196   |   0.0 |  0.00
Modify  | 0.67186    | 0.67186    | 0.67186    |   0.0 |  0.34
Other   |            | 0.09832    |            |       |  0.05

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

Total # of neighbors = 311288
Ave neighs/atom = 77.822
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.98148476196, Press = 0.912919160773578
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13859.427     -13859.427     -14009.661     -14009.661      290.63892      290.63892      47968.388      47968.388     -1362.5354     -1362.5354    
     14000  -13856.539     -13856.539     -14006.478     -14006.478      290.06698      290.06698      47874.391      47874.391      1695.6811      1695.6811    
Loop time of 198.546 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.152 hours/ns, 5.037 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.63     | 197.63     | 197.63     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14204    | 0.14204    | 0.14204    |   0.0 |  0.07
Output  | 0.00050269 | 0.00050269 | 0.00050269 |   0.0 |  0.00
Modify  | 0.67311    | 0.67311    | 0.67311    |   0.0 |  0.34
Other   |            | 0.09778    |            |       |  0.05

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

Total # of neighbors = 311214
Ave neighs/atom = 77.8035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.933663097182, Press = 3.07548769376024
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13856.539     -13856.539     -14006.478     -14006.478      290.06698      290.06698      47874.391      47874.391      1695.6811      1695.6811    
     15000  -13861.262     -13861.262     -14010.727     -14010.727      289.15137      289.15137      47983.199      47983.199     -1953.9423     -1953.9423    
Loop time of 198.593 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.165 hours/ns, 5.035 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    | 197.68     | 197.68     | 197.68     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14088    | 0.14088    | 0.14088    |   0.0 |  0.07
Output  | 0.00019489 | 0.00019489 | 0.00019489 |   0.0 |  0.00
Modify  | 0.67264    | 0.67264    | 0.67264    |   0.0 |  0.34
Other   |            | 0.09874    |            |       |  0.05

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

Total # of neighbors = 311238
Ave neighs/atom = 77.8095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.768908314315, Press = -1.42628506824083
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13861.262     -13861.262     -14010.727     -14010.727      289.15137      289.15137      47983.199      47983.199     -1953.9423     -1953.9423    
     16000  -13851.671     -13851.671     -14004.725     -14004.725      296.09189      296.09189      47878.205      47878.205      1866.7601      1866.7601    
Loop time of 198.617 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.171 hours/ns, 5.035 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    | 197.7      | 197.7      | 197.7      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14189    | 0.14189    | 0.14189    |   0.0 |  0.07
Output  | 0.00019289 | 0.00019289 | 0.00019289 |   0.0 |  0.00
Modify  | 0.6728     | 0.6728     | 0.6728     |   0.0 |  0.34
Other   |            | 0.09832    |            |       |  0.05

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

Total # of neighbors = 311128
Ave neighs/atom = 77.782
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.821330784753, Press = 3.36507489689892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13851.671     -13851.671     -14004.725     -14004.725      296.09189      296.09189      47878.205      47878.205      1866.7601      1866.7601    
     17000  -13858.225     -13858.225     -14010.164     -14010.164      293.93694      293.93694      47936.867      47936.867     -457.41296     -457.41296    
Loop time of 198.831 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.231 hours/ns, 5.029 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    | 197.92     | 197.92     | 197.92     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14062    | 0.14062    | 0.14062    |   0.0 |  0.07
Output  | 0.00023354 | 0.00023354 | 0.00023354 |   0.0 |  0.00
Modify  | 0.67261    | 0.67261    | 0.67261    |   0.0 |  0.34
Other   |            | 0.09872    |            |       |  0.05

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

Total # of neighbors = 311312
Ave neighs/atom = 77.828
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.992752557092, Press = -0.533679956129822
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13858.225     -13858.225     -14010.164     -14010.164      293.93694      293.93694      47936.867      47936.867     -457.41296     -457.41296    
     18000  -13850.564     -13850.564     -14004.805     -14004.805      298.38986      298.38986      47931.843      47931.843      281.97887      281.97887    
Loop time of 198.559 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.155 hours/ns, 5.036 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    | 197.65     | 197.65     | 197.65     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14203    | 0.14203    | 0.14203    |   0.0 |  0.07
Output  | 0.00019284 | 0.00019284 | 0.00019284 |   0.0 |  0.00
Modify  | 0.67162    | 0.67162    | 0.67162    |   0.0 |  0.34
Other   |            | 0.0989     |            |       |  0.05

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

Total # of neighbors = 311304
Ave neighs/atom = 77.826
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.074778966765, Press = 1.63931137823489
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13850.564     -13850.564     -14004.805     -14004.805      298.38986      298.38986      47931.843      47931.843      281.97887      281.97887    
     19000  -13859.878     -13859.878     -14009.365     -14009.365      289.19265      289.19265      47946.551      47946.551     -678.89866     -678.89866    
Loop time of 199.019 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.283 hours/ns, 5.025 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    | 198.11     | 198.11     | 198.11     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14091    | 0.14091    | 0.14091    |   0.0 |  0.07
Output  | 0.0002431  | 0.0002431  | 0.0002431  |   0.0 |  0.00
Modify  | 0.6723     | 0.6723     | 0.6723     |   0.0 |  0.34
Other   |            | 0.09883    |            |       |  0.05

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

Total # of neighbors = 311154
Ave neighs/atom = 77.7885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.157514688049, Press = 0.76778943122594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13859.878     -13859.878     -14009.365     -14009.365      289.19265      289.19265      47946.551      47946.551     -678.89866     -678.89866    
     20000  -13853.18      -13853.18      -14006.116     -14006.116      295.86521      295.86521      47893.774      47893.774      1214.6157      1214.6157    
Loop time of 199.382 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.384 hours/ns, 5.016 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    | 198.47     | 198.47     | 198.47     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14194    | 0.14194    | 0.14194    |   0.0 |  0.07
Output  | 0.00019279 | 0.00019279 | 0.00019279 |   0.0 |  0.00
Modify  | 0.67597    | 0.67597    | 0.67597    |   0.0 |  0.34
Other   |            | 0.09785    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.207022094417, Press = 2.71648551701358
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13853.18      -13853.18      -14006.116     -14006.116      295.86521      295.86521      47893.774      47893.774      1214.6157      1214.6157    
     21000  -13857.788     -13857.788     -14008.264     -14008.264      291.10687      291.10687      47966.473      47966.473     -1205.3744     -1205.3744    
Loop time of 199.27 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.353 hours/ns, 5.018 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    | 198.35     | 198.35     | 198.35     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14067    | 0.14067    | 0.14067    |   0.0 |  0.07
Output  | 0.00019295 | 0.00019295 | 0.00019295 |   0.0 |  0.00
Modify  | 0.67614    | 0.67614    | 0.67614    |   0.0 |  0.34
Other   |            | 0.09876    |            |       |  0.05

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

Total # of neighbors = 311158
Ave neighs/atom = 77.7895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.334169981706, Press = -1.74909311606451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13857.788     -13857.788     -14008.264     -14008.264      291.10687      291.10687      47966.473      47966.473     -1205.3744     -1205.3744    
     22000  -13853.266     -13853.266     -14007.248     -14007.248      297.88898      297.88898      47881.749      47881.749      1397.4432      1397.4432    
Loop time of 199.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.403 hours/ns, 5.014 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    | 198.54     | 198.54     | 198.54     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14209    | 0.14209    | 0.14209    |   0.0 |  0.07
Output  | 0.00019428 | 0.00019428 | 0.00019428 |   0.0 |  0.00
Modify  | 0.67489    | 0.67489    | 0.67489    |   0.0 |  0.34
Other   |            | 0.09828    |            |       |  0.05

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

Total # of neighbors = 311184
Ave neighs/atom = 77.796
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.359898364042, Press = 3.37658299334459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13853.266     -13853.266     -14007.248     -14007.248      297.88898      297.88898      47881.749      47881.749      1397.4432      1397.4432    
     23000  -13859.402     -13859.402     -14008.312     -14008.312      288.07566      288.07566      47940.854      47940.854     -508.44296     -508.44296    
Loop time of 199.557 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.433 hours/ns, 5.011 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    | 198.64     | 198.64     | 198.64     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14089    | 0.14089    | 0.14089    |   0.0 |  0.07
Output  | 0.00024965 | 0.00024965 | 0.00024965 |   0.0 |  0.00
Modify  | 0.67502    | 0.67502    | 0.67502    |   0.0 |  0.34
Other   |            | 0.09917    |            |       |  0.05

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

Total # of neighbors = 311262
Ave neighs/atom = 77.8155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.40652767198, Press = -1.3776167061933
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13859.402     -13859.402     -14008.312     -14008.312      288.07566      288.07566      47940.854      47940.854     -508.44296     -508.44296    
     24000  -13857         -13857         -14007.295     -14007.295      290.756        290.756        47896.724      47896.724      905.89411      905.89411    
Loop time of 199.262 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.351 hours/ns, 5.019 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    | 198.35     | 198.35     | 198.35     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1412     | 0.1412     | 0.1412     |   0.0 |  0.07
Output  | 0.00019516 | 0.00019516 | 0.00019516 |   0.0 |  0.00
Modify  | 0.67529    | 0.67529    | 0.67529    |   0.0 |  0.34
Other   |            | 0.09857    |            |       |  0.05

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

Total # of neighbors = 311190
Ave neighs/atom = 77.7975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.398550480206, Press = 1.4154914983061
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13857         -13857         -14007.295     -14007.295      290.756        290.756        47896.724      47896.724      905.89411      905.89411    
     25000  -13857.355     -13857.355     -14009.62      -14009.62       294.56752      294.56752      47929.876      47929.876     -255.55491     -255.55491    
Loop time of 198.887 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.246 hours/ns, 5.028 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    | 197.98     | 197.98     | 197.98     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14185    | 0.14185    | 0.14185    |   0.0 |  0.07
Output  | 0.00025038 | 0.00025038 | 0.00025038 |   0.0 |  0.00
Modify  | 0.6712     | 0.6712     | 0.6712     |   0.0 |  0.34
Other   |            | 0.0972     |            |       |  0.05

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

Total # of neighbors = 311200
Ave neighs/atom = 77.8
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.394711714044, Press = -0.258220144364164
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13857.355     -13857.355     -14009.62      -14009.62       294.56752      294.56752      47929.876      47929.876     -255.55491     -255.55491    
     26000  -13859.999     -13859.999     -14008.805     -14008.805      287.87674      287.87674      47899.268      47899.268      616.98647      616.98647    
Loop time of 199.077 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.299 hours/ns, 5.023 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    | 198.16     | 198.16     | 198.16     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14231    | 0.14231    | 0.14231    |   0.0 |  0.07
Output  | 0.00019267 | 0.00019267 | 0.00019267 |   0.0 |  0.00
Modify  | 0.67222    | 0.67222    | 0.67222    |   0.0 |  0.34
Other   |            | 0.09806    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.363523374626, Press = 1.38347964501316
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13859.999     -13859.999     -14008.805     -14008.805      287.87674      287.87674      47899.268      47899.268      616.98647      616.98647    
     27000  -13856.99      -13856.99      -14008.661     -14008.661      293.41737      293.41737      47939.138      47939.138     -449.22373     -449.22373    
Loop time of 198.917 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.255 hours/ns, 5.027 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    | 198        | 198        | 198        |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14138    | 0.14138    | 0.14138    |   0.0 |  0.07
Output  | 0.00019427 | 0.00019427 | 0.00019427 |   0.0 |  0.00
Modify  | 0.67317    | 0.67317    | 0.67317    |   0.0 |  0.34
Other   |            | 0.09708    |            |       |  0.05

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

Total # of neighbors = 311218
Ave neighs/atom = 77.8045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.353744014702, Press = -1.33137161861735
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13856.99      -13856.99      -14008.661     -14008.661      293.41737      293.41737      47939.138      47939.138     -449.22373     -449.22373    
     28000  -13860.253     -13860.253     -14010.411     -14010.411      290.49099      290.49099      47889.841      47889.841      658.98427      658.98427    
Loop time of 198.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.261 hours/ns, 5.027 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.03     | 198.03     | 198.03     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14173    | 0.14173    | 0.14173    |   0.0 |  0.07
Output  | 0.00019413 | 0.00019413 | 0.00019413 |   0.0 |  0.00
Modify  | 0.671      | 0.671      | 0.671      |   0.0 |  0.34
Other   |            | 0.09877    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.268554655889, Press = 3.433169821899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13860.253     -13860.253     -14010.411     -14010.411      290.49099      290.49099      47889.841      47889.841      658.98427      658.98427    
     29000  -13856.695     -13856.695     -14006.256     -14006.256      289.33496      289.33496      47929.166      47929.166      23.950607      23.950607    
Loop time of 199 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.278 hours/ns, 5.025 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    | 198.09     | 198.09     | 198.09     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14135    | 0.14135    | 0.14135    |   0.0 |  0.07
Output  | 0.00019367 | 0.00019367 | 0.00019367 |   0.0 |  0.00
Modify  | 0.67255    | 0.67255    | 0.67255    |   0.0 |  0.34
Other   |            | 0.09741    |            |       |  0.05

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

Total # of neighbors = 311268
Ave neighs/atom = 77.817
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.228720262386, Press = -2.17184340225165
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13856.695     -13856.695     -14006.256     -14006.256      289.33496      289.33496      47929.166      47929.166      23.950607      23.950607    
     30000  -13857.146     -13857.146     -14008.113     -14008.113      292.05637      292.05637      47929.679      47929.679     -122.17279     -122.17279    
Loop time of 199.099 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.305 hours/ns, 5.023 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    | 198.19     | 198.19     | 198.19     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1409     | 0.1409     | 0.1409     |   0.0 |  0.07
Output  | 0.00024859 | 0.00024859 | 0.00024859 |   0.0 |  0.00
Modify  | 0.67218    | 0.67218    | 0.67218    |   0.0 |  0.34
Other   |            | 0.09888    |            |       |  0.05

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

Total # of neighbors = 311020
Ave neighs/atom = 77.755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.184101453773, Press = 2.3397327276008
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13857.146     -13857.146     -14008.113     -14008.113      292.05637      292.05637      47929.679      47929.679     -122.17279     -122.17279    
     31000  -13863.727     -13863.727     -14012.666     -14012.666      288.1329       288.1329       47896.001      47896.001      376.43792      376.43792    
Loop time of 198.86 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.239 hours/ns, 5.029 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    | 197.95     | 197.95     | 197.95     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14254    | 0.14254    | 0.14254    |   0.0 |  0.07
Output  | 0.0001949  | 0.0001949  | 0.0001949  |   0.0 |  0.00
Modify  | 0.6715     | 0.6715     | 0.6715     |   0.0 |  0.34
Other   |            | 0.0985     |            |       |  0.05

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

Total # of neighbors = 311190
Ave neighs/atom = 77.7975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.184402409816, Press = -0.497209694331149
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13863.727     -13863.727     -14012.666     -14012.666      288.1329       288.1329       47896.001      47896.001      376.43792      376.43792    
     32000  -13857.067     -13857.067     -14006.718     -14006.718      289.51127      289.51127      47939.51       47939.51      -236.96928     -236.96928    
Loop time of 198.78 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.217 hours/ns, 5.031 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.87     | 197.87     | 197.87     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14311    | 0.14311    | 0.14311    |   0.0 |  0.07
Output  | 0.00019309 | 0.00019309 | 0.00019309 |   0.0 |  0.00
Modify  | 0.6707     | 0.6707     | 0.6707     |   0.0 |  0.34
Other   |            | 0.09757    |            |       |  0.05

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

Total # of neighbors = 311438
Ave neighs/atom = 77.8595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.147931812498, Press = 1.20252641932143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13857.067     -13857.067     -14006.718     -14006.718      289.51127      289.51127      47939.51       47939.51      -236.96928     -236.96928    
     33000  -13860.333     -13860.333     -14013.14      -14013.14       295.61538      295.61538      47905.852      47905.852     -27.810141     -27.810141    
Loop time of 198.721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.200 hours/ns, 5.032 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.81     | 197.81     | 197.81     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13974    | 0.13974    | 0.13974    |   0.0 |  0.07
Output  | 0.00019384 | 0.00019384 | 0.00019384 |   0.0 |  0.00
Modify  | 0.67325    | 0.67325    | 0.67325    |   0.0 |  0.34
Other   |            | 0.09734    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.078432795776, Press = -1.40938915104425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13860.333     -13860.333     -14013.14      -14013.14       295.61538      295.61538      47905.852      47905.852     -27.810141     -27.810141    
     34000  -13858.88      -13858.88      -14009.147     -14009.147      290.70077      290.70077      47925.009      47925.009     -126.09894     -126.09894    
Loop time of 199.031 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.286 hours/ns, 5.024 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.12     | 198.12     | 198.12     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14157    | 0.14157    | 0.14157    |   0.0 |  0.07
Output  | 0.00019224 | 0.00019224 | 0.00019224 |   0.0 |  0.00
Modify  | 0.67258    | 0.67258    | 0.67258    |   0.0 |  0.34
Other   |            | 0.09716    |            |       |  0.05

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

Total # of neighbors = 311252
Ave neighs/atom = 77.813
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.099680724834, Press = 2.97771949427466
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13858.88      -13858.88      -14009.147     -14009.147      290.70077      290.70077      47925.009      47925.009     -126.09894     -126.09894    
     35000  -13852.758     -13852.758     -14006.17      -14006.17       296.78598      296.78598      47937.69       47937.69      -129.83627     -129.83627    
Loop time of 198.968 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.269 hours/ns, 5.026 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.05     | 198.05     | 198.05     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14203    | 0.14203    | 0.14203    |   0.0 |  0.07
Output  | 0.00024797 | 0.00024797 | 0.00024797 |   0.0 |  0.00
Modify  | 0.67139    | 0.67139    | 0.67139    |   0.0 |  0.34
Other   |            | 0.09964    |            |       |  0.05

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

Total # of neighbors = 311228
Ave neighs/atom = 77.807
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.156065554214, Press = -1.28732545323768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13852.758     -13852.758     -14006.17      -14006.17       296.78598      296.78598      47937.69       47937.69      -129.83627     -129.83627    
     36000  -13856.877     -13856.877     -14007.523     -14007.523      291.43451      291.43451      47910.709      47910.709      460.26278      460.26278    
Loop time of 198.965 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.268 hours/ns, 5.026 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.05     | 198.05     | 198.05     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14184    | 0.14184    | 0.14184    |   0.0 |  0.07
Output  | 0.00019272 | 0.00019272 | 0.00019272 |   0.0 |  0.00
Modify  | 0.67327    | 0.67327    | 0.67327    |   0.0 |  0.34
Other   |            | 0.09763    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.168191183664, Press = 1.63274170167031
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13856.877     -13856.877     -14007.523     -14007.523      291.43451      291.43451      47910.709      47910.709      460.26278      460.26278    
     37000  -13857.421     -13857.421     -14007.45      -14007.45       290.24164      290.24164      47929.841      47929.841     -56.097991     -56.097991    
Loop time of 199.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.379 hours/ns, 5.016 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.45     | 198.45     | 198.45     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14137    | 0.14137    | 0.14137    |   0.0 |  0.07
Output  | 0.00019306 | 0.00019306 | 0.00019306 |   0.0 |  0.00
Modify  | 0.67352    | 0.67352    | 0.67352    |   0.0 |  0.34
Other   |            | 0.09818    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.226544238096, Press = -0.281172338573664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13857.421     -13857.421     -14007.45      -14007.45       290.24164      290.24164      47929.841      47929.841     -56.097991     -56.097991    
     38000  -13851.765     -13851.765     -14006.618     -14006.618      299.57268      299.57268      47922.508      47922.508      352.11692      352.11692    
Loop time of 199.476 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.410 hours/ns, 5.013 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    | 198.56     | 198.56     | 198.56     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14159    | 0.14159    | 0.14159    |   0.0 |  0.07
Output  | 0.00024847 | 0.00024847 | 0.00024847 |   0.0 |  0.00
Modify  | 0.67541    | 0.67541    | 0.67541    |   0.0 |  0.34
Other   |            | 0.09857    |            |       |  0.05

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

Total # of neighbors = 311132
Ave neighs/atom = 77.783
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.264719106345, Press = 1.61831811267087
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13851.765     -13851.765     -14006.618     -14006.618      299.57268      299.57268      47922.508      47922.508      352.11692      352.11692    
     39000  -13856.237     -13856.237     -14008.36      -14008.36       294.2929       294.2929       47939.556      47939.556     -349.09989     -349.09989    
Loop time of 199.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.316 hours/ns, 5.022 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.22     | 198.22     | 198.22     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14169    | 0.14169    | 0.14169    |   0.0 |  0.07
Output  | 0.00019289 | 0.00019289 | 0.00019289 |   0.0 |  0.00
Modify  | 0.67271    | 0.67271    | 0.67271    |   0.0 |  0.34
Other   |            | 0.09774    |            |       |  0.05

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

Total # of neighbors = 311192
Ave neighs/atom = 77.798
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.2661061917, Press = -0.978702616605801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13856.237     -13856.237     -14008.36      -14008.36       294.2929       294.2929       47939.556      47939.556     -349.09989     -349.09989    
     40000  -13863.407     -13863.407     -14012.219     -14012.219      287.88818      287.88818      47908.264      47908.264     -86.594608     -86.594608    
Loop time of 198.805 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.224 hours/ns, 5.030 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.89     | 197.89     | 197.89     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14157    | 0.14157    | 0.14157    |   0.0 |  0.07
Output  | 0.00019266 | 0.00019266 | 0.00019266 |   0.0 |  0.00
Modify  | 0.67195    | 0.67195    | 0.67195    |   0.0 |  0.34
Other   |            | 0.09835    |            |       |  0.05

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

Total # of neighbors = 311230
Ave neighs/atom = 77.8075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.236570862138, Press = 2.22383624456594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13863.407     -13863.407     -14012.219     -14012.219      287.88818      287.88818      47908.264      47908.264     -86.594608     -86.594608    
     41000  -13855.184     -13855.184     -14009.069     -14009.069      297.7003       297.7003       47931.769      47931.769     -208.08449     -208.08449    
Loop time of 198.856 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.238 hours/ns, 5.029 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    | 197.94     | 197.94     | 197.94     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14261    | 0.14261    | 0.14261    |   0.0 |  0.07
Output  | 0.00019302 | 0.00019302 | 0.00019302 |   0.0 |  0.00
Modify  | 0.67315    | 0.67315    | 0.67315    |   0.0 |  0.34
Other   |            | 0.09767    |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.288 hours/ns, 5.024 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    | 198.13     | 198.13     | 198.13     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14202    | 0.14202    | 0.14202    |   0.0 |  0.07
Output  | 0.00019255 | 0.00019255 | 0.00019255 |   0.0 |  0.00
Modify  | 0.67243    | 0.67243    | 0.67243    |   0.0 |  0.34
Other   |            | 0.0975     |            |       |  0.05

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

Total # of neighbors = 311232
Ave neighs/atom = 77.808
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.198215038389, Press = 1.17110367576023
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13853.878     -13853.878     -14005.453     -14005.453      293.23095      293.23095      47941.079      47941.079     -98.147297     -98.147297    
     43000  -13859.222     -13859.222     -14010.282     -14010.282      292.2372       292.2372       47915.156      47915.156      78.107207      78.107207    
Loop time of 198.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.230 hours/ns, 5.029 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    | 197.92     | 197.92     | 197.92     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1417     | 0.1417     | 0.1417     |   0.0 |  0.07
Output  | 0.00019338 | 0.00019338 | 0.00019338 |   0.0 |  0.00
Modify  | 0.67303    | 0.67303    | 0.67303    |   0.0 |  0.34
Other   |            | 0.09823    |            |       |  0.05

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

Total # of neighbors = 311224
Ave neighs/atom = 77.806
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.206413529425, Press = -0.913934313685349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13859.222     -13859.222     -14010.282     -14010.282      292.2372       292.2372       47915.156      47915.156      78.107207      78.107207    
     44000  -13857.723     -13857.723     -14005.891     -14005.891      286.6418       286.6418       47925          47925          227.14753      227.14753    
Loop time of 198.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.277 hours/ns, 5.025 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    | 198.08     | 198.08     | 198.08     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14183    | 0.14183    | 0.14183    |   0.0 |  0.07
Output  | 0.00019422 | 0.00019422 | 0.00019422 |   0.0 |  0.00
Modify  | 0.6738     | 0.6738     | 0.6738     |   0.0 |  0.34
Other   |            | 0.09751    |            |       |  0.05

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

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

Performance: 0.435 ns/day, 55.172 hours/ns, 5.035 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    | 197.71     | 197.71     | 197.71     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14062    | 0.14062    | 0.14062    |   0.0 |  0.07
Output  | 0.00019157 | 0.00019157 | 0.00019157 |   0.0 |  0.00
Modify  | 0.67204    | 0.67204    | 0.67204    |   0.0 |  0.34
Other   |            | 0.09813    |            |       |  0.05

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

Total # of neighbors = 311234
Ave neighs/atom = 77.8085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.132512498983, Press = -0.561096824254039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13861.468     -13861.468     -14010.902     -14010.902      289.08947      289.08947      47909.661      47909.661      147.238        147.238      
     46000  -13858.607     -13858.607     -14010.125     -14010.125      293.12295      293.12295      47928.595      47928.595     -265.12848     -265.12848    
Loop time of 199.137 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.316 hours/ns, 5.022 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    | 198.22     | 198.22     | 198.22     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14198    | 0.14198    | 0.14198    |   0.0 |  0.07
Output  | 0.00025007 | 0.00025007 | 0.00025007 |   0.0 |  0.00
Modify  | 0.67189    | 0.67189    | 0.67189    |   0.0 |  0.34
Other   |            | 0.09812    |            |       |  0.05

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

Total # of neighbors = 311222
Ave neighs/atom = 77.8055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.139941116247, Press = 0.608210940162508
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13858.607     -13858.607     -14010.125     -14010.125      293.12295      293.12295      47928.595      47928.595     -265.12848     -265.12848    
     47000  -13857.133     -13857.133     -14009.38      -14009.38       294.53244      294.53244      47916.409      47916.409      239.03176      239.03176    
Loop time of 199.097 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.305 hours/ns, 5.023 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.18     | 198.18     | 198.18     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14087    | 0.14087    | 0.14087    |   0.0 |  0.07
Output  | 0.00024476 | 0.00024476 | 0.00024476 |   0.0 |  0.00
Modify  | 0.67398    | 0.67398    | 0.67398    |   0.0 |  0.34
Other   |            | 0.09794    |            |       |  0.05

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

Total # of neighbors = 311196
Ave neighs/atom = 77.799
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.164530308985, Press = 0.337669497760505
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, 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  -13857.133     -13857.133     -14009.38      -14009.38       294.53244      294.53244      47916.409      47916.409      239.03176      239.03176    
     48000  -13854.033     -13854.033     -14009.268     -14009.268      300.31257      300.31257      47937.378      47937.378     -393.11801     -393.11801    
Loop time of 199.108 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.308 hours/ns, 5.022 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.2      | 198.2      | 198.2      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14098    | 0.14098    | 0.14098    |   0.0 |  0.07
Output  | 0.00019285 | 0.00019285 | 0.00019285 |   0.0 |  0.00
Modify  | 0.67354    | 0.67354    | 0.67354    |   0.0 |  0.34
Other   |            | 0.09832    |            |       |  0.05

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

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

Performance: 0.435 ns/day, 55.233 hours/ns, 5.029 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.93     | 197.93     | 197.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14092    | 0.14092    | 0.14092    |   0.0 |  0.07
Output  | 0.00019186 | 0.00019186 | 0.00019186 |   0.0 |  0.00
Modify  | 0.67342    | 0.67342    | 0.67342    |   0.0 |  0.34
Other   |            | 0.09842    |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.240 hours/ns, 5.029 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    | 197.95     | 197.95     | 197.95     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14192    | 0.14192    | 0.14192    |   0.0 |  0.07
Output  | 0.00019297 | 0.00019297 | 0.00019297 |   0.0 |  0.00
Modify  | 0.67308    | 0.67308    | 0.67308    |   0.0 |  0.34
Other   |            | 0.0971     |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.253 hours/ns, 5.027 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    | 198        | 198        | 198        |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14187    | 0.14187    | 0.14187    |   0.0 |  0.07
Output  | 0.00019228 | 0.00019228 | 0.00019228 |   0.0 |  0.00
Modify  | 0.67346    | 0.67346    | 0.67346    |   0.0 |  0.34
Other   |            | 0.09827    |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.266 hours/ns, 5.026 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    | 198.04     | 198.04     | 198.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14133    | 0.14133    | 0.14133    |   0.0 |  0.07
Output  | 0.00046188 | 0.00046188 | 0.00046188 |   0.0 |  0.00
Modify  | 0.67323    | 0.67323    | 0.67323    |   0.0 |  0.34
Other   |            | 0.09821    |            |       |  0.05

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

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

Performance: 0.435 ns/day, 55.215 hours/ns, 5.031 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.86     | 197.86     | 197.86     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14244    | 0.14244    | 0.14244    |   0.0 |  0.07
Output  | 0.00019344 | 0.00019344 | 0.00019344 |   0.0 |  0.00
Modify  | 0.67178    | 0.67178    | 0.67178    |   0.0 |  0.34
Other   |            | 0.09824    |            |       |  0.05

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

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

Performance: 0.435 ns/day, 55.219 hours/ns, 5.030 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.88     | 197.88     | 197.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14156    | 0.14156    | 0.14156    |   0.0 |  0.07
Output  | 0.00019573 | 0.00019573 | 0.00019573 |   0.0 |  0.00
Modify  | 0.67424    | 0.67424    | 0.67424    |   0.0 |  0.34
Other   |            | 0.09735    |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.266 hours/ns, 5.026 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.05     | 198.05     | 198.05     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14116    | 0.14116    | 0.14116    |   0.0 |  0.07
Output  | 0.00019378 | 0.00019378 | 0.00019378 |   0.0 |  0.00
Modify  | 0.67186    | 0.67186    | 0.67186    |   0.0 |  0.34
Other   |            | 0.09809    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.287863624454, Press = 0.534142867210907
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13854.316     -13854.316     -14006.766     -14006.766      294.92477      294.92477      47944.47       47944.47      -260.95862     -260.95862    
     56000  -13858.636     -13858.636     -14009.729     -14009.729      292.29899      292.29899      47900.941      47900.941      595.85759      595.85759    
Loop time of 198.872 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.242 hours/ns, 5.028 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    | 197.96     | 197.96     | 197.96     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14191    | 0.14191    | 0.14191    |   0.0 |  0.07
Output  | 0.00019437 | 0.00019437 | 0.00019437 |   0.0 |  0.00
Modify  | 0.67369    | 0.67369    | 0.67369    |   0.0 |  0.34
Other   |            | 0.09806    |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.267 hours/ns, 5.026 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    | 198.05     | 198.05     | 198.05     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14147    | 0.14147    | 0.14147    |   0.0 |  0.07
Output  | 0.00019347 | 0.00019347 | 0.00019347 |   0.0 |  0.00
Modify  | 0.67385    | 0.67385    | 0.67385    |   0.0 |  0.34
Other   |            | 0.0975     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.247386666185, Press = 0.79141090992261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13857.85      -13857.85      -14009.644     -14009.644      293.65561      293.65561      47966.627      47966.627     -1327.4821     -1327.4821    
     58000  -13859.998     -13859.998     -14010.082     -14010.082      290.347        290.347        47844.98       47844.98       2122.0636      2122.0636    
Loop time of 199.036 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.288 hours/ns, 5.024 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    | 198.12     | 198.12     | 198.12     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14128    | 0.14128    | 0.14128    |   0.0 |  0.07
Output  | 0.0001931  | 0.0001931  | 0.0001931  |   0.0 |  0.00
Modify  | 0.67348    | 0.67348    | 0.67348    |   0.0 |  0.34
Other   |            | 0.09744    |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.332 hours/ns, 5.020 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    | 198.28     | 198.28     | 198.28     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14193    | 0.14193    | 0.14193    |   0.0 |  0.07
Output  | 0.00019562 | 0.00019562 | 0.00019562 |   0.0 |  0.00
Modify  | 0.67281    | 0.67281    | 0.67281    |   0.0 |  0.34
Other   |            | 0.09824    |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.325 hours/ns, 5.021 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    | 198.26     | 198.26     | 198.26     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14258    | 0.14258    | 0.14258    |   0.0 |  0.07
Output  | 0.00019317 | 0.00019317 | 0.00019317 |   0.0 |  0.00
Modify  | 0.67264    | 0.67264    | 0.67264    |   0.0 |  0.34
Other   |            | 0.0973     |            |       |  0.05

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

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

Performance: 0.435 ns/day, 55.207 hours/ns, 5.032 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    | 197.83     | 197.83     | 197.83     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14216    | 0.14216    | 0.14216    |   0.0 |  0.07
Output  | 0.00019376 | 0.00019376 | 0.00019376 |   0.0 |  0.00
Modify  | 0.67163    | 0.67163    | 0.67163    |   0.0 |  0.34
Other   |            | 0.09828    |            |       |  0.05

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

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

Performance: 0.435 ns/day, 55.229 hours/ns, 5.030 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    | 197.91     | 197.91     | 197.91     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14269    | 0.14269    | 0.14269    |   0.0 |  0.07
Output  | 0.0001943  | 0.0001943  | 0.0001943  |   0.0 |  0.00
Modify  | 0.67394    | 0.67394    | 0.67394    |   0.0 |  0.34
Other   |            | 0.09688    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.200549735578, Press = -0.379788250404085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13856.015     -13856.015     -14007.677     -14007.677      293.40077      293.40077      47915.449      47915.449      352.5608       352.5608     
     63000  -13860.543     -13860.543     -14011.177     -14011.177      291.41115      291.41115      47923.863      47923.863     -340.25832     -340.25832    
Loop time of 199.176 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.327 hours/ns, 5.021 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    | 198.26     | 198.26     | 198.26     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14094    | 0.14094    | 0.14094    |   0.0 |  0.07
Output  | 0.00019326 | 0.00019326 | 0.00019326 |   0.0 |  0.00
Modify  | 0.6734     | 0.6734     | 0.6734     |   0.0 |  0.34
Other   |            | 0.09835    |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.287 hours/ns, 5.024 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    | 198.12     | 198.12     | 198.12     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14227    | 0.14227    | 0.14227    |   0.0 |  0.07
Output  | 0.00024515 | 0.00024515 | 0.00024515 |   0.0 |  0.00
Modify  | 0.67239    | 0.67239    | 0.67239    |   0.0 |  0.34
Other   |            | 0.09762    |            |       |  0.05

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0