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

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_Wagner_2007_Ni__MO_444394830472_002
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43614.2081218568 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_444394830472_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 = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17648.467     -17648.467     -17800         -17800          293.15         293.15         43614.208      43614.208      3711.034       3711.034     
      1000  -17485.853     -17485.853     -17638.34      -17638.34       294.99658      294.99658      43916.26       43916.26       2607.2445      2607.2445    
Loop time of 32.63 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.648 ns/day, 9.064 hours/ns, 30.647 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.478     | 32.478     | 32.478     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022114   | 0.022114   | 0.022114   |   0.0 |  0.07
Output  | 0.0002133  | 0.0002133  | 0.0002133  |   0.0 |  0.00
Modify  | 0.11917    | 0.11917    | 0.11917    |   0.0 |  0.37
Other   |            | 0.01091    |            |       |  0.03

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

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17485.853     -17485.853     -17638.34      -17638.34       294.99658      294.99658      43916.26       43916.26       2607.2445      2607.2445    
      2000  -17491.43      -17491.43      -17642.065     -17642.065      291.41371      291.41371      43945.206      43945.206      1060.2476      1060.2476    
Loop time of 36.4415 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.371 ns/day, 10.123 hours/ns, 27.441 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.292     | 36.292     | 36.292     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021694   | 0.021694   | 0.021694   |   0.0 |  0.06
Output  | 0.00011383 | 0.00011383 | 0.00011383 |   0.0 |  0.00
Modify  | 0.11744    | 0.11744    | 0.11744    |   0.0 |  0.32
Other   |            | 0.01038    |            |       |  0.03

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

Total # of neighbors = 314950
Ave neighs/atom = 78.7375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17491.43      -17491.43      -17642.065     -17642.065      291.41371      291.41371      43945.206      43945.206      1060.2476      1060.2476    
      3000  -17494.778     -17494.778     -17645.929     -17645.929      292.41065      292.41065      43953.73       43953.73       545.40377      545.40377    
Loop time of 36.5597 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.363 ns/day, 10.155 hours/ns, 27.353 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.41      | 36.41      | 36.41      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021582   | 0.021582   | 0.021582   |   0.0 |  0.06
Output  | 8.1093e-05 | 8.1093e-05 | 8.1093e-05 |   0.0 |  0.00
Modify  | 0.11726    | 0.11726    | 0.11726    |   0.0 |  0.32
Other   |            | 0.01036    |            |       |  0.03

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

Total # of neighbors = 314790
Ave neighs/atom = 78.6975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17494.778     -17494.778     -17645.929     -17645.929      292.41065      292.41065      43953.73       43953.73       545.40377      545.40377    
      4000  -17487.856     -17487.856     -17642.602     -17642.602      299.36639      299.36639      43958.466      43958.466      643.31933      643.31933    
Loop time of 36.6428 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.358 ns/day, 10.179 hours/ns, 27.291 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.494     | 36.494     | 36.494     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021525   | 0.021525   | 0.021525   |   0.0 |  0.06
Output  | 6.911e-05  | 6.911e-05  | 6.911e-05  |   0.0 |  0.00
Modify  | 0.11719    | 0.11719    | 0.11719    |   0.0 |  0.32
Other   |            | 0.01037    |            |       |  0.03

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

Total # of neighbors = 314570
Ave neighs/atom = 78.6425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17487.856     -17487.856     -17642.602     -17642.602      299.36639      299.36639      43958.466      43958.466      643.31933      643.31933    
      5000  -17495.89      -17495.89      -17645.141     -17645.141      288.73628      288.73628      43938.559      43938.559      1126.2138      1126.2138    
Loop time of 36.6032 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.360 ns/day, 10.168 hours/ns, 27.320 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.454     | 36.454     | 36.454     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02154    | 0.02154    | 0.02154    |   0.0 |  0.06
Output  | 7.2156e-05 | 7.2156e-05 | 7.2156e-05 |   0.0 |  0.00
Modify  | 0.11762    | 0.11762    | 0.11762    |   0.0 |  0.32
Other   |            | 0.01041    |            |       |  0.03

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

Total # of neighbors = 314766
Ave neighs/atom = 78.6915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 289.995443849686, Press = 136.614236024271
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17495.89      -17495.89      -17645.141     -17645.141      288.73628      288.73628      43938.559      43938.559      1126.2138      1126.2138    
      6000  -17492.172     -17492.172     -17642.526     -17642.526      290.87064      290.87064      43905.894      43905.894      2556.0707      2556.0707    
Loop time of 36.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.363 ns/day, 10.157 hours/ns, 27.347 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.414     | 36.414     | 36.414     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021702   | 0.021702   | 0.021702   |   0.0 |  0.06
Output  | 5.308e-05  | 5.308e-05  | 5.308e-05  |   0.0 |  0.00
Modify  | 0.12095    | 0.12095    | 0.12095    |   0.0 |  0.33
Other   |            | 0.01041    |            |       |  0.03

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

Total # of neighbors = 314884
Ave neighs/atom = 78.721
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.338185220588, Press = 12.6144376899197
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17492.172     -17492.172     -17642.526     -17642.526      290.87064      290.87064      43905.894      43905.894      2556.0707      2556.0707    
      7000  -17489.256     -17489.256     -17639.829     -17639.829      291.29474      291.29474      43920.393      43920.393      2130.4303      2130.4303    
Loop time of 36.5574 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.363 ns/day, 10.155 hours/ns, 27.354 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.404     | 36.404     | 36.404     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021534   | 0.021534   | 0.021534   |   0.0 |  0.06
Output  | 4.4173e-05 | 4.4173e-05 | 4.4173e-05 |   0.0 |  0.00
Modify  | 0.12098    | 0.12098    | 0.12098    |   0.0 |  0.33
Other   |            | 0.01036    |            |       |  0.03

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

Total # of neighbors = 314950
Ave neighs/atom = 78.7375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.959546424701, Press = 13.2841128973529
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17489.256     -17489.256     -17639.829     -17639.829      291.29474      291.29474      43920.393      43920.393      2130.4303      2130.4303    
      8000  -17494.671     -17494.671     -17645.035     -17645.035      290.88971      290.88971      43937.508      43937.508      1105.5953      1105.5953    
Loop time of 36.6571 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.357 ns/day, 10.183 hours/ns, 27.280 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.504     | 36.504     | 36.504     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021624   | 0.021624   | 0.021624   |   0.0 |  0.06
Output  | 6.6275e-05 | 6.6275e-05 | 6.6275e-05 |   0.0 |  0.00
Modify  | 0.12088    | 0.12088    | 0.12088    |   0.0 |  0.33
Other   |            | 0.01039    |            |       |  0.03

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

Total # of neighbors = 315054
Ave neighs/atom = 78.7635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.023088694357, Press = 6.17445452505577
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17494.671     -17494.671     -17645.035     -17645.035      290.88971      290.88971      43937.508      43937.508      1105.5953      1105.5953    
      9000  -17491.71      -17491.71      -17644.188     -17644.188      294.97872      294.97872      43955.66       43955.66       612.11129      612.11129    
Loop time of 36.5508 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.364 ns/day, 10.153 hours/ns, 27.359 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.398     | 36.398     | 36.398     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021606   | 0.021606   | 0.021606   |   0.0 |  0.06
Output  | 4.8571e-05 | 4.8571e-05 | 4.8571e-05 |   0.0 |  0.00
Modify  | 0.12079    | 0.12079    | 0.12079    |   0.0 |  0.33
Other   |            | 0.01033    |            |       |  0.03

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

