# 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.8890872895717616*${_u_distance}
variable latticeconst_converted equal 3.8890872895717616*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.88908728957176
Lattice spacing in x,y,z = 3.8890873 3.8890873 3.8890873
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (38.890873 38.890873 38.890873)
  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 (38.890873 38.890873 38.890873)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Pd

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

kim interactions Pd
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongParkDo_2018_PdFe__MO_924736622203_002
pair_coeff * * Pd
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 106.42

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_924736622203_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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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  -15467.791     -15467.791     -15640         -15640          333.15         333.15         58822.445      58822.445      3127.0321      3127.0321    
      1000  -15299.786     -15299.786     -15472.367     -15472.367      333.8689       333.8689       59667.766      59667.766     -1371.4511     -1371.4511    
Loop time of 33.6821 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.565 ns/day, 9.356 hours/ns, 29.689 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    | 33.526     | 33.526     | 33.526     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022909   | 0.022909   | 0.022909   |   0.0 |  0.07
Output  | 0.00013555 | 0.00013555 | 0.00013555 |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.36
Other   |            | 0.01155    |            |       |  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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -15299.786     -15299.786     -15472.367     -15472.367      333.8689       333.8689       59667.766      59667.766     -1371.4511     -1371.4511    
      2000  -15301.197     -15301.197     -15467.846     -15467.846      322.3942       322.3942       59551.777      59551.777      2799.8249      2799.8249    
Loop time of 37.6859 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.293 ns/day, 10.468 hours/ns, 26.535 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    | 37.535     | 37.535     | 37.535     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021912   | 0.021912   | 0.021912   |   0.0 |  0.06
Output  | 7.4721e-05 | 7.4721e-05 | 7.4721e-05 |   0.0 |  0.00
Modify  | 0.11795    | 0.11795    | 0.11795    |   0.0 |  0.31
Other   |            | 0.01089    |            |       |  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:       312006 ave      312006 max      312006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312006
Ave neighs/atom = 78.0015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -15301.197     -15301.197     -15467.846     -15467.846      322.3942       322.3942       59551.777      59551.777      2799.8249      2799.8249    
      3000  -15309.833     -15309.833     -15474.921     -15474.921      319.37451      319.37451      59633.411      59633.411     -631.9031      -631.9031     
Loop time of 37.8613 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.282 ns/day, 10.517 hours/ns, 26.412 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    | 37.71      | 37.71      | 37.71      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021713   | 0.021713   | 0.021713   |   0.0 |  0.06
Output  | 6.7988e-05 | 6.7988e-05 | 6.7988e-05 |   0.0 |  0.00
Modify  | 0.11814    | 0.11814    | 0.11814    |   0.0 |  0.31
Other   |            | 0.01102    |            |       |  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:       312030 ave      312030 max      312030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312030
Ave neighs/atom = 78.0075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -15309.833     -15309.833     -15474.921     -15474.921      319.37451      319.37451      59633.411      59633.411     -631.9031      -631.9031     
      4000  -15299.036     -15299.036     -15475.074     -15475.074      340.55771      340.55771      59618.988      59618.988      108.30409      108.30409    
Loop time of 37.8195 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.285 ns/day, 10.505 hours/ns, 26.441 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    | 37.669     | 37.669     | 37.669     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021791   | 0.021791   | 0.021791   |   0.0 |  0.06
Output  | 4.6448e-05 | 4.6448e-05 | 4.6448e-05 |   0.0 |  0.00
Modify  | 0.11793    | 0.11793    | 0.11793    |   0.0 |  0.31
Other   |            | 0.01093    |            |       |  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:       312044 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -15299.036     -15299.036     -15475.074     -15475.074      340.55771      340.55771      59618.988      59618.988      108.30409      108.30409    
      5000  -15305.129     -15305.129     -15475.185     -15475.185      328.98523      328.98523      59569.06       59569.06       1400.8807      1400.8807    
Loop time of 37.8388 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.283 ns/day, 10.511 hours/ns, 26.428 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    | 37.688     | 37.688     | 37.688     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02174    | 0.02174    | 0.02174    |   0.0 |  0.06
Output  | 4.9374e-05 | 4.9374e-05 | 4.9374e-05 |   0.0 |  0.00
Modify  | 0.11846    | 0.11846    | 0.11846    |   0.0 |  0.31
Other   |            | 0.01074    |            |       |  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:       312034 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.0085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 330.937765744375, Press = -578.715398982919
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -15305.129     -15305.129     -15475.185     -15475.185      328.98523      328.98523      59569.06       59569.06       1400.8807      1400.8807    
      6000  -15303.445     -15303.445     -15474.807     -15474.807      331.5113       331.5113       59660.977      59660.977     -1527.9007     -1527.9007    
Loop time of 37.8382 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.283 ns/day, 10.511 hours/ns, 26.428 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    | 37.684     | 37.684     | 37.684     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021716   | 0.021716   | 0.021716   |   0.0 |  0.06
Output  | 3.4385e-05 | 3.4385e-05 | 3.4385e-05 |   0.0 |  0.00
Modify  | 0.12158    | 0.12158    | 0.12158    |   0.0 |  0.32
Other   |            | 0.01071    |            |       |  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:       312044 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.599192264927, Press = -57.5250826761894
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -15303.445     -15303.445     -15474.807     -15474.807      331.5113       331.5113       59660.977      59660.977     -1527.9007     -1527.9007    
      7000  -15302.365     -15302.365     -15477.067     -15477.067      337.97102      337.97102      59608.922      59608.922      5.3648725      5.3648725    
Loop time of 37.9419 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.277 ns/day, 10.539 hours/ns, 26.356 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    | 37.788     | 37.788     | 37.788     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021808   | 0.021808   | 0.021808   |   0.0 |  0.06
Output  | 3.2291e-05 | 3.2291e-05 | 3.2291e-05 |   0.0 |  0.00
Modify  | 0.12157    | 0.12157    | 0.12157    |   0.0 |  0.32
Other   |            | 0.01069    |            |       |  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:       312018 ave      312018 max      312018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312018
Ave neighs/atom = 78.0045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.123920508082, Press = -16.7585395240227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -15302.365     -15302.365     -15477.067     -15477.067      337.97102      337.97102      59608.922      59608.922      5.3648725      5.3648725    
      8000  -15305.111     -15305.111     -15479.362     -15479.362      337.10094      337.10094      59604.812      59604.812     -99.163881     -99.163881    
Loop time of 37.8818 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.281 ns/day, 10.523 hours/ns, 26.398 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    | 37.728     | 37.728     | 37.728     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02173    | 0.02173    | 0.02173    |   0.0 |  0.06
Output  | 5.0746e-05 | 5.0746e-05 | 5.0746e-05 |   0.0 |  0.00
Modify  | 0.12167    | 0.12167    | 0.12167    |   0.0 |  0.32
Other   |            | 0.01069    |            |       |  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:       312042 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.0105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.431185428934, Press = -28.5053890973576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -15305.111     -15305.111     -15479.362     -15479.362      337.10094      337.10094      59604.812      59604.812     -99.163881     -99.163881    
      9000  -15299.637     -15299.637     -15473.465     -15473.465      336.28116      336.28116      59636.038      59636.038     -245.2601      -245.2601     