Total # of neighbors = 314852
Ave neighs/atom = 78.713
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.890294675709, Press = 0.928354422622483
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17491.71      -17491.71      -17644.188     -17644.188      294.97872      294.97872      43955.66       43955.66       612.11129      612.11129    
     10000  -17497.665     -17497.665     -17648.085     -17648.085      290.99709      290.99709      43946.526      43946.526      647.76004      647.76004    
Loop time of 36.5787 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.362 ns/day, 10.161 hours/ns, 27.338 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.426     | 36.426     | 36.426     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02158    | 0.02158    | 0.02158    |   0.0 |  0.06
Output  | 5.859e-05  | 5.859e-05  | 5.859e-05  |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.33
Other   |            | 0.01036    |            |       |  0.03

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

Total # of neighbors = 314796
Ave neighs/atom = 78.699
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.771140741349, Press = 0.360011064307478
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17497.665     -17497.665     -17648.085     -17648.085      290.99709      290.99709      43946.526      43946.526      647.76004      647.76004    
     11000  -17490.946     -17490.946     -17643.234     -17643.234      294.61196      294.61196      43952.674      43952.674      788.46195      788.46195    
Loop time of 36.6148 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.360 ns/day, 10.171 hours/ns, 27.311 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.462     | 36.462     | 36.462     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02153    | 0.02153    | 0.02153    |   0.0 |  0.06
Output  | 5.286e-05  | 5.286e-05  | 5.286e-05  |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.33
Other   |            | 0.01037    |            |       |  0.03

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

Total # of neighbors = 314790
Ave neighs/atom = 78.6975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.607891470116, Press = 1.6838572285672
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17490.946     -17490.946     -17643.234     -17643.234      294.61196      294.61196      43952.674      43952.674      788.46195      788.46195    
     12000  -17493.107     -17493.107     -17644.904     -17644.904      293.66083      293.66083      43950.392      43950.392      774.34262      774.34262    
Loop time of 36.6028 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.360 ns/day, 10.167 hours/ns, 27.320 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.45      | 36.45      | 36.45      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021537   | 0.021537   | 0.021537   |   0.0 |  0.06
Output  | 3.9153e-05 | 3.9153e-05 | 3.9153e-05 |   0.0 |  0.00
Modify  | 0.12069    | 0.12069    | 0.12069    |   0.0 |  0.33
Other   |            | 0.01032    |            |       |  0.03

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

Total # of neighbors = 314916
Ave neighs/atom = 78.729
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.653190079027, Press = 2.95333006389854
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17493.107     -17493.107     -17644.904     -17644.904      293.66083      293.66083      43950.392      43950.392      774.34262      774.34262    
     13000  -17493.564     -17493.564     -17644.528     -17644.528      292.0514       292.0514       43956.805      43956.805      498.80146      498.80146    
Loop time of 36.628 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.359 ns/day, 10.174 hours/ns, 27.302 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.475     | 36.475     | 36.475     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021444   | 0.021444   | 0.021444   |   0.0 |  0.06
Output  | 5.4493e-05 | 5.4493e-05 | 5.4493e-05 |   0.0 |  0.00
Modify  | 0.12079    | 0.12079    | 0.12079    |   0.0 |  0.33
Other   |            | 0.01033    |            |       |  0.03

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

Total # of neighbors = 314788
Ave neighs/atom = 78.697
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.901945164779, Press = 5.68942647793614
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17493.564     -17493.564     -17644.528     -17644.528      292.0514       292.0514       43956.805      43956.805      498.80146      498.80146    
     14000  -17489.194     -17489.194     -17642.235     -17642.235      296.06796      296.06796      43967.537      43967.537      257.48278      257.48278    
Loop time of 36.6591 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.357 ns/day, 10.183 hours/ns, 27.278 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.506     | 36.506     | 36.506     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021578   | 0.021578   | 0.021578   |   0.0 |  0.06
Output  | 9.569e-05  | 9.569e-05  | 9.569e-05  |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.33
Other   |            | 0.01027    |            |       |  0.03

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

Total # of neighbors = 314850
Ave neighs/atom = 78.7125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.077094259397, Press = 6.61360851693897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17489.194     -17489.194     -17642.235     -17642.235      296.06796      296.06796      43967.537      43967.537      257.48278      257.48278    
     15000  -17493.291     -17493.291     -17644.589     -17644.589      292.69671      292.69671      43974.224      43974.224     -165.29371     -165.29371    
Loop time of 36.6441 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.358 ns/day, 10.179 hours/ns, 27.290 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.491     | 36.491     | 36.491     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021521   | 0.021521   | 0.021521   |   0.0 |  0.06
Output  | 7.3308e-05 | 7.3308e-05 | 7.3308e-05 |   0.0 |  0.00
Modify  | 0.12082    | 0.12082    | 0.12082    |   0.0 |  0.33
Other   |            | 0.01033    |            |       |  0.03

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

Total # of neighbors = 314718
Ave neighs/atom = 78.6795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.017779309485, Press = 7.24734496649583
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17493.291     -17493.291     -17644.589     -17644.589      292.69671      292.69671      43974.224      43974.224     -165.29371     -165.29371    
     16000  -17493.519     -17493.519     -17642.314     -17642.314      287.85461      287.85461      43980.123      43980.123     -475.943       -475.943      
Loop time of 36.6733 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.356 ns/day, 10.187 hours/ns, 27.268 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.52      | 36.52      | 36.52      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021565   | 0.021565   | 0.021565   |   0.0 |  0.06
Output  | 5.9952e-05 | 5.9952e-05 | 5.9952e-05 |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.33
Other   |            | 0.01033    |            |       |  0.03

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

Total # of neighbors = 314714
Ave neighs/atom = 78.6785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.913350998355, Press = 5.0911998891721
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17493.519     -17493.519     -17642.314     -17642.314      287.85461      287.85461      43980.123      43980.123     -475.943       -475.943      
     17000  -17490.231     -17490.231     -17642.022     -17642.022      293.64954      293.64954      43984.104      43984.104     -463.99417     -463.99417    
Loop time of 36.6637 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.357 ns/day, 10.184 hours/ns, 27.275 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.511     | 36.511     | 36.511     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021557   | 0.021557   | 0.021557   |   0.0 |  0.06
Output  | 3.5256e-05 | 3.5256e-05 | 3.5256e-05 |   0.0 |  0.00
Modify  | 0.12085    | 0.12085    | 0.12085    |   0.0 |  0.33
Other   |            | 0.01033    |            |       |  0.03

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

Total # of neighbors = 314786
Ave neighs/atom = 78.6965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.83135555712, Press = 2.50502752805556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17490.231     -17490.231     -17642.022     -17642.022      293.64954      293.64954      43984.104      43984.104     -463.99417     -463.99417    
     18000  -17496.457     -17496.457     -17644.62      -17644.62       286.6304       286.6304       43981.345      43981.345     -584.68226     -584.68226    
Loop time of 36.6246 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.359 ns/day, 10.173 hours/ns, 27.304 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.472     | 36.472     | 36.472     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021757   | 0.021757   | 0.021757   |   0.0 |  0.06
Output  | 5.6055e-05 | 5.6055e-05 | 5.6055e-05 |   0.0 |  0.00
Modify  | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.33
Other   |            | 0.01034    |            |       |  0.03

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