Loop time of 37.8822 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.281 ns/day, 10.523 hours/ns, 26.398 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    | 37.728     | 37.728     | 37.728     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021674   | 0.021674   | 0.021674   |   0.0 |  0.06
Output  | 4.6447e-05 | 4.6447e-05 | 4.6447e-05 |   0.0 |  0.00
Modify  | 0.12167    | 0.12167    | 0.12167    |   0.0 |  0.32
Other   |            | 0.01067    |            |       |  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:       312042 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.0105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.77329585524, Press = -9.17086620587914
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -15299.637     -15299.637     -15473.465     -15473.465      336.28116      336.28116      59636.038      59636.038     -245.2601      -245.2601     
     10000  -15304.142     -15304.142     -15476.114     -15476.114      332.69076      332.69076      59561.789      59561.789      1706.4993      1706.4993    
Loop time of 37.8438 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.283 ns/day, 10.512 hours/ns, 26.424 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    | 37.69      | 37.69      | 37.69      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021813   | 0.021813   | 0.021813   |   0.0 |  0.06
Output  | 3.2943e-05 | 3.2943e-05 | 3.2943e-05 |   0.0 |  0.00
Modify  | 0.12156    | 0.12156    | 0.12156    |   0.0 |  0.32
Other   |            | 0.01075    |            |       |  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:       312020 ave      312020 max      312020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312020
Ave neighs/atom = 78.005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.894137049573, Press = -4.2510463926316
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -15304.142     -15304.142     -15476.114     -15476.114      332.69076      332.69076      59561.789      59561.789      1706.4993      1706.4993    
     11000  -15308.033     -15308.033     -15477.213     -15477.213      327.28859      327.28859      59584.1        59584.1        650.24306      650.24306    
Loop time of 37.8675 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.282 ns/day, 10.519 hours/ns, 26.408 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    | 37.713     | 37.713     | 37.713     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021719   | 0.021719   | 0.021719   |   0.0 |  0.06
Output  | 4.8171e-05 | 4.8171e-05 | 4.8171e-05 |   0.0 |  0.00
Modify  | 0.12154    | 0.12154    | 0.12154    |   0.0 |  0.32
Other   |            | 0.01066    |            |       |  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:       312052 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.970886442726, Press = -12.7945870028735
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -15308.033     -15308.033     -15477.213     -15477.213      327.28859      327.28859      59584.1        59584.1        650.24306      650.24306    
     12000  -15309.321     -15309.321     -15475.825     -15475.825      322.11386      322.11386      59648.476      59648.476     -1226.0108     -1226.0108    
Loop time of 37.8032 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.286 ns/day, 10.501 hours/ns, 26.453 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    | 37.649     | 37.649     | 37.649     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021735   | 0.021735   | 0.021735   |   0.0 |  0.06
Output  | 4.3492e-05 | 4.3492e-05 | 4.3492e-05 |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.32
Other   |            | 0.01063    |            |       |  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:       311972 ave      311972 max      311972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311972
Ave neighs/atom = 77.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.786757443444, Press = -13.2042434633934
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -15309.321     -15309.321     -15475.825     -15475.825      322.11386      322.11386      59648.476      59648.476     -1226.0108     -1226.0108    
     13000  -15303.584     -15303.584     -15475.325     -15475.325      332.24426      332.24426      59652.167      59652.167     -1017.1689     -1017.1689    
Loop time of 37.8546 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.282 ns/day, 10.515 hours/ns, 26.417 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    | 37.701     | 37.701     | 37.701     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021789   | 0.021789   | 0.021789   |   0.0 |  0.06
Output  | 3.2842e-05 | 3.2842e-05 | 3.2842e-05 |   0.0 |  0.00
Modify  | 0.12148    | 0.12148    | 0.12148    |   0.0 |  0.32
Other   |            | 0.01058    |            |       |  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:       312044 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.562618784782, Press = -3.66318034619954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -15303.584     -15303.584     -15475.325     -15475.325      332.24426      332.24426      59652.167      59652.167     -1017.1689     -1017.1689    
     14000  -15298.483     -15298.483     -15473.097     -15473.097      337.80341      337.80341      59566.528      59566.528      2013.7527      2013.7527    
Loop time of 37.8059 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.285 ns/day, 10.502 hours/ns, 26.451 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    | 37.652     | 37.652     | 37.652     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02164    | 0.02164    | 0.02164    |   0.0 |  0.06
Output  | 4.7139e-05 | 4.7139e-05 | 4.7139e-05 |   0.0 |  0.00
Modify  | 0.12158    | 0.12158    | 0.12158    |   0.0 |  0.32
Other   |            | 0.01066    |            |       |  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:       311984 ave      311984 max      311984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311984
Ave neighs/atom = 77.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.447813316003, Press = -3.67818189503361
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -15298.483     -15298.483     -15473.097     -15473.097      337.80341      337.80341      59566.528      59566.528      2013.7527      2013.7527    
     15000  -15304.955     -15304.955     -15473.304     -15473.304      325.68177      325.68177      59627.782      59627.782     -230.10532     -230.10532    
Loop time of 37.8807 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.281 ns/day, 10.522 hours/ns, 26.399 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    | 37.727     | 37.727     | 37.727     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021774   | 0.021774   | 0.021774   |   0.0 |  0.06
Output  | 3.2621e-05 | 3.2621e-05 | 3.2621e-05 |   0.0 |  0.00
Modify  | 0.12164    | 0.12164    | 0.12164    |   0.0 |  0.32
Other   |            | 0.01059    |            |       |  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:       312088 ave      312088 max      312088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312088
Ave neighs/atom = 78.022
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.584994397059, Press = -6.65883923490419
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -15304.955     -15304.955     -15473.304     -15473.304      325.68177      325.68177      59627.782      59627.782     -230.10532     -230.10532    
     16000  -15301.805     -15301.805     -15474.835     -15474.835      334.73925      334.73925      59655.529      59655.529     -1182.8191     -1182.8191    
Loop time of 37.8655 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.282 ns/day, 10.518 hours/ns, 26.409 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    | 37.711     | 37.711     | 37.711     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021776   | 0.021776   | 0.021776   |   0.0 |  0.06
Output  | 4.9664e-05 | 4.9664e-05 | 4.9664e-05 |   0.0 |  0.00
Modify  | 0.12159    | 0.12159    | 0.12159    |   0.0 |  0.32
Other   |            | 0.01068    |            |       |  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:       312040 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.686591713564, Press = -0.0629476503612963
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -15301.805     -15301.805     -15474.835     -15474.835      334.73925      334.73925      59655.529      59655.529     -1182.8191     -1182.8191    
     17000  -15304.558     -15304.558     -15477.196     -15477.196      333.98086      333.98086      59563.844      59563.844      1526.7613      1526.7613    
Loop time of 37.8598 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.282 ns/day, 10.517 hours/ns, 26.413 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    | 37.706     | 37.706     | 37.706     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021655   | 0.021655   | 0.021655   |   0.0 |  0.06
Output  | 4.5596e-05 | 4.5596e-05 | 4.5596e-05 |   0.0 |  0.00
Modify  | 0.12162    | 0.12162    | 0.12162    |   0.0 |  0.32
Other   |            | 0.01073    |            |       |  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:       312064 ave      312064 max      312064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312064
Ave neighs/atom = 78.016
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.636197922817, Press = -0.186375323888143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -15304.558     -15304.558     -15477.196     -15477.196      333.98086      333.98086      59563.844      59563.844      1526.7613      1526.7613    
     18000  -15298.967     -15298.967     -15473.537     -15473.537      337.71733      337.71733      59605.671      59605.671      578.47181      578.47181    
Loop time of 37.8819 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.281 ns/day, 10.523 hours/ns, 26.398 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    | 37.728     | 37.728     | 37.728     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021783   | 0.021783   | 0.021783   |   0.0 |  0.06
Output  | 3.197e-05  | 3.197e-05  | 3.197e-05  |   0.0 |  0.00
Modify  | 0.12158    | 0.12158    | 0.12158    |   0.0 |  0.32
Other   |            | 0.01063    |            |       |  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:       312058 ave      312058 max      312058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312058
Ave neighs/atom = 78.0145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.764260126341, Press = -4.09432942998325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -15298.967     -15298.967     -15473.537     -15473.537      337.71733      337.71733      59605.671      59605.671      578.47181      578.47181    
     19000  -15301.219     -15301.219     -15475.572     -15475.572      337.29861      337.29861      59668.893      59668.893     -1712.5097     -1712.5097    
Loop time of 37.8699 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.281 ns/day, 10.519 hours/ns, 26.406 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    | 37.716     | 37.716     | 37.716     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021664   | 0.021664   | 0.021664   |   0.0 |  0.06
Output  | 4.8181e-05 | 4.8181e-05 | 4.8181e-05 |   0.0 |  0.00
Modify  | 0.12164    | 0.12164    | 0.12164    |   0.0 |  0.32
Other   |            | 0.01061    |            |       |  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:       312042 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.0105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.702805392401, Press = -5.24223577114362
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -15301.219     -15301.219     -15475.572     -15475.572      337.29861      337.29861      59668.893      59668.893     -1712.5097     -1712.5097    
     20000  -15308.597     -15308.597     -15477.197     -15477.197      326.16869      326.16869      59618.406      59618.406     -353.26523     -353.26523    
Loop time of 37.8218 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.284 ns/day, 10.506 hours/ns, 26.440 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    | 37.668     | 37.668     | 37.668     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021722   | 0.021722   | 0.021722   |   0.0 |  0.06
Output  | 4.4985e-05 | 4.4985e-05 | 4.4985e-05 |   0.0 |  0.00
Modify  | 0.1217     | 0.1217     | 0.1217     |   0.0 |  0.32
Other   |            | 0.01076    |            |       |  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:       312014 ave      312014 max      312014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312014
Ave neighs/atom = 78.0035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.569615448939, Press = -2.23477961229991
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -15308.597     -15308.597     -15477.197     -15477.197      326.16869      326.16869      59618.406      59618.406     -353.26523     -353.26523    
     21000  -15304.966     -15304.966     -15474.84      -15474.84       328.63397      328.63397      59588.658      59588.658      926.05436      926.05436    
Loop time of 37.8493 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.283 ns/day, 10.514 hours/ns, 26.421 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    | 37.695     | 37.695     | 37.695     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021749   | 0.021749   | 0.021749   |   0.0 |  0.06
Output  | 3.186e-05  | 3.186e-05  | 3.186e-05  |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  0.32
Other   |            | 0.01061    |            |       |  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:       312046 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.0115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.619619083792, Press = -0.220642749085265
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -15304.966     -15304.966     -15474.84      -15474.84       328.63397      328.63397      59588.658      59588.658      926.05436      926.05436    
     22000  -15300.093     -15300.093     -15473.666     -15473.666      335.79022      335.79022      59592.067      59592.067      1012.0913      1012.0913    
Loop time of 37.957 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.276 ns/day, 10.544 hours/ns, 26.346 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.8       | 37.8       | 37.8       |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022304   | 0.022304   | 0.022304   |   0.0 |  0.06
Output  | 5.7268e-05 | 5.7268e-05 | 5.7268e-05 |   0.0 |  0.00
Modify  | 0.12323    | 0.12323    | 0.12323    |   0.0 |  0.32
Other   |            | 0.01092    |            |       |  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:       312008 ave      312008 max      312008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312008
Ave neighs/atom = 78.002
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.663887931153, Press = -3.54889720067489
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -15300.093     -15300.093     -15473.666     -15473.666      335.79022      335.79022      59592.067      59592.067      1012.0913      1012.0913    
     23000  -15304.925     -15304.925     -15475.923     -15475.923      330.80695      330.80695      59639.815      59639.815     -837.61142     -837.61142    
Loop time of 38.0109 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.273 ns/day, 10.559 hours/ns, 26.308 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.853     | 37.853     | 37.853     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022589   | 0.022589   | 0.022589   |   0.0 |  0.06
Output  | 5.6717e-05 | 5.6717e-05 | 5.6717e-05 |   0.0 |  0.00
Modify  | 0.12368    | 0.12368    | 0.12368    |   0.0 |  0.33
Other   |            | 0.01108    |            |       |  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:       312068 ave      312068 max      312068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312068
Ave neighs/atom = 78.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.591648615286, Press = -3.18946470897965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -15304.925     -15304.925     -15475.923     -15475.923      330.80695      330.80695      59639.815      59639.815     -837.61142     -837.61142    
     24000  -15303.023     -15303.023     -15475.308     -15475.308      333.29665      333.29665      59648.37       59648.37      -1125.6395     -1125.6395    
Loop time of 38.0356 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.272 ns/day, 10.565 hours/ns, 26.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    | 37.875     | 37.875     | 37.875     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02377    | 0.02377    | 0.02377    |   0.0 |  0.06
Output  | 4.7861e-05 | 4.7861e-05 | 4.7861e-05 |   0.0 |  0.00
Modify  | 0.12529    | 0.12529    | 0.12529    |   0.0 |  0.33
Other   |            | 0.01122    |            |       |  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:       312032 ave      312032 max      312032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312032
Ave neighs/atom = 78.008
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.450615501421, Press = -1.05616216060191
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -15303.023     -15303.023     -15475.308     -15475.308      333.29665      333.29665      59648.37       59648.37      -1125.6395     -1125.6395    
     25000  -15309.823     -15309.823     -15480.42      -15480.42       330.03249      330.03249      59603.255      59603.255     -182.68368     -182.68368    