Total # of neighbors = 314712
Ave neighs/atom = 78.678
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.739982805885, Press = 1.3043101938311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17496.457     -17496.457     -17644.62      -17644.62       286.6304       286.6304       43981.345      43981.345     -584.68226     -584.68226    
     19000  -17492.493     -17492.493     -17645.827     -17645.827      296.63403      296.63403      43979.426      43979.426     -543.75974     -543.75974    
Loop time of 36.6471 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.358 ns/day, 10.180 hours/ns, 27.287 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.494     | 36.494     | 36.494     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021614   | 0.021614   | 0.021614   |   0.0 |  0.06
Output  | 4.829e-05  | 4.829e-05  | 4.829e-05  |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.33
Other   |            | 0.01032    |            |       |  0.03

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

Total # of neighbors = 314720
Ave neighs/atom = 78.68
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.718143798331, Press = 0.0118251638936145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17492.493     -17492.493     -17645.827     -17645.827      296.63403      296.63403      43979.426      43979.426     -543.75974     -543.75974    
     20000  -17491.249     -17491.249     -17644.534     -17644.534      296.54132      296.54132      43995.669      43995.669     -1030.5089     -1030.5089    
Loop time of 36.5815 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.362 ns/day, 10.162 hours/ns, 27.336 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.429     | 36.429     | 36.429     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021473   | 0.021473   | 0.021473   |   0.0 |  0.06
Output  | 3.9484e-05 | 3.9484e-05 | 3.9484e-05 |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.33
Other   |            | 0.01029    |            |       |  0.03

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

Total # of neighbors = 314754
Ave neighs/atom = 78.6885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.641374999611, Press = 0.12757909809705
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17491.249     -17491.249     -17644.534     -17644.534      296.54132      296.54132      43995.669      43995.669     -1030.5089     -1030.5089    
     21000  -17493.513     -17493.513     -17644.2       -17644.2        291.51434      291.51434      44015.562      44015.562     -1918.3408     -1918.3408    
Loop time of 36.6388 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.358 ns/day, 10.177 hours/ns, 27.293 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.486     | 36.486     | 36.486     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021511   | 0.021511   | 0.021511   |   0.0 |  0.06
Output  | 5.3811e-05 | 5.3811e-05 | 5.3811e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.33
Other   |            | 0.01031    |            |       |  0.03

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

Total # of neighbors = 314684
Ave neighs/atom = 78.671
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.657324631999, Press = 0.263684870260845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17493.513     -17493.513     -17644.2       -17644.2        291.51434      291.51434      44015.562      44015.562     -1918.3408     -1918.3408    
     22000  -17493.849     -17493.849     -17644.285     -17644.285      291.02851      291.02851      44019.342      44019.342     -1976.6726     -1976.6726    
Loop time of 36.6183 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.359 ns/day, 10.172 hours/ns, 27.309 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.465     | 36.465     | 36.465     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021736   | 0.021736   | 0.021736   |   0.0 |  0.06
Output  | 3.8622e-05 | 3.8622e-05 | 3.8622e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.33
Other   |            | 0.01029    |            |       |  0.03

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

Total # of neighbors = 314708
Ave neighs/atom = 78.677
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.674231302892, Press = 0.343592221892669
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17493.849     -17493.849     -17644.285     -17644.285      291.02851      291.02851      44019.342      44019.342     -1976.6726     -1976.6726    
     23000  -17492.524     -17492.524     -17642.338     -17642.338      289.82601      289.82601      44014.85       44014.85      -1712.0649     -1712.0649    
Loop time of 36.4943 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.367 ns/day, 10.137 hours/ns, 27.402 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.342     | 36.342     | 36.342     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021485   | 0.021485   | 0.021485   |   0.0 |  0.06
Output  | 6.1165e-05 | 6.1165e-05 | 6.1165e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.33
Other   |            | 0.01034    |            |       |  0.03

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

Total # of neighbors = 314536
Ave neighs/atom = 78.634
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.557877075939, Press = 0.571690541836444
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17492.524     -17492.524     -17642.338     -17642.338      289.82601      289.82601      44014.85       44014.85      -1712.0649     -1712.0649    
     24000  -17496.216     -17496.216     -17643.422     -17643.422      284.77966      284.77966      44009.904      44009.904     -1756.8085     -1756.8085    
Loop time of 36.6243 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.359 ns/day, 10.173 hours/ns, 27.304 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.471     | 36.471     | 36.471     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021535   | 0.021535   | 0.021535   |   0.0 |  0.06
Output  | 5.7529e-05 | 5.7529e-05 | 5.7529e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.33
Other   |            | 0.01032    |            |       |  0.03

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

Total # of neighbors = 314630
Ave neighs/atom = 78.6575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.533624967565, Press = 0.797698898316816
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17496.216     -17496.216     -17643.422     -17643.422      284.77966      284.77966      44009.904      44009.904     -1756.8085     -1756.8085    
     25000  -17490.999     -17490.999     -17646.36      -17646.36       300.55583      300.55583      44019.213      44019.213     -2048.459      -2048.459     
Loop time of 36.6217 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.359 ns/day, 10.173 hours/ns, 27.306 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.469     | 36.469     | 36.469     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021567   | 0.021567   | 0.021567   |   0.0 |  0.06
Output  | 3.221e-05  | 3.221e-05  | 3.221e-05  |   0.0 |  0.00
Modify  | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.33
Other   |            | 0.0103     |            |       |  0.03

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

Total # of neighbors = 314604
Ave neighs/atom = 78.651
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.60227488554, Press = 0.355627003547593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17490.999     -17490.999     -17646.36      -17646.36       300.55583      300.55583      44019.213      44019.213     -2048.459      -2048.459     
     26000  -17494.018     -17494.018     -17645.227     -17645.227      292.52369      292.52369      44001.482      44001.482     -1428.4025     -1428.4025    
Loop time of 36.7849 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.349 ns/day, 10.218 hours/ns, 27.185 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.632     | 36.632     | 36.632     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021619   | 0.021619   | 0.021619   |   0.0 |  0.06
Output  | 5.2138e-05 | 5.2138e-05 | 5.2138e-05 |   0.0 |  0.00
Modify  | 0.12089    | 0.12089    | 0.12089    |   0.0 |  0.33
Other   |            | 0.01034    |            |       |  0.03

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

Total # of neighbors = 314502
Ave neighs/atom = 78.6255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.609153619162, Press = 0.13683855573181
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17494.018     -17494.018     -17645.227     -17645.227      292.52369      292.52369      44001.482      44001.482     -1428.4025     -1428.4025    
     27000  -17488.828     -17488.828     -17641.024     -17641.024      294.43233      294.43233      43991.953      43991.953     -782.89126     -782.89126    
Loop time of 36.8422 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.345 ns/day, 10.234 hours/ns, 27.143 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.689     | 36.689     | 36.689     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021673   | 0.021673   | 0.021673   |   0.0 |  0.06
Output  | 3.8111e-05 | 3.8111e-05 | 3.8111e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.33
Other   |            | 0.01036    |            |       |  0.03

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

Total # of neighbors = 314596
Ave neighs/atom = 78.649
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.664332933582, Press = -0.14970504004577
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17488.828     -17488.828     -17641.024     -17641.024      294.43233      294.43233      43991.953      43991.953     -782.89126     -782.89126    
     28000  -17489.47      -17489.47      -17643.266     -17643.266      297.52938      297.52938      43981.352      43981.352     -484.26944     -484.26944    
Loop time of 36.838 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.345 ns/day, 10.233 hours/ns, 27.146 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.684     | 36.684     | 36.684     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021707   | 0.021707   | 0.021707   |   0.0 |  0.06
Output  | 6.6134e-05 | 6.6134e-05 | 6.6134e-05 |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  0.33
Other   |            | 0.01037    |            |       |  0.03

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

Total # of neighbors = 314782
Ave neighs/atom = 78.6955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.663213884468, Press = -0.298860596842766
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17489.47      -17489.47      -17643.266     -17643.266      297.52938      297.52938      43981.352      43981.352     -484.26944     -484.26944    
     29000  -17494.049     -17494.049     -17645.189     -17645.189      292.39081      292.39081      43980.146      43980.146     -473.63264     -473.63264    
Loop time of 36.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.343 ns/day, 10.243 hours/ns, 27.119 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.721     | 36.721     | 36.721     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021712   | 0.021712   | 0.021712   |   0.0 |  0.06
Output  | 4.795e-05  | 4.795e-05  | 4.795e-05  |   0.0 |  0.00
Modify  | 0.12147    | 0.12147    | 0.12147    |   0.0 |  0.33
Other   |            | 0.01036    |            |       |  0.03

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

Total # of neighbors = 314698
Ave neighs/atom = 78.6745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.637573255268, Press = -0.720692033734591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17494.049     -17494.049     -17645.189     -17645.189      292.39081      292.39081      43980.146      43980.146     -473.63264     -473.63264    
     30000  -17494.539     -17494.539     -17644.976     -17644.976      291.03179      291.03179      43997.271      43997.271     -1044.0181     -1044.0181    
Loop time of 36.7972 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.348 ns/day, 10.221 hours/ns, 27.176 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.644     | 36.644     | 36.644     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021656   | 0.021656   | 0.021656   |   0.0 |  0.06
Output  | 3.3844e-05 | 3.3844e-05 | 3.3844e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.33
Other   |            | 0.01037    |            |       |  0.03

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

Total # of neighbors = 314592
Ave neighs/atom = 78.648
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.683291323569, Press = -0.400304720519078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17494.539     -17494.539     -17644.976     -17644.976      291.03179      291.03179      43997.271      43997.271     -1044.0181     -1044.0181    
     31000  -17488.549     -17488.549     -17641.134     -17641.134      295.18437      295.18437      44025.493      44025.493     -2009.5067     -2009.5067    
Loop time of 36.8913 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.342 ns/day, 10.248 hours/ns, 27.107 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.738     | 36.738     | 36.738     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021712   | 0.021712   | 0.021712   |   0.0 |  0.06
Output  | 4.7239e-05 | 4.7239e-05 | 4.7239e-05 |   0.0 |  0.00
Modify  | 0.12156    | 0.12156    | 0.12156    |   0.0 |  0.33
Other   |            | 0.01038    |            |       |  0.03

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

Total # of neighbors = 314648
Ave neighs/atom = 78.662
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.748089288955, Press = -0.820604282884744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17488.549     -17488.549     -17641.134     -17641.134      295.18437      295.18437      44025.493      44025.493     -2009.5067     -2009.5067    
     32000  -17495.591     -17495.591     -17644.328     -17644.328      287.74132      287.74132      44022.961      44022.961     -2160.6789     -2160.6789    
Loop time of 36.8313 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.346 ns/day, 10.231 hours/ns, 27.151 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.678     | 36.678     | 36.678     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02176    | 0.02176    | 0.02176    |   0.0 |  0.06
Output  | 5.7047e-05 | 5.7047e-05 | 5.7047e-05 |   0.0 |  0.00
Modify  | 0.12133    | 0.12133    | 0.12133    |   0.0 |  0.33
Other   |            | 0.0104     |            |       |  0.03

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

Total # of neighbors = 314660
Ave neighs/atom = 78.665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.749287688107, Press = -1.17597993834494
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17495.591     -17495.591     -17644.328     -17644.328      287.74132      287.74132      44022.961      44022.961     -2160.6789     -2160.6789    
     33000  -17492.33      -17492.33      -17642.614     -17642.614      290.73391      290.73391      44006.193      44006.193     -1311.5329     -1311.5329    
Loop time of 36.9003 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.341 ns/day, 10.250 hours/ns, 27.100 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.747     | 36.747     | 36.747     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021691   | 0.021691   | 0.021691   |   0.0 |  0.06
Output  | 5.8831e-05 | 5.8831e-05 | 5.8831e-05 |   0.0 |  0.00
Modify  | 0.12167    | 0.12167    | 0.12167    |   0.0 |  0.33
Other   |            | 0.01037    |            |       |  0.03

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

Total # of neighbors = 314502
Ave neighs/atom = 78.6255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.781552721297, Press = -1.05599453574232
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17492.33      -17492.33      -17642.614     -17642.614      290.73391      290.73391      44006.193      44006.193     -1311.5329     -1311.5329    
     34000  -17486.43      -17486.43      -17639.842     -17639.842      296.7861       296.7861       43987.112      43987.112     -507.85508     -507.85508    
Loop time of 37.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.335 ns/day, 10.278 hours/ns, 27.026 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.847     | 36.847     | 36.847     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021864   | 0.021864   | 0.021864   |   0.0 |  0.06
Output  | 5.6025e-05 | 5.6025e-05 | 5.6025e-05 |   0.0 |  0.00
Modify  | 0.12222    | 0.12222    | 0.12222    |   0.0 |  0.33
Other   |            | 0.01041    |            |       |  0.03

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

Total # of neighbors = 314646
Ave neighs/atom = 78.6615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.81010562952, Press = -0.617971952299286
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17486.43      -17486.43      -17639.842     -17639.842      296.7861       296.7861       43987.112      43987.112     -507.85508     -507.85508    
     35000  -17492.269     -17492.269     -17643.504     -17643.504      292.57396      292.57396      43973.277      43973.277     -92.00985      -92.00985     
Loop time of 37.1015 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.329 ns/day, 10.306 hours/ns, 26.953 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.947     | 36.947     | 36.947     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021932   | 0.021932   | 0.021932   |   0.0 |  0.06
Output  | 3.9464e-05 | 3.9464e-05 | 3.9464e-05 |   0.0 |  0.00
Modify  | 0.12174    | 0.12174    | 0.12174    |   0.0 |  0.33
Other   |            | 0.01038    |            |       |  0.03

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

Total # of neighbors = 314780
Ave neighs/atom = 78.695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.86019865642, Press = -0.752717389969315
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17492.269     -17492.269     -17643.504     -17643.504      292.57396      292.57396      43973.277      43973.277     -92.00985      -92.00985     
     36000  -17495.11      -17495.11      -17643.039     -17643.039      286.1801       286.1801       43968.306      43968.306     -91.362782     -91.362782    
Loop time of 37.1125 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.328 ns/day, 10.309 hours/ns, 26.945 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.958     | 36.958     | 36.958     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02173    | 0.02173    | 0.02173    |   0.0 |  0.06
Output  | 7.987e-05  | 7.987e-05  | 7.987e-05  |   0.0 |  0.00
Modify  | 0.12204    | 0.12204    | 0.12204    |   0.0 |  0.33
Other   |            | 0.01041    |            |       |  0.03

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

Total # of neighbors = 314760
Ave neighs/atom = 78.69
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.913465985938, Press = -0.864959342541998
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17495.11      -17495.11      -17643.039     -17643.039      286.1801       286.1801       43968.306      43968.306     -91.362782     -91.362782    
     37000  -17493.593     -17493.593     -17644.716     -17644.716      292.35842      292.35842      43967.295      43967.295      131.86956      131.86956    