Loop time of 37.9493 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.277 ns/day, 10.541 hours/ns, 26.351 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.793     | 37.793     | 37.793     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022323   | 0.022323   | 0.022323   |   0.0 |  0.06
Output  | 6.6034e-05 | 6.6034e-05 | 6.6034e-05 |   0.0 |  0.00
Modify  | 0.12319    | 0.12319    | 0.12319    |   0.0 |  0.32
Other   |            | 0.01105    |            |       |  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:       312002 ave      312002 max      312002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312002
Ave neighs/atom = 78.0005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.405323719841, Press = -0.961762821618683
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -15309.823     -15309.823     -15480.42      -15480.42       330.03249      330.03249      59603.255      59603.255     -182.68368     -182.68368    
     26000  -15301.404     -15301.404     -15474.575     -15474.575      335.00997      335.00997      59523.616      59523.616      3086.6977      3086.6977    
Loop time of 37.9275 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.278 ns/day, 10.535 hours/ns, 26.366 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.773     | 37.773     | 37.773     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02191    | 0.02191    | 0.02191    |   0.0 |  0.06
Output  | 4.8241e-05 | 4.8241e-05 | 4.8241e-05 |   0.0 |  0.00
Modify  | 0.12205    | 0.12205    | 0.12205    |   0.0 |  0.32
Other   |            | 0.01098    |            |       |  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:       312024 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.307867060974, Press = -2.13523248670585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -15301.404     -15301.404     -15474.575     -15474.575      335.00997      335.00997      59523.616      59523.616      3086.6977      3086.6977    
     27000  -15299.331     -15299.331     -15474.924     -15474.924      339.6959       339.6959       59642.455      59642.455     -639.2939      -639.2939     
Loop time of 37.9133 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.279 ns/day, 10.531 hours/ns, 26.376 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.759     | 37.759     | 37.759     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021778   | 0.021778   | 0.021778   |   0.0 |  0.06
Output  | 4.213e-05  | 4.213e-05  | 4.213e-05  |   0.0 |  0.00
Modify  | 0.12194    | 0.12194    | 0.12194    |   0.0 |  0.32
Other   |            | 0.01089    |            |       |  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:       312060 ave      312060 max      312060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312060
Ave neighs/atom = 78.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.259662185372, Press = -3.8948584510889
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -15299.331     -15299.331     -15474.924     -15474.924      339.6959       339.6959       59642.455      59642.455     -639.2939      -639.2939     
     28000  -15304.922     -15304.922     -15477.344     -15477.344      333.56209      333.56209      59646.18       59646.18      -1093.9965     -1093.9965    
Loop time of 37.9751 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.275 ns/day, 10.549 hours/ns, 26.333 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.82      | 37.82      | 37.82      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021961   | 0.021961   | 0.021961   |   0.0 |  0.06
Output  | 5.8601e-05 | 5.8601e-05 | 5.8601e-05 |   0.0 |  0.00
Modify  | 0.12209    | 0.12209    | 0.12209    |   0.0 |  0.32
Other   |            | 0.01082    |            |       |  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:       312036 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.306563251916, Press = -1.81445811134758
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -15304.922     -15304.922     -15477.344     -15477.344      333.56209      333.56209      59646.18       59646.18      -1093.9965     -1093.9965    
     29000  -15302.132     -15302.132     -15475.401     -15475.401      335.20011      335.20011      59606.051      59606.051      347.75347      347.75347    
Loop time of 37.9508 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.277 ns/day, 10.542 hours/ns, 26.350 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.795     | 37.795     | 37.795     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022063   | 0.022063   | 0.022063   |   0.0 |  0.06
Output  | 9.6162e-05 | 9.6162e-05 | 9.6162e-05 |   0.0 |  0.00
Modify  | 0.12234    | 0.12234    | 0.12234    |   0.0 |  0.32
Other   |            | 0.01087    |            |       |  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:       312052 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.326040718977, Press = -1.13113339370676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -15302.132     -15302.132     -15475.401     -15475.401      335.20011      335.20011      59606.051      59606.051      347.75347      347.75347    
     30000  -15309.394     -15309.394     -15476.108     -15476.108      322.51948      322.51948      59575.594      59575.594      1144.0875      1144.0875    
Loop time of 37.9892 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.274 ns/day, 10.553 hours/ns, 26.323 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.832     | 37.832     | 37.832     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022626   | 0.022626   | 0.022626   |   0.0 |  0.06
Output  | 5.85e-05   | 5.85e-05   | 5.85e-05   |   0.0 |  0.00
Modify  | 0.12346    | 0.12346    | 0.12346    |   0.0 |  0.32
Other   |            | 0.01098    |            |       |  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:       311980 ave      311980 max      311980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311980
Ave neighs/atom = 77.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.253505357862, Press = -1.82643983043051
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -15309.394     -15309.394     -15476.108     -15476.108      322.51948      322.51948      59575.594      59575.594      1144.0875      1144.0875    
     31000  -15305.66      -15305.66      -15473.333     -15473.333      324.37503      324.37503      59589.98       59589.98       1104.109       1104.109     
Loop time of 38.0361 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.272 ns/day, 10.566 hours/ns, 26.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    | 37.879     | 37.879     | 37.879     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022563   | 0.022563   | 0.022563   |   0.0 |  0.06
Output  | 4.4784e-05 | 4.4784e-05 | 4.4784e-05 |   0.0 |  0.00
Modify  | 0.12358    | 0.12358    | 0.12358    |   0.0 |  0.32
Other   |            | 0.01112    |            |       |  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:       312054 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.0135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.263068697005, Press = -1.99749836108677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -15305.66      -15305.66      -15473.333     -15473.333      324.37503      324.37503      59589.98       59589.98       1104.109       1104.109     
     32000  -15300.26      -15300.26      -15476.172     -15476.172      340.31354      340.31354      59642.361      59642.361     -786.55383     -786.55383    
Loop time of 37.965 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.276 ns/day, 10.546 hours/ns, 26.340 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.809     | 37.809     | 37.809     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02236    | 0.02236    | 0.02236    |   0.0 |  0.06
Output  | 0.00014728 | 0.00014728 | 0.00014728 |   0.0 |  0.00
Modify  | 0.12288    | 0.12288    | 0.12288    |   0.0 |  0.32
Other   |            | 0.01087    |            |       |  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:       312064 ave      312064 max      312064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312064
Ave neighs/atom = 78.016
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.263560116103, Press = -3.11029363272126
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -15300.26      -15300.26      -15476.172     -15476.172      340.31354      340.31354      59642.361      59642.361     -786.55383     -786.55383    
     33000  -15304.771     -15304.771     -15476.016     -15476.016      331.28616      331.28616      59645.54       59645.54      -1085.4696     -1085.4696    