Loop time of 37.0786 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.330 ns/day, 10.300 hours/ns, 26.970 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.924     | 36.924     | 36.924     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02183    | 0.02183    | 0.02183    |   0.0 |  0.06
Output  | 4.8611e-05 | 4.8611e-05 | 4.8611e-05 |   0.0 |  0.00
Modify  | 0.12193    | 0.12193    | 0.12193    |   0.0 |  0.33
Other   |            | 0.01042    |            |       |  0.03

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

Total # of neighbors = 314818
Ave neighs/atom = 78.7045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.910879493086, Press = -1.18376226286109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17493.593     -17493.593     -17644.716     -17644.716      292.35842      292.35842      43967.295      43967.295      131.86956      131.86956    
     38000  -17490.54      -17490.54      -17642.986     -17642.986      294.91607      294.91607      43963.08       43963.08       402.31561      402.31561    
Loop time of 37.0358 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.288 hours/ns, 27.001 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.882     | 36.882     | 36.882     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021755   | 0.021755   | 0.021755   |   0.0 |  0.06
Output  | 3.8763e-05 | 3.8763e-05 | 3.8763e-05 |   0.0 |  0.00
Modify  | 0.12196    | 0.12196    | 0.12196    |   0.0 |  0.33
Other   |            | 0.0104     |            |       |  0.03

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

Total # of neighbors = 314656
Ave neighs/atom = 78.664
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.858729076975, Press = -1.35477865651681
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17490.54      -17490.54      -17642.986     -17642.986      294.91607      294.91607      43963.08       43963.08       402.31561      402.31561    
     39000  -17499.465     -17499.465     -17646.77      -17646.77       284.97138      284.97138      43940.515      43940.515      932.46016      932.46016    
Loop time of 37.0088 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.335 ns/day, 10.280 hours/ns, 27.021 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.855     | 36.855     | 36.855     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021786   | 0.021786   | 0.021786   |   0.0 |  0.06
Output  | 5.1637e-05 | 5.1637e-05 | 5.1637e-05 |   0.0 |  0.00
Modify  | 0.12178    | 0.12178    | 0.12178    |   0.0 |  0.33
Other   |            | 0.0104     |            |       |  0.03

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

Total # of neighbors = 314932
Ave neighs/atom = 78.733
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.831686076246, Press = -1.47237414344079
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17499.465     -17499.465     -17646.77      -17646.77       284.97138      284.97138      43940.515      43940.515      932.46016      932.46016    
     40000  -17489.45      -17489.45      -17642.014     -17642.014      295.14543      295.14543      43925.111      43925.111      2046.6135      2046.6135    
Loop time of 37.0462 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.291 hours/ns, 26.993 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.892     | 36.892     | 36.892     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021788   | 0.021788   | 0.021788   |   0.0 |  0.06
Output  | 4.795e-05  | 4.795e-05  | 4.795e-05  |   0.0 |  0.00
Modify  | 0.12218    | 0.12218    | 0.12218    |   0.0 |  0.33
Other   |            | 0.01039    |            |       |  0.03

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

Total # of neighbors = 314722
Ave neighs/atom = 78.6805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.794669853339, Press = -1.61970210261925
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17489.45      -17489.45      -17642.014     -17642.014      295.14543      295.14543      43925.111      43925.111      2046.6135      2046.6135    
     41000  -17491.942     -17491.942     -17642.941     -17642.941      292.11856      292.11856      43955.429      43955.429      670.92597      670.92597    
Loop time of 37.1039 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.329 ns/day, 10.307 hours/ns, 26.951 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.95      | 36.95      | 36.95      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021815   | 0.021815   | 0.021815   |   0.0 |  0.06
Output  | 6.0714e-05 | 6.0714e-05 | 6.0714e-05 |   0.0 |  0.00
Modify  | 0.1221     | 0.1221     | 0.1221     |   0.0 |  0.33
Other   |            | 0.01037    |            |       |  0.03

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

Total # of neighbors = 314854
Ave neighs/atom = 78.7135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.802248195084, Press = -1.08659329196803
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17491.942     -17491.942     -17642.941     -17642.941      292.11856      292.11856      43955.429      43955.429      670.92597      670.92597    
     42000  -17492.812     -17492.812     -17641.912     -17641.912      288.44279      288.44279      43957.811      43957.811      545.17686      545.17686    
Loop time of 37.0984 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.329 ns/day, 10.305 hours/ns, 26.955 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.944     | 36.944     | 36.944     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021847   | 0.021847   | 0.021847   |   0.0 |  0.06
Output  | 4.796e-05  | 4.796e-05  | 4.796e-05  |   0.0 |  0.00
Modify  | 0.12179    | 0.12179    | 0.12179    |   0.0 |  0.33
Other   |            | 0.01038    |            |       |  0.03

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

Total # of neighbors = 314794
Ave neighs/atom = 78.6985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.863166984877, Press = -0.554576671057075
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17492.812     -17492.812     -17641.912     -17641.912      288.44279      288.44279      43957.811      43957.811      545.17686      545.17686    
     43000  -17489.461     -17489.461     -17641.25      -17641.25       293.64604      293.64604      43965.272      43965.272      339.07104      339.07104    
Loop time of 37.2722 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.318 ns/day, 10.353 hours/ns, 26.830 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.117     | 37.117     | 37.117     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0219     | 0.0219     | 0.0219     |   0.0 |  0.06
Output  | 3.7852e-05 | 3.7852e-05 | 3.7852e-05 |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.33
Other   |            | 0.01041    |            |       |  0.03

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

Total # of neighbors = 314804
Ave neighs/atom = 78.701
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.871864541644, Press = -0.550277668219026
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17489.461     -17489.461     -17641.25      -17641.25       293.64604      293.64604      43965.272      43965.272      339.07104      339.07104    
     44000  -17491.959     -17491.959     -17643.677     -17643.677      293.50779      293.50779      43963.511      43963.511      248.26571      248.26571    
Loop time of 37.24 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.320 ns/day, 10.344 hours/ns, 26.853 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.085     | 37.085     | 37.085     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021921   | 0.021921   | 0.021921   |   0.0 |  0.06
Output  | 6.4291e-05 | 6.4291e-05 | 6.4291e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.33
Other   |            | 0.01047    |            |       |  0.03

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

Total # of neighbors = 314784
Ave neighs/atom = 78.696
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.877995490059, Press = -0.788138377405827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17491.959     -17491.959     -17643.677     -17643.677      293.50779      293.50779      43963.511      43963.511      248.26571      248.26571    
     45000  -17490.093     -17490.093     -17642.649     -17642.649      295.13103      295.13103      43949.294      43949.294      1018.2825      1018.2825    
Loop time of 37.2736 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.318 ns/day, 10.354 hours/ns, 26.829 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.119     | 37.119     | 37.119     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021873   | 0.021873   | 0.021873   |   0.0 |  0.06
Output  | 4.0236e-05 | 4.0236e-05 | 4.0236e-05 |   0.0 |  0.00
Modify  | 0.12262    | 0.12262    | 0.12262    |   0.0 |  0.33
Other   |            | 0.01045    |            |       |  0.03

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

Total # of neighbors = 314756
Ave neighs/atom = 78.689
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.896907492487, Press = -1.22517262016509
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17490.093     -17490.093     -17642.649     -17642.649      295.13103      295.13103      43949.294      43949.294      1018.2825      1018.2825    
     46000  -17492.302     -17492.302     -17644.042     -17644.042      293.55216      293.55216      43950.043      43950.043      925.48604      925.48604    
Loop time of 37.2954 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.317 ns/day, 10.360 hours/ns, 26.813 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.14      | 37.14      | 37.14      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021952   | 0.021952   | 0.021952   |   0.0 |  0.06
Output  | 6.6235e-05 | 6.6235e-05 | 6.6235e-05 |   0.0 |  0.00
Modify  | 0.12257    | 0.12257    | 0.12257    |   0.0 |  0.33
Other   |            | 0.01044    |            |       |  0.03

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

Total # of neighbors = 314814
Ave neighs/atom = 78.7035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.918279694291, Press = -1.21934610032829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17492.302     -17492.302     -17644.042     -17644.042      293.55216      293.55216      43950.043      43950.043      925.48604      925.48604    
     47000  -17491.9       -17491.9       -17643.013     -17643.013      292.33789      292.33789      43945.214      43945.214      1024.0544      1024.0544    
Loop time of 37.2433 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.320 ns/day, 10.345 hours/ns, 26.850 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.088     | 37.088     | 37.088     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021909   | 0.021909   | 0.021909   |   0.0 |  0.06
Output  | 5.292e-05  | 5.292e-05  | 5.292e-05  |   0.0 |  0.00
Modify  | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314684
Ave neighs/atom = 78.671
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.959350922786, Press = -1.36683606495523
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17491.9       -17491.9       -17643.013     -17643.013      292.33789      292.33789      43945.214      43945.214      1024.0544      1024.0544    
     48000  -17490.117     -17490.117     -17641.991     -17641.991      293.80978      293.80978      43945.757      43945.757      1199.6836      1199.6836    
Loop time of 37.2994 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.316 ns/day, 10.361 hours/ns, 26.810 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.145     | 37.145     | 37.145     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021909   | 0.021909   | 0.021909   |   0.0 |  0.06
Output  | 4.774e-05  | 4.774e-05  | 4.774e-05  |   0.0 |  0.00
Modify  | 0.12245    | 0.12245    | 0.12245    |   0.0 |  0.33
Other   |            | 0.01042    |            |       |  0.03

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

Total # of neighbors = 314878
Ave neighs/atom = 78.7195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.9655937038, Press = -0.89382116519216
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17490.117     -17490.117     -17641.991     -17641.991      293.80978      293.80978      43945.757      43945.757      1199.6836      1199.6836    
     49000  -17494.219     -17494.219     -17643.79      -17643.79       289.354        289.354        43948.74       43948.74       848.31678      848.31678    
Loop time of 37.1787 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.324 ns/day, 10.327 hours/ns, 26.897 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.023     | 37.023     | 37.023     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021903   | 0.021903   | 0.021903   |   0.0 |  0.06
Output  | 6.2267e-05 | 6.2267e-05 | 6.2267e-05 |   0.0 |  0.00
Modify  | 0.12284    | 0.12284    | 0.12284    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 314906
Ave neighs/atom = 78.7265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.945808502736, Press = -0.699466048384111
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17494.219     -17494.219     -17643.79      -17643.79       289.354        289.354        43948.74       43948.74       848.31678      848.31678    
     50000  -17495.31      -17495.31      -17646.402     -17646.402      292.29834      292.29834      43942.646      43942.646      988.63927      988.63927    
Loop time of 37.2854 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.317 ns/day, 10.357 hours/ns, 26.820 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.131     | 37.131     | 37.131     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021859   | 0.021859   | 0.021859   |   0.0 |  0.06
Output  | 4.4544e-05 | 4.4544e-05 | 4.4544e-05 |   0.0 |  0.00
Modify  | 0.12229    | 0.12229    | 0.12229    |   0.0 |  0.33
Other   |            | 0.01043    |            |       |  0.03

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

Total # of neighbors = 314828
Ave neighs/atom = 78.707
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.926469146083, Press = -0.306489648218628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17495.31      -17495.31      -17646.402     -17646.402      292.29834      292.29834      43942.646      43942.646      988.63927      988.63927    
     51000  -17490.132     -17490.132     -17643.229     -17643.229      296.1774       296.1774       43949.025      43949.025      954.71694      954.71694    
Loop time of 37.3356 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.314 ns/day, 10.371 hours/ns, 26.784 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.18      | 37.18      | 37.18      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022042   | 0.022042   | 0.022042   |   0.0 |  0.06
Output  | 4.4333e-05 | 4.4333e-05 | 4.4333e-05 |   0.0 |  0.00
Modify  | 0.12281    | 0.12281    | 0.12281    |   0.0 |  0.33
Other   |            | 0.01045    |            |       |  0.03

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

Total # of neighbors = 314730
Ave neighs/atom = 78.6825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.911589045754, Press = -0.0155622898345999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17490.132     -17490.132     -17643.229     -17643.229      296.1774       296.1774       43949.025      43949.025      954.71694      954.71694    
     52000  -17493.23      -17493.23      -17646.012     -17646.012      295.56611      295.56611      43918.333      43918.333      1973.1927      1973.1927    
Loop time of 37.3626 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.312 ns/day, 10.378 hours/ns, 26.765 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.207     | 37.207     | 37.207     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022027   | 0.022027   | 0.022027   |   0.0 |  0.06
Output  | 5.5434e-05 | 5.5434e-05 | 5.5434e-05 |   0.0 |  0.00
Modify  | 0.12291    | 0.12291    | 0.12291    |   0.0 |  0.33
Other   |            | 0.01048    |            |       |  0.03

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

Total # of neighbors = 314682
Ave neighs/atom = 78.6705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.922192608178, Press = 0.0515420960319892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17493.23      -17493.23      -17646.012     -17646.012      295.56611      295.56611      43918.333      43918.333      1973.1927      1973.1927    
     53000  -17494.576     -17494.576     -17645.319     -17645.319      291.62213      291.62213      43869.52       43869.52       4032.0573      4032.0573    
Loop time of 37.3293 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.315 ns/day, 10.369 hours/ns, 26.789 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.175     | 37.175     | 37.175     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021883   | 0.021883   | 0.021883   |   0.0 |  0.06
Output  | 4.0366e-05 | 4.0366e-05 | 4.0366e-05 |   0.0 |  0.00
Modify  | 0.12225    | 0.12225    | 0.12225    |   0.0 |  0.33
Other   |            | 0.01046    |            |       |  0.03

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

Total # of neighbors = 314850
Ave neighs/atom = 78.7125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.95504845923, Press = 0.718965546093762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17494.576     -17494.576     -17645.319     -17645.319      291.62213      291.62213      43869.52       43869.52       4032.0573      4032.0573    
     54000  -17490.102     -17490.102     -17645.096     -17645.096      299.84692      299.84692      43923.905      43923.905      1771.9604      1771.9604    
Loop time of 37.3186 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.315 ns/day, 10.366 hours/ns, 26.796 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.163     | 37.163     | 37.163     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021853   | 0.021853   | 0.021853   |   0.0 |  0.06
Output  | 6.8108e-05 | 6.8108e-05 | 6.8108e-05 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.33
Other   |            | 0.01046    |            |       |  0.03

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

Total # of neighbors = 314962
Ave neighs/atom = 78.7405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.951445420274, Press = 0.58754359944675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17490.102     -17490.102     -17645.096     -17645.096      299.84692      299.84692      43923.905      43923.905      1771.9604      1771.9604    
     55000  -17492.229     -17492.229     -17645.017     -17645.017      295.57707      295.57707      43946.085      43946.085      864.54579      864.54579    