Loop time of 38.0103 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.273 ns/day, 10.558 hours/ns, 26.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    | 37.854     | 37.854     | 37.854     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022275   | 0.022275   | 0.022275   |   0.0 |  0.06
Output  | 0.00015799 | 0.00015799 | 0.00015799 |   0.0 |  0.00
Modify  | 0.12281    | 0.12281    | 0.12281    |   0.0 |  0.32
Other   |            | 0.01103    |            |       |  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:       312042 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.0105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.327320129744, Press = -0.761826295645881
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -15304.771     -15304.771     -15476.016     -15476.016      331.28616      331.28616      59645.54       59645.54      -1085.4696     -1085.4696    
     34000  -15303.886     -15303.886     -15474.834     -15474.834      330.7109       330.7109       59586.91       59586.91       905.6373       905.6373     
Loop time of 38.0291 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.272 ns/day, 10.564 hours/ns, 26.296 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    | 37.871     | 37.871     | 37.871     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02285    | 0.02285    | 0.02285    |   0.0 |  0.06
Output  | 5.1858e-05 | 5.1858e-05 | 5.1858e-05 |   0.0 |  0.00
Modify  | 0.12406    | 0.12406    | 0.12406    |   0.0 |  0.33
Other   |            | 0.01112    |            |       |  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:       312020 ave      312020 max      312020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312020
Ave neighs/atom = 78.005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.348334439863, Press = -1.45722113229638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -15303.886     -15303.886     -15474.834     -15474.834      330.7109       330.7109       59586.91       59586.91       905.6373       905.6373     
     35000  -15304.885     -15304.885     -15475.237     -15475.237      329.5584       329.5584       59589.437      59589.437      817.96754      817.96754    
Loop time of 37.9558 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.276 ns/day, 10.543 hours/ns, 26.346 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.8       | 37.8       | 37.8       |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022257   | 0.022257   | 0.022257   |   0.0 |  0.06
Output  | 0.00011129 | 0.00011129 | 0.00011129 |   0.0 |  0.00
Modify  | 0.12281    | 0.12281    | 0.12281    |   0.0 |  0.32
Other   |            | 0.0109     |            |       |  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:       312054 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.0135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.33397376772, Press = -1.63821617911356
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -15304.885     -15304.885     -15475.237     -15475.237      329.5584       329.5584       59589.437      59589.437      817.96754      817.96754    
     36000  -15309.322     -15309.322     -15481.163     -15481.163      332.4384       332.4384       59573.915      59573.915      616.48341      616.48341    
Loop time of 38.0439 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.271 ns/day, 10.568 hours/ns, 26.285 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.885     | 37.885     | 37.885     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023005   | 0.023005   | 0.023005   |   0.0 |  0.06
Output  | 0.00017194 | 0.00017194 | 0.00017194 |   0.0 |  0.00
Modify  | 0.12423    | 0.12423    | 0.12423    |   0.0 |  0.33
Other   |            | 0.01111    |            |       |  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:       312008 ave      312008 max      312008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312008
Ave neighs/atom = 78.002
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.321378968678, Press = -2.35964412200044
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -15309.322     -15309.322     -15481.163     -15481.163      332.4384       332.4384       59573.915      59573.915      616.48341      616.48341    
     37000  -15301.986     -15301.986     -15475.301     -15475.301      335.29034      335.29034      59713.901      59713.901     -3107.6828     -3107.6828    
Loop time of 38.0591 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.270 ns/day, 10.572 hours/ns, 26.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    | 37.901     | 37.901     | 37.901     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022932   | 0.022932   | 0.022932   |   0.0 |  0.06
Output  | 4.9583e-05 | 4.9583e-05 | 4.9583e-05 |   0.0 |  0.00
Modify  | 0.12393    | 0.12393    | 0.12393    |   0.0 |  0.33
Other   |            | 0.01109    |            |       |  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:       312054 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.0135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.259956570849, Press = -3.09855259821762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -15301.986     -15301.986     -15475.301     -15475.301      335.29034      335.29034      59713.901      59713.901     -3107.6828     -3107.6828    
     38000  -15301.736     -15301.736     -15473.422     -15473.422      332.13652      332.13652      59644.033      59644.033     -514.07198     -514.07198    
Loop time of 37.9186 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.279 ns/day, 10.533 hours/ns, 26.372 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.763     | 37.763     | 37.763     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022307   | 0.022307   | 0.022307   |   0.0 |  0.06
Output  | 9.9658e-05 | 9.9658e-05 | 9.9658e-05 |   0.0 |  0.00
Modify  | 0.12275    | 0.12275    | 0.12275    |   0.0 |  0.32
Other   |            | 0.01089    |            |       |  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:       312014 ave      312014 max      312014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312014
Ave neighs/atom = 78.0035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.22079733531, Press = 0.690775719215567
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -15301.736     -15301.736     -15473.422     -15473.422      332.13652      332.13652      59644.033      59644.033     -514.07198     -514.07198    
     39000  -15310.162     -15310.162     -15479.753     -15479.753      328.08682      328.08682      59564.904      59564.904      1072.1537      1072.1537    
Loop time of 37.9446 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.277 ns/day, 10.540 hours/ns, 26.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    | 37.79      | 37.79      | 37.79      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02186    | 0.02186    | 0.02186    |   0.0 |  0.06
Output  | 5.9983e-05 | 5.9983e-05 | 5.9983e-05 |   0.0 |  0.00
Modify  | 0.12174    | 0.12174    | 0.12174    |   0.0 |  0.32
Other   |            | 0.01092    |            |       |  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:       311998 ave      311998 max      311998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311998
Ave neighs/atom = 77.9995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.195915172157, Press = -0.69705427418644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -15310.162     -15310.162     -15479.753     -15479.753      328.08682      328.08682      59564.904      59564.904      1072.1537      1072.1537    
     40000  -15303.258     -15303.258     -15475.505     -15475.505      333.22393      333.22393      59625.404      59625.404     -291.94937     -291.94937    
Loop time of 37.9413 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.277 ns/day, 10.539 hours/ns, 26.356 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.786     | 37.786     | 37.786     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021983   | 0.021983   | 0.021983   |   0.0 |  0.06
Output  | 0.00011042 | 0.00011042 | 0.00011042 |   0.0 |  0.00
Modify  | 0.12216    | 0.12216    | 0.12216    |   0.0 |  0.32
Other   |            | 0.01075    |            |       |  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:       312066 ave      312066 max      312066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312066
Ave neighs/atom = 78.0165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.164580599557, Press = -1.94897012825992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -15303.258     -15303.258     -15475.505     -15475.505      333.22393      333.22393      59625.404      59625.404     -291.94937     -291.94937    
     41000  -15303.45      -15303.45      -15474.313     -15474.313      330.54644      330.54644      59590.08       59590.08       1104.7351      1104.7351    