Loop time of 37.3117 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.316 ns/day, 10.364 hours/ns, 26.801 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.157     | 37.157     | 37.157     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022053   | 0.022053   | 0.022053   |   0.0 |  0.06
Output  | 5.1526e-05 | 5.1526e-05 | 5.1526e-05 |   0.0 |  0.00
Modify  | 0.12257    | 0.12257    | 0.12257    |   0.0 |  0.33
Other   |            | 0.01038    |            |       |  0.03

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

Total # of neighbors = 314848
Ave neighs/atom = 78.712
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.955729242477, Press = 0.591577366795139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -17492.229     -17492.229     -17645.017     -17645.017      295.57707      295.57707      43946.085      43946.085      864.54579      864.54579    
     56000  -17492.835     -17492.835     -17646.055     -17646.055      296.41464      296.41464      43954.332      43954.332      495.23207      495.23207    
Loop time of 37.2477 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.320 ns/day, 10.347 hours/ns, 26.847 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.092     | 37.092     | 37.092     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021848   | 0.021848   | 0.021848   |   0.0 |  0.06
Output  | 4.814e-05  | 4.814e-05  | 4.814e-05  |   0.0 |  0.00
Modify  | 0.12295    | 0.12295    | 0.12295    |   0.0 |  0.33
Other   |            | 0.01048    |            |       |  0.03

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

Total # of neighbors = 314782
Ave neighs/atom = 78.6955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.962999205053, Press = 0.579609468446568
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -17492.835     -17492.835     -17646.055     -17646.055      296.41464      296.41464      43954.332      43954.332      495.23207      495.23207    
     57000  -17490.291     -17490.291     -17641.909     -17641.909      293.31417      293.31417      43960.67       43960.67       466.81827      466.81827    
Loop time of 37.2925 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.317 ns/day, 10.359 hours/ns, 26.815 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.137     | 37.137     | 37.137     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021877   | 0.021877   | 0.021877   |   0.0 |  0.06
Output  | 6.1085e-05 | 6.1085e-05 | 6.1085e-05 |   0.0 |  0.00
Modify  | 0.12274    | 0.12274    | 0.12274    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 314876
Ave neighs/atom = 78.719
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.984121635271, Press = 0.508791625970712
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17490.291     -17490.291     -17641.909     -17641.909      293.31417      293.31417      43960.67       43960.67       466.81827      466.81827    
     58000  -17491.784     -17491.784     -17646.074     -17646.074      298.48338      298.48338      43961.553      43961.553      337.87275      337.87275    
Loop time of 37.0539 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.293 hours/ns, 26.988 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.899     | 36.899     | 36.899     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021775   | 0.021775   | 0.021775   |   0.0 |  0.06
Output  | 5.9782e-05 | 5.9782e-05 | 5.9782e-05 |   0.0 |  0.00
Modify  | 0.12217    | 0.12217    | 0.12217    |   0.0 |  0.33
Other   |            | 0.01042    |            |       |  0.03

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

Total # of neighbors = 314874
Ave neighs/atom = 78.7185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.991770036251, Press = 0.747085040394676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -17491.784     -17491.784     -17646.074     -17646.074      298.48338      298.48338      43961.553      43961.553      337.87275      337.87275    
     59000  -17494.32      -17494.32      -17643.994     -17643.994      289.5546       289.5546       43942.108      43942.108      1093.5406      1093.5406    
Loop time of 37.0355 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.288 hours/ns, 27.001 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.881     | 36.881     | 36.881     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021743   | 0.021743   | 0.021743   |   0.0 |  0.06
Output  | 0.00011029 | 0.00011029 | 0.00011029 |   0.0 |  0.00
Modify  | 0.12187    | 0.12187    | 0.12187    |   0.0 |  0.33
Other   |            | 0.01039    |            |       |  0.03

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

Total # of neighbors = 314732
Ave neighs/atom = 78.683
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.988295928248, Press = 1.39136658308837
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -17494.32      -17494.32      -17643.994     -17643.994      289.5546       289.5546       43942.108      43942.108      1093.5406      1093.5406    
     60000  -17490.527     -17490.527     -17641.844     -17641.844      292.73222      292.73222      43965.023      43965.023      344.89828      344.89828    
Loop time of 37.0806 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.330 ns/day, 10.300 hours/ns, 26.968 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.927     | 36.927     | 36.927     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021719   | 0.021719   | 0.021719   |   0.0 |  0.06
Output  | 7.8327e-05 | 7.8327e-05 | 7.8327e-05 |   0.0 |  0.00
Modify  | 0.12184    | 0.12184    | 0.12184    |   0.0 |  0.33
Other   |            | 0.01042    |            |       |  0.03

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

Total # of neighbors = 314802
Ave neighs/atom = 78.7005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.999583150608, Press = 1.10282134998224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -17490.527     -17490.527     -17641.844     -17641.844      292.73222      292.73222      43965.023      43965.023      344.89828      344.89828    
     61000  -17492.848     -17492.848     -17641.39      -17641.39       287.36575      287.36575      43961.616      43961.616      246.79021      246.79021    
Loop time of 36.9668 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.337 ns/day, 10.269 hours/ns, 27.051 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.813     | 36.813     | 36.813     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021651   | 0.021651   | 0.021651   |   0.0 |  0.06
Output  | 4.7158e-05 | 4.7158e-05 | 4.7158e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.33
Other   |            | 0.01037    |            |       |  0.03

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

Total # of neighbors = 314778
Ave neighs/atom = 78.6945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.018677368382, Press = 0.447174892487922
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -17492.848     -17492.848     -17641.39      -17641.39       287.36575      287.36575      43961.616      43961.616      246.79021      246.79021    
     62000  -17494.832     -17494.832     -17644.227     -17644.227      289.0152       289.0152       43967.358      43967.358      42.062333      42.062333    
Loop time of 36.8695 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.343 ns/day, 10.242 hours/ns, 27.123 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.716     | 36.716     | 36.716     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021586   | 0.021586   | 0.021586   |   0.0 |  0.06
Output  | 6.9361e-05 | 6.9361e-05 | 6.9361e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.33
Other   |            | 0.01037    |            |       |  0.03

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

Total # of neighbors = 314790
Ave neighs/atom = 78.6975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.027275592892, Press = 0.325783629882652
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -17494.832     -17494.832     -17644.227     -17644.227      289.0152       289.0152       43967.358      43967.358      42.062333      42.062333    
     63000  -17495.193     -17495.193     -17644.026     -17644.026      287.92728      287.92728      43954.684      43954.684      476.02007      476.02007    
Loop time of 36.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.346 ns/day, 10.231 hours/ns, 27.152 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.677     | 36.677     | 36.677     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021621   | 0.021621   | 0.021621   |   0.0 |  0.06
Output  | 5.1076e-05 | 5.1076e-05 | 5.1076e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.33
Other   |            | 0.01035    |            |       |  0.03

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

Total # of neighbors = 314788
Ave neighs/atom = 78.697
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.01290478424, Press = 0.495322518007618
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -17495.193     -17495.193     -17644.026     -17644.026      287.92728      287.92728      43954.684      43954.684      476.02007      476.02007    
     64000  -17490.703     -17490.703     -17642.726     -17642.726      294.09916      294.09916      43980.738      43980.738     -380.06841     -380.06841    
Loop time of 36.7927 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.348 ns/day, 10.220 hours/ns, 27.179 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.64      | 36.64      | 36.64      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021557   | 0.021557   | 0.021557   |   0.0 |  0.06
Output  | 5.0716e-05 | 5.0716e-05 | 5.0716e-05 |   0.0 |  0.00
Modify  | 0.12105    | 0.12105    | 0.12105    |   0.0 |  0.33
Other   |            | 0.01036    |            |       |  0.03

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