Loop time of 37.9117 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.279 ns/day, 10.531 hours/ns, 26.377 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.756     | 37.756     | 37.756     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022357   | 0.022357   | 0.022357   |   0.0 |  0.06
Output  | 0.00014076 | 0.00014076 | 0.00014076 |   0.0 |  0.00
Modify  | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.32
Other   |            | 0.01088    |            |       |  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:       312046 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.0115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.104386846086, Press = -0.767707942684759
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -15303.45      -15303.45      -15474.313     -15474.313      330.54644      330.54644      59590.08       59590.08       1104.7351      1104.7351    
     42000  -15305.138     -15305.138     -15477.876     -15477.876      334.17385      334.17385      59564.309      59564.309      1440.9888      1440.9888    
Loop time of 38.0716 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.269 ns/day, 10.575 hours/ns, 26.266 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.914     | 37.914     | 37.914     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022812   | 0.022812   | 0.022812   |   0.0 |  0.06
Output  | 0.00015296 | 0.00015296 | 0.00015296 |   0.0 |  0.00
Modify  | 0.12384    | 0.12384    | 0.12384    |   0.0 |  0.33
Other   |            | 0.01102    |            |       |  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:       312062 ave      312062 max      312062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312062
Ave neighs/atom = 78.0155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.119754831277, Press = -2.58179539384772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -15305.138     -15305.138     -15477.876     -15477.876      334.17385      334.17385      59564.309      59564.309      1440.9888      1440.9888    
     43000  -15302.257     -15302.257     -15475.7       -15475.7        335.53809      335.53809      59690.365      59690.365     -2310.4545     -2310.4545    
Loop time of 38.0424 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.271 ns/day, 10.567 hours/ns, 26.286 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.884     | 37.884     | 37.884     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023151   | 0.023151   | 0.023151   |   0.0 |  0.06
Output  | 5.5485e-05 | 5.5485e-05 | 5.5485e-05 |   0.0 |  0.00
Modify  | 0.12423    | 0.12423    | 0.12423    |   0.0 |  0.33
Other   |            | 0.011      |            |       |  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:       312016 ave      312016 max      312016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312016
Ave neighs/atom = 78.004
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.148085461487, Press = -1.59987094471579
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -15302.257     -15302.257     -15475.7       -15475.7        335.53809      335.53809      59690.365      59690.365     -2310.4545     -2310.4545    
     44000  -15303.581     -15303.581     -15477.313     -15477.313      336.09652      336.09652      59640.785      59640.785     -878.91888     -878.91888    
Loop time of 38.0186 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.273 ns/day, 10.561 hours/ns, 26.303 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.861     | 37.861     | 37.861     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022849   | 0.022849   | 0.022849   |   0.0 |  0.06
Output  | 6.6416e-05 | 6.6416e-05 | 6.6416e-05 |   0.0 |  0.00
Modify  | 0.12381    | 0.12381    | 0.12381    |   0.0 |  0.33
Other   |            | 0.01098    |            |       |  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 = 333.150661981421, Press = -1.16656011430949
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -15303.581     -15303.581     -15477.313     -15477.313      336.09652      336.09652      59640.785      59640.785     -878.91888     -878.91888    
     45000  -15307.779     -15307.779     -15476.419     -15476.419      326.24522      326.24522      59624.57       59624.57      -519.46196     -519.46196    
Loop time of 38.0146 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.273 ns/day, 10.560 hours/ns, 26.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    | 37.858     | 37.858     | 37.858     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022452   | 0.022452   | 0.022452   |   0.0 |  0.06
Output  | 4.777e-05  | 4.777e-05  | 4.777e-05  |   0.0 |  0.00
Modify  | 0.1231     | 0.1231     | 0.1231     |   0.0 |  0.32
Other   |            | 0.0109     |            |       |  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:       312022 ave      312022 max      312022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312022
Ave neighs/atom = 78.0055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.147296537397, Press = -1.23620162052174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -15307.779     -15307.779     -15476.419     -15476.419      326.24522      326.24522      59624.57       59624.57      -519.46196     -519.46196    
     46000  -15302.774     -15302.774     -15474.207     -15474.207      331.64802      331.64802      59633.896      59633.896     -350.82701     -350.82701    
Loop time of 38.0003 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.274 ns/day, 10.556 hours/ns, 26.316 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.843     | 37.843     | 37.843     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022642   | 0.022642   | 0.022642   |   0.0 |  0.06
Output  | 0.00011922 | 0.00011922 | 0.00011922 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.32
Other   |            | 0.01094    |            |       |  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:       312024 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.14499029885, Press = -0.832958211498654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -15302.774     -15302.774     -15474.207     -15474.207      331.64802      331.64802      59633.896      59633.896     -350.82701     -350.82701    
     47000  -15302.634     -15302.634     -15473.854     -15473.854      331.23659      331.23659      59613.744      59613.744      264.11786      264.11786    
Loop time of 37.8751 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.281 ns/day, 10.521 hours/ns, 26.403 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.719     | 37.719     | 37.719     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022464   | 0.022464   | 0.022464   |   0.0 |  0.06
Output  | 4.4794e-05 | 4.4794e-05 | 4.4794e-05 |   0.0 |  0.00
Modify  | 0.12309    | 0.12309    | 0.12309    |   0.0 |  0.32
Other   |            | 0.01089    |            |       |  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:       312058 ave      312058 max      312058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312058
Ave neighs/atom = 78.0145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.081845580339, Press = -1.25319895867123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -15302.634     -15302.634     -15473.854     -15473.854      331.23659      331.23659      59613.744      59613.744      264.11786      264.11786    
     48000  -15305.299     -15305.299     -15479.247     -15479.247      336.51388      336.51388      59625.555      59625.555     -764.89243     -764.89243    
Loop time of 37.9697 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.276 ns/day, 10.547 hours/ns, 26.337 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.813     | 37.813     | 37.813     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02264    | 0.02264    | 0.02264    |   0.0 |  0.06
Output  | 0.00014867 | 0.00014867 | 0.00014867 |   0.0 |  0.00
Modify  | 0.12328    | 0.12328    | 0.12328    |   0.0 |  0.32
Other   |            | 0.01096    |            |       |  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:       312032 ave      312032 max      312032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312032
Ave neighs/atom = 78.008
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.09849094315, Press = -1.7693160692013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -15305.299     -15305.299     -15479.247     -15479.247      336.51388      336.51388      59625.555      59625.555     -764.89243     -764.89243    
     49000  -15298.823     -15298.823     -15473.355     -15473.355      337.64406      337.64406      59673.038      59673.038     -1640.2669     -1640.2669    
Loop time of 38.0714 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.269 ns/day, 10.575 hours/ns, 26.266 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.914     | 37.914     | 37.914     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022707   | 0.022707   | 0.022707   |   0.0 |  0.06
Output  | 0.00013955 | 0.00013955 | 0.00013955 |   0.0 |  0.00
Modify  | 0.1234     | 0.1234     | 0.1234     |   0.0 |  0.32
Other   |            | 0.01102    |            |       |  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:       312030 ave      312030 max      312030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312030
Ave neighs/atom = 78.0075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.14928718703, Press = -0.801682478993123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -15298.823     -15298.823     -15473.355     -15473.355      337.64406      337.64406      59673.038      59673.038     -1640.2669     -1640.2669    
     50000  -15303.973     -15303.973     -15475.367     -15475.367      331.57446      331.57446      59584.017      59584.017      992.0616       992.0616     
Loop time of 37.9347 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.278 ns/day, 10.537 hours/ns, 26.361 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.777     | 37.777     | 37.777     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022922   | 0.022922   | 0.022922   |   0.0 |  0.06
Output  | 4.3192e-05 | 4.3192e-05 | 4.3192e-05 |   0.0 |  0.00
Modify  | 0.12385    | 0.12385    | 0.12385    |   0.0 |  0.33
Other   |            | 0.01105    |            |       |  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:       312044 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.174362198711, Press = 0.288503958150681
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -15303.973     -15303.973     -15475.367     -15475.367      331.57446      331.57446      59584.017      59584.017      992.0616       992.0616     
     51000  -15300.487     -15300.487     -15477.036     -15477.036      341.54619      341.54619      59605.335      59605.335      168.81377      168.81377    
Loop time of 37.9952 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.274 ns/day, 10.554 hours/ns, 26.319 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.837     | 37.837     | 37.837     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023033   | 0.023033   | 0.023033   |   0.0 |  0.06
Output  | 5.5224e-05 | 5.5224e-05 | 5.5224e-05 |   0.0 |  0.00
Modify  | 0.124      | 0.124      | 0.124      |   0.0 |  0.33
Other   |            | 0.01108    |            |       |  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:       312052 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.215483717307, Press = -1.21609151353456
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -15300.487     -15300.487     -15477.036     -15477.036      341.54619      341.54619      59605.335      59605.335      168.81377      168.81377    
     52000  -15302.625     -15302.625     -15475.966     -15475.966      335.33969      335.33969      59615.799      59615.799     -42.314542     -42.314542    
Loop time of 37.9127 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.279 ns/day, 10.531 hours/ns, 26.376 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.757     | 37.757     | 37.757     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022231   | 0.022231   | 0.022231   |   0.0 |  0.06
Output  | 5.6467e-05 | 5.6467e-05 | 5.6467e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.32
Other   |            | 0.01086    |            |       |  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:       312024 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.206843386125, Press = -1.34156729316403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -15302.625     -15302.625     -15475.966     -15475.966      335.33969      335.33969      59615.799      59615.799     -42.314542     -42.314542    
     53000  -15303.762     -15303.762     -15476.778     -15476.778      334.7106       334.7106       59619.691      59619.691     -292.41692     -292.41692    
Loop time of 37.9761 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.275 ns/day, 10.549 hours/ns, 26.332 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.821     | 37.821     | 37.821     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021922   | 0.021922   | 0.021922   |   0.0 |  0.06
Output  | 0.00013347 | 0.00013347 | 0.00013347 |   0.0 |  0.00
Modify  | 0.12206    | 0.12206    | 0.12206    |   0.0 |  0.32
Other   |            | 0.01079    |            |       |  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:       312044 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.206560813265, Press = -0.690064569470164
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -15303.762     -15303.762     -15476.778     -15476.778      334.7106       334.7106       59619.691      59619.691     -292.41692     -292.41692    
     54000  -15305.825     -15305.825     -15474.767     -15474.767      326.82921      326.82921      59610.295      59610.295      71.018999      71.018999    
Loop time of 38.0352 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.272 ns/day, 10.565 hours/ns, 26.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    | 37.879     | 37.879     | 37.879     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022355   | 0.022355   | 0.022355   |   0.0 |  0.06
Output  | 4.7229e-05 | 4.7229e-05 | 4.7229e-05 |   0.0 |  0.00
Modify  | 0.12287    | 0.12287    | 0.12287    |   0.0 |  0.32
Other   |            | 0.01089    |            |       |  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:       312024 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.190661417595, Press = -0.781408508419897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -15305.825     -15305.825     -15474.767     -15474.767      326.82921      326.82921      59610.295      59610.295      71.018999      71.018999    
     55000  -15301.553     -15301.553     -15473.498     -15473.498      332.63948      332.63948      59583.381      59583.381      1197.5427      1197.5427    
Loop time of 37.888 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.280 ns/day, 10.524 hours/ns, 26.394 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.733     | 37.733     | 37.733     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02194    | 0.02194    | 0.02194    |   0.0 |  0.06
Output  | 4.1609e-05 | 4.1609e-05 | 4.1609e-05 |   0.0 |  0.00
Modify  | 0.12219    | 0.12219    | 0.12219    |   0.0 |  0.32
Other   |            | 0.01076    |            |       |  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:       312046 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.0115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.153540523762, Press = -0.350260252434545
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -15301.553     -15301.553     -15473.498     -15473.498      332.63948      332.63948      59583.381      59583.381      1197.5427      1197.5427    
     56000  -15308.667     -15308.667     -15480.944     -15480.944      333.28107      333.28107      59543.191      59543.191      1611.6662      1611.6662    
Loop time of 38.0315 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.272 ns/day, 10.564 hours/ns, 26.294 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.874     | 37.874     | 37.874     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022825   | 0.022825   | 0.022825   |   0.0 |  0.06
Output  | 0.00011783 | 0.00011783 | 0.00011783 |   0.0 |  0.00
Modify  | 0.12376    | 0.12376    | 0.12376    |   0.0 |  0.33
Other   |            | 0.011      |            |       |  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:       312056 ave      312056 max      312056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312056
Ave neighs/atom = 78.014
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.153391246117, Press = -1.53592449428482
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -15308.667     -15308.667     -15480.944     -15480.944      333.28107      333.28107      59543.191      59543.191      1611.6662      1611.6662    
     57000  -15300.32      -15300.32      -15474.816     -15474.816      337.57539      337.57539      59692.591      59692.591     -2332.6639     -2332.6639    
Loop time of 38.0221 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.272 ns/day, 10.562 hours/ns, 26.300 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.866     | 37.866     | 37.866     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022187   | 0.022187   | 0.022187   |   0.0 |  0.06
Output  | 4.3672e-05 | 4.3672e-05 | 4.3672e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.32
Other   |            | 0.01093    |            |       |  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:       312054 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.0135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.131039219181, Press = -2.24742425274102
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -15300.32      -15300.32      -15474.816     -15474.816      337.57539      337.57539      59692.591      59692.591     -2332.6639     -2332.6639    
     58000  -15303.327     -15303.327     -15476.191     -15476.191      334.41815      334.41815      59647.529      59647.529     -1037.7445     -1037.7445    