Total # of neighbors = 314788
Ave neighs/atom = 78.697
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.003032252204, Press = 1.07749636393267
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -17490.703     -17490.703     -17642.726     -17642.726      294.09916      294.09916      43980.738      43980.738     -380.06841     -380.06841    
     65000  -17493.595     -17493.595     -17641.491     -17641.491      286.11442      286.11442      43989.761      43989.761     -783.91392     -783.91392    
Loop time of 36.8199 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.347 ns/day, 10.228 hours/ns, 27.159 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.667     | 36.667     | 36.667     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021674   | 0.021674   | 0.021674   |   0.0 |  0.06
Output  | 5.8931e-05 | 5.8931e-05 | 5.8931e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.33
Other   |            | 0.0104     |            |       |  0.03

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

Total # of neighbors = 314798
Ave neighs/atom = 78.6995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.984436588928, Press = 1.37249132081842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -17493.595     -17493.595     -17641.491     -17641.491      286.11442      286.11442      43989.761      43989.761     -783.91392     -783.91392    
     66000  -17494.803     -17494.803     -17646.158     -17646.158      292.8068       292.8068       43975.787      43975.787     -249.33975     -249.33975    
Loop time of 36.8141 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.347 ns/day, 10.226 hours/ns, 27.164 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.661     | 36.661     | 36.661     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021689   | 0.021689   | 0.021689   |   0.0 |  0.06
Output  | 3.7831e-05 | 3.7831e-05 | 3.7831e-05 |   0.0 |  0.00
Modify  | 0.12102    | 0.12102    | 0.12102    |   0.0 |  0.33
Other   |            | 0.01032    |            |       |  0.03

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

Total # of neighbors = 314700
Ave neighs/atom = 78.675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.974444040307, Press = 0.323220480384463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -17494.803     -17494.803     -17646.158     -17646.158      292.8068       292.8068       43975.787      43975.787     -249.33975     -249.33975    
     67000  -17491.34      -17491.34      -17640.81      -17640.81       289.15965      289.15965      43971.313      43971.313      147.87756      147.87756    
Loop time of 36.8457 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.345 ns/day, 10.235 hours/ns, 27.140 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.693     | 36.693     | 36.693     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021709   | 0.021709   | 0.021709   |   0.0 |  0.06
Output  | 5.4973e-05 | 5.4973e-05 | 5.4973e-05 |   0.0 |  0.00
Modify  | 0.12098    | 0.12098    | 0.12098    |   0.0 |  0.33
Other   |            | 0.01035    |            |       |  0.03

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

Total # of neighbors = 314558
Ave neighs/atom = 78.6395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.945563226843, Press = 0.103365032670404
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -17491.34      -17491.34      -17640.81      -17640.81       289.15965      289.15965      43971.313      43971.313      147.87756      147.87756    
     68000  -17495.707     -17495.707     -17645.827     -17645.827      290.41658      290.41658      43978.831      43978.831     -512.96806     -512.96806    
Loop time of 36.8544 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.344 ns/day, 10.237 hours/ns, 27.134 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.701     | 36.701     | 36.701     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021716   | 0.021716   | 0.021716   |   0.0 |  0.06
Output  | 4.8992e-05 | 4.8992e-05 | 4.8992e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.33
Other   |            | 0.01036    |            |       |  0.03

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

Total # of neighbors = 314758
Ave neighs/atom = 78.6895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.932043535508, Press = 0.381637808409955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -17495.707     -17495.707     -17645.827     -17645.827      290.41658      290.41658      43978.831      43978.831     -512.96806     -512.96806    
     69000  -17491.595     -17491.595     -17644.434     -17644.434      295.6777       295.6777       43980.62       43980.62      -295.73688     -295.73688    
Loop time of 36.8683 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.343 ns/day, 10.241 hours/ns, 27.124 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.715     | 36.715     | 36.715     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021707   | 0.021707   | 0.021707   |   0.0 |  0.06
Output  | 3.4214e-05 | 3.4214e-05 | 3.4214e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.33
Other   |            | 0.01036    |            |       |  0.03

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

Total # of neighbors = 314662
Ave neighs/atom = 78.6655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.953728207894, Press = 0.58704212424088
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -17491.595     -17491.595     -17644.434     -17644.434      295.6777       295.6777       43980.62       43980.62      -295.73688     -295.73688    
     70000  -17496.656     -17496.656     -17647.303     -17647.303      291.43783      291.43783      43989.483      43989.483     -885.29747     -885.29747    
Loop time of 36.8138 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.347 ns/day, 10.226 hours/ns, 27.164 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.66      | 36.66      | 36.66      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021596   | 0.021596   | 0.021596   |   0.0 |  0.06
Output  | 6.6244e-05 | 6.6244e-05 | 6.6244e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.33
Other   |            | 0.01035    |            |       |  0.03

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

Total # of neighbors = 314646
Ave neighs/atom = 78.6615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928845152363, Press = 0.877913409132377
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -17496.656     -17496.656     -17647.303     -17647.303      291.43783      291.43783      43989.483      43989.483     -885.29747     -885.29747    
     71000  -17493.933     -17493.933     -17641.977     -17641.977      286.40095      286.40095      43994.645      43994.645     -1038.566      -1038.566     
Loop time of 36.9157 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.340 ns/day, 10.254 hours/ns, 27.089 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.763     | 36.763     | 36.763     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021593   | 0.021593   | 0.021593   |   0.0 |  0.06
Output  | 4.278e-05  | 4.278e-05  | 4.278e-05  |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.33
Other   |            | 0.01034    |            |       |  0.03

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

Total # of neighbors = 314594
Ave neighs/atom = 78.6485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.934408257227, Press = 0.729633998080355
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -17493.933     -17493.933     -17641.977     -17641.977      286.40095      286.40095      43994.645      43994.645     -1038.566      -1038.566     
     72000  -17489.813     -17489.813     -17642.679     -17642.679      295.72911      295.72911      43992.931      43992.931     -906.15044     -906.15044    
Loop time of 36.8864 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.342 ns/day, 10.246 hours/ns, 27.110 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.733     | 36.733     | 36.733     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021571   | 0.021571   | 0.021571   |   0.0 |  0.06
Output  | 3.5376e-05 | 3.5376e-05 | 3.5376e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.33
Other   |            | 0.01031    |            |       |  0.03

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

Total # of neighbors = 314752
Ave neighs/atom = 78.688
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.955012073838, Press = 0.358152781877647
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: 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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -17489.813     -17489.813     -17642.679     -17642.679      295.72911      295.72911      43992.931      43992.931     -906.15044     -906.15044    
     73000  -17493.597     -17493.597     -17643.535     -17643.535      290.06559      290.06559      43984.07       43984.07      -728.3735      -728.3735     
Loop time of 36.9774 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.337 ns/day, 10.272 hours/ns, 27.044 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.824     | 36.824     | 36.824     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021792   | 0.021792   | 0.021792   |   0.0 |  0.06
Output  | 6.1466e-05 | 6.1466e-05 | 6.1466e-05 |   0.0 |  0.00
Modify  | 0.12147    | 0.12147    | 0.12147    |   0.0 |  0.33
Other   |            | 0.01038    |            |       |  0.03

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

Total # of neighbors = 314868
Ave neighs/atom = 78.717
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
43970.457646458

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0