Loop time of 37.9907 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.274 ns/day, 10.553 hours/ns, 26.322 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.834     | 37.834     | 37.834     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02241    | 0.02241    | 0.02241    |   0.0 |  0.06
Output  | 4.6468e-05 | 4.6468e-05 | 4.6468e-05 |   0.0 |  0.00
Modify  | 0.12293    | 0.12293    | 0.12293    |   0.0 |  0.32
Other   |            | 0.01094    |            |       |  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:       312064 ave      312064 max      312064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312064
Ave neighs/atom = 78.016
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.147387543787, Press = -0.593557027208855
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -15303.327     -15303.327     -15476.191     -15476.191      334.41815      334.41815      59647.529      59647.529     -1037.7445     -1037.7445    
     59000  -15303.596     -15303.596     -15476.547     -15476.547      334.58521      334.58521      59611.095      59611.095     -98.243627     -98.243627    
Loop time of 37.979 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.275 ns/day, 10.550 hours/ns, 26.330 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.823     | 37.823     | 37.823     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022176   | 0.022176   | 0.022176   |   0.0 |  0.06
Output  | 5.9763e-05 | 5.9763e-05 | 5.9763e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.32
Other   |            | 0.011      |            |       |  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:       312028 ave      312028 max      312028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312028
Ave neighs/atom = 78.007
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.183188636789, Press = -1.3284009590953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -15303.596     -15303.596     -15476.547     -15476.547      334.58521      334.58521      59611.095      59611.095     -98.243627     -98.243627    
     60000  -15303.333     -15303.333     -15474.589     -15474.589      331.30627      331.30627      59636.528      59636.528     -556.11645     -556.11645    
Loop time of 37.9609 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.276 ns/day, 10.545 hours/ns, 26.343 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.807     | 37.807     | 37.807     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021664   | 0.021664   | 0.021664   |   0.0 |  0.06
Output  | 0.00012919 | 0.00012919 | 0.00012919 |   0.0 |  0.00
Modify  | 0.12127    | 0.12127    | 0.12127    |   0.0 |  0.32
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:       312040 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.172664542597, Press = -1.2137089524241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -15303.333     -15303.333     -15474.589     -15474.589      331.30627      331.30627      59636.528      59636.528     -556.11645     -556.11645    
     61000  -15302.495     -15302.495     -15474.982     -15474.982      333.68744      333.68744      59661.032      59661.032     -1291.2765     -1291.2765    
Loop time of 38.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.271 ns/day, 10.566 hours/ns, 26.289 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.884     | 37.884     | 37.884     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021893   | 0.021893   | 0.021893   |   0.0 |  0.06
Output  | 5.4883e-05 | 5.4883e-05 | 5.4883e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.32
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:       311998 ave      311998 max      311998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311998
Ave neighs/atom = 77.9995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.165008499198, Press = -0.376745907226565
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -15302.495     -15302.495     -15474.982     -15474.982      333.68744      333.68744      59661.032      59661.032     -1291.2765     -1291.2765    
     62000  -15304.971     -15304.971     -15478.978     -15478.978      336.62835      336.62835      59542.591      59542.591      1905.0342      1905.0342    
Loop time of 37.9736 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.275 ns/day, 10.548 hours/ns, 26.334 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.82      | 37.82      | 37.82      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021668   | 0.021668   | 0.021668   |   0.0 |  0.06
Output  | 5.4613e-05 | 5.4613e-05 | 5.4613e-05 |   0.0 |  0.00
Modify  | 0.12142    | 0.12142    | 0.12142    |   0.0 |  0.32
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:       312038 ave      312038 max      312038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312038
Ave neighs/atom = 78.0095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.166574790237, Press = 0.358172350282469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -15304.971     -15304.971     -15478.978     -15478.978      336.62835      336.62835      59542.591      59542.591      1905.0342      1905.0342    
     63000  -15301.998     -15301.998     -15477.982     -15477.982      340.453        340.453        59583.2        59583.2        609.68501      609.68501    
Loop time of 37.8654 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.282 ns/day, 10.518 hours/ns, 26.409 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.712     | 37.712     | 37.712     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021616   | 0.021616   | 0.021616   |   0.0 |  0.06
Output  | 4.4494e-05 | 4.4494e-05 | 4.4494e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.32
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:       312048 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.174327285801, Press = -1.08067640175263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -15301.998     -15301.998     -15477.982     -15477.982      340.453        340.453        59583.2        59583.2        609.68501      609.68501    
     64000  -15296.968     -15296.968     -15470.334     -15470.334      335.38693      335.38693      59654.784      59654.784     -660.13499     -660.13499    
Loop time of 37.8613 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.282 ns/day, 10.517 hours/ns, 26.412 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.708     | 37.708     | 37.708     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021514   | 0.021514   | 0.021514   |   0.0 |  0.06
Output  | 5.5384e-05 | 5.5384e-05 | 5.5384e-05 |   0.0 |  0.00
Modify  | 0.12083    | 0.12083    | 0.12083    |   0.0 |  0.32
Other   |            | 0.01053    |            |       |  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:       312068 ave      312068 max      312068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312068
Ave neighs/atom = 78.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.188500895226, Press = -1.06605811333275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -15296.968     -15296.968     -15470.334     -15470.334      335.38693      335.38693      59654.784      59654.784     -660.13499     -660.13499    
     65000  -15305.445     -15305.445     -15476.502     -15476.502      330.92056      330.92056      59650.83       59650.83      -1380.8527     -1380.8527    
Loop time of 37.883 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.281 ns/day, 10.523 hours/ns, 26.397 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.73      | 37.73      | 37.73      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021602   | 0.021602   | 0.021602   |   0.0 |  0.06
Output  | 5.297e-05  | 5.297e-05  | 5.297e-05  |   0.0 |  0.00
Modify  | 0.12095    | 0.12095    | 0.12095    |   0.0 |  0.32
Other   |            | 0.01054    |            |       |  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:       312058 ave      312058 max      312058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312058
Ave neighs/atom = 78.0145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.216615126764, Press = -0.387306909274347
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -15305.445     -15305.445     -15476.502     -15476.502      330.92056      330.92056      59650.83       59650.83      -1380.8527     -1380.8527    
     66000  -15302.744     -15302.744     -15475.498     -15475.498      334.20528      334.20528      59586.993      59586.993      689.94123      689.94123    
Loop time of 37.9581 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.276 ns/day, 10.544 hours/ns, 26.345 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.805     | 37.805     | 37.805     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021575   | 0.021575   | 0.021575   |   0.0 |  0.06
Output  | 5.5295e-05 | 5.5295e-05 | 5.5295e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.32
Other   |            | 0.01056    |            |       |  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:       312004 ave      312004 max      312004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0