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

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

kim_interactions Ni

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

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


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9614516893 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_115454747503_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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17627.791     -17627.791     -17800         -17800          333.15         333.15         43665.961      43665.961      4212.4642      4212.4642    
      1000  -17443.869     -17443.869     -17624.378     -17624.378      349.20584      349.20584      44225.061      44225.061     -853.8124      -853.8124     
Loop time of 447.087 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.191 hours/ns, 2.237 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 446.15     | 446.15     | 446.15     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14455    | 0.14455    | 0.14455    |   0.0 |  0.03
Output  | 0.0003421  | 0.0003421  | 0.0003421  |   0.0 |  0.00
Modify  | 0.69014    | 0.69014    | 0.69014    |   0.0 |  0.15
Other   |            | 0.09775    |            |       |  0.02

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

Total # of neighbors = 344000
Ave neighs/atom = 86
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17443.869     -17443.869     -17624.378     -17624.378      349.20584      349.20584      44225.061      44225.061     -853.8124      -853.8124     
      2000  -17454.609     -17454.609     -17623.77      -17623.77       327.25301      327.25301      44222.94       44222.94      -887.66446     -887.66446    
Loop time of 483.235 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.232 hours/ns, 2.069 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.26     | 482.26     | 482.26     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14899    | 0.14899    | 0.14899    |   0.0 |  0.03
Output  | 0.00023118 | 0.00023118 | 0.00023118 |   0.0 |  0.00
Modify  | 0.72682    | 0.72682    | 0.72682    |   0.0 |  0.15
Other   |            | 0.09991    |            |       |  0.02

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

Total # of neighbors = 360018
Ave neighs/atom = 90.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 = 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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17454.609     -17454.609     -17623.77      -17623.77       327.25301      327.25301      44222.94       44222.94      -887.66446     -887.66446    
      3000  -17453.858     -17453.858     -17622.126     -17622.126      325.52599      325.52599      44191.003      44191.003      523.13211      523.13211    
Loop time of 480.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.588 hours/ns, 2.079 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 479.94     | 479.94     | 479.94     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14776    | 0.14776    | 0.14776    |   0.0 |  0.03
Output  | 0.000229   | 0.000229   | 0.000229   |   0.0 |  0.00
Modify  | 0.72304    | 0.72304    | 0.72304    |   0.0 |  0.15
Other   |            | 0.1002     |            |       |  0.02

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

Total # of neighbors = 360722
Ave neighs/atom = 90.1805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17453.858     -17453.858     -17622.126     -17622.126      325.52599      325.52599      44191.003      44191.003      523.13211      523.13211    
      4000  -17450.643     -17450.643     -17625.437     -17625.437      338.15071      338.15071      44188.212      44188.212      514.12723      514.12723    
Loop time of 484.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.659 hours/ns, 2.063 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.8      | 483.8      | 483.8      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14905    | 0.14905    | 0.14905    |   0.0 |  0.03
Output  | 0.0002673  | 0.0002673  | 0.0002673  |   0.0 |  0.00
Modify  | 0.71884    | 0.71884    | 0.71884    |   0.0 |  0.15
Other   |            | 0.0997     |            |       |  0.02

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

Total # of neighbors = 361338
Ave neighs/atom = 90.3345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17450.643     -17450.643     -17625.437     -17625.437      338.15071      338.15071      44188.212      44188.212      514.12723      514.12723    
      5000  -17455.811     -17455.811     -17624.511     -17624.511      326.36332      326.36332      44199.096      44199.096      24.890805      24.890805    
Loop time of 480.078 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.355 hours/ns, 2.083 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 479.12     | 479.12     | 479.12     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14711    | 0.14711    | 0.14711    |   0.0 |  0.03
Output  | 0.00018674 | 0.00018674 | 0.00018674 |   0.0 |  0.00
Modify  | 0.71362    | 0.71362    | 0.71362    |   0.0 |  0.15
Other   |            | 0.09939    |            |       |  0.02

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

Total # of neighbors = 360932
Ave neighs/atom = 90.233
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.186924086434, Press = -457.13637937618
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17455.811     -17455.811     -17624.511     -17624.511      326.36332      326.36332      44199.096      44199.096      24.890805      24.890805    
      6000  -17449.586     -17449.586     -17623.112     -17623.112      335.69747      335.69747      44248.817      44248.817     -1803.0244     -1803.0244    
Loop time of 482.231 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 133.953 hours/ns, 2.074 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 481.23     | 481.23     | 481.23     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14936    | 0.14936    | 0.14936    |   0.0 |  0.03
Output  | 0.0001908  | 0.0001908  | 0.0001908  |   0.0 |  0.00
Modify  | 0.75458    | 0.75458    | 0.75458    |   0.0 |  0.16
Other   |            | 0.1002     |            |       |  0.02

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

Total # of neighbors = 360782
Ave neighs/atom = 90.1955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.693656272577, Press = -17.2364708706436
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17449.586     -17449.586     -17623.112     -17623.112      335.69747      335.69747      44248.817      44248.817     -1803.0244     -1803.0244    
      7000  -17455.624     -17455.624     -17627.618     -17627.618      332.73396      332.73396      44179.77       44179.77       565.9984       565.9984     
Loop time of 489.33 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.925 hours/ns, 2.044 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 488.31     | 488.31     | 488.31     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14991    | 0.14991    | 0.14991    |   0.0 |  0.03
Output  | 0.00023463 | 0.00023463 | 0.00023463 |   0.0 |  0.00
Modify  | 0.76745    | 0.76745    | 0.76745    |   0.0 |  0.16
Other   |            | 0.1017     |            |       |  0.02

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

Total # of neighbors = 360462
Ave neighs/atom = 90.1155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.979382151009, Press = 29.815661697303
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17455.624     -17455.624     -17627.618     -17627.618      332.73396      332.73396      44179.77       44179.77       565.9984       565.9984     
      8000  -17451.898     -17451.898     -17625.065     -17625.065      335.00256      335.00256      44135.688      44135.688      2684.7649      2684.7649    
Loop time of 486.785 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.218 hours/ns, 2.054 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 485.78     | 485.78     | 485.78     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14874    | 0.14874    | 0.14874    |   0.0 |  0.03
Output  | 0.00033811 | 0.00033811 | 0.00033811 |   0.0 |  0.00
Modify  | 0.75754    | 0.75754    | 0.75754    |   0.0 |  0.16
Other   |            | 0.1012     |            |       |  0.02

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

Total # of neighbors = 360356
Ave neighs/atom = 90.089
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.926839419731, Press = -9.08734069922884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17451.898     -17451.898     -17625.065     -17625.065      335.00256      335.00256      44135.688      44135.688      2684.7649      2684.7649    
      9000  -17456.684     -17456.684     -17628.358     -17628.358      332.11492      332.11492      44195.006      44195.006     -156.43421     -156.43421    
Loop time of 488.816 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.782 hours/ns, 2.046 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 487.8      | 487.8      | 487.8      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14997    | 0.14997    | 0.14997    |   0.0 |  0.03
Output  | 0.00024008 | 0.00024008 | 0.00024008 |   0.0 |  0.00
Modify  | 0.76634    | 0.76634    | 0.76634    |   0.0 |  0.16
Other   |            | 0.1011     |            |       |  0.02

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

Total # of neighbors = 361652
Ave neighs/atom = 90.413
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.605830321344, Press = -14.2747326952659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17456.684     -17456.684     -17628.358     -17628.358      332.11492      332.11492      44195.006      44195.006     -156.43421     -156.43421    
     10000  -17452.312     -17452.312     -17623.316     -17623.316      330.81852      330.81852      44217.769      44217.769     -676.65242     -676.65242    
Loop time of 491.322 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.176 ns/day, 136.478 hours/ns, 2.035 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 490.3      | 490.3      | 490.3      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15108    | 0.15108    | 0.15108    |   0.0 |  0.03
Output  | 0.00018814 | 0.00018814 | 0.00018814 |   0.0 |  0.00
Modify  | 0.76798    | 0.76798    | 0.76798    |   0.0 |  0.16
Other   |            | 0.101      |            |       |  0.02

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

Total # of neighbors = 360156
Ave neighs/atom = 90.039
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.757070475467, Press = -3.69148460869639
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17452.312     -17452.312     -17623.316     -17623.316      330.81852      330.81852      44217.769      44217.769     -676.65242     -676.65242    
     11000  -17457.39      -17457.39      -17627.562     -17627.562      329.21107      329.21107      44188.626      44188.626      59.213081      59.213081    
Loop time of 494.289 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.175 ns/day, 137.302 hours/ns, 2.023 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 493.25     | 493.25     | 493.25     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15123    | 0.15123    | 0.15123    |   0.0 |  0.03
Output  | 0.00024139 | 0.00024139 | 0.00024139 |   0.0 |  0.00
Modify  | 0.78093    | 0.78093    | 0.78093    |   0.0 |  0.16
Other   |            | 0.1025     |            |       |  0.02

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

Total # of neighbors = 360652
Ave neighs/atom = 90.163
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.000101547555, Press = -1.13024799579961
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17457.39      -17457.39      -17627.562     -17627.562      329.21107      329.21107      44188.626      44188.626      59.213081      59.213081    
     12000  -17454.022     -17454.022     -17626.766     -17626.766      334.18579      334.18579      44156.712      44156.712      1604.3938      1604.3938    
Loop time of 488.647 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.735 hours/ns, 2.046 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 487.64     | 487.64     | 487.64     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15016    | 0.15016    | 0.15016    |   0.0 |  0.03
Output  | 0.00018728 | 0.00018728 | 0.00018728 |   0.0 |  0.00
Modify  | 0.75854    | 0.75854    | 0.75854    |   0.0 |  0.16
Other   |            | 0.1008     |            |       |  0.02

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

Total # of neighbors = 360940
Ave neighs/atom = 90.235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.948490133195, Press = -2.28741907596316
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17454.022     -17454.022     -17626.766     -17626.766      334.18579      334.18579      44156.712      44156.712      1604.3938      1604.3938    
     13000  -17452.457     -17452.457     -17620.795     -17620.795      325.66046      325.66046      44201.928      44201.928      281.20406      281.20406    
Loop time of 484.818 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.672 hours/ns, 2.063 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.83     | 483.83     | 483.83     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14817    | 0.14817    | 0.14817    |   0.0 |  0.03
Output  | 0.00023338 | 0.00023338 | 0.00023338 |   0.0 |  0.00
Modify  | 0.74342    | 0.74342    | 0.74342    |   0.0 |  0.15
Other   |            | 0.1003     |            |       |  0.02

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

Total # of neighbors = 361434
Ave neighs/atom = 90.3585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.693835343345, Press = -11.5212654465236
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17452.457     -17452.457     -17620.795     -17620.795      325.66046      325.66046      44201.928      44201.928      281.20406      281.20406    
     14000  -17458.587     -17458.587     -17626.774     -17626.774      325.36962      325.36962      44248.181      44248.181     -2250.9151     -2250.9151    
Loop time of 485.307 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.808 hours/ns, 2.061 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 484.3      | 484.3      | 484.3      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14958    | 0.14958    | 0.14958    |   0.0 |  0.03
Output  | 0.00024412 | 0.00024412 | 0.00024412 |   0.0 |  0.00
Modify  | 0.7605     | 0.7605     | 0.7605     |   0.0 |  0.16
Other   |            | 0.1014     |            |       |  0.02

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

Total # of neighbors = 360986
Ave neighs/atom = 90.2465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.651411169997, Press = -1.23562396176111
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17458.587     -17458.587     -17626.774     -17626.774      325.36962      325.36962      44248.181      44248.181     -2250.9151     -2250.9151    
     15000  -17451.53      -17451.53      -17623.066     -17623.066      331.8485       331.8485       44186.32       44186.32       782.82995      782.82995    
Loop time of 485.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.806 hours/ns, 2.061 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 484.3      | 484.3      | 484.3      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14912    | 0.14912    | 0.14912    |   0.0 |  0.03
Output  | 0.00023948 | 0.00023948 | 0.00023948 |   0.0 |  0.00
Modify  | 0.752      | 0.752      | 0.752      |   0.0 |  0.15
Other   |            | 0.1008     |            |       |  0.02

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

Total # of neighbors = 359642
Ave neighs/atom = 89.9105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.6698878996, Press = 1.76261139376066
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17451.53      -17451.53      -17623.066     -17623.066      331.8485       331.8485       44186.32       44186.32       782.82995      782.82995    
     16000  -17448.803     -17448.803     -17623.778     -17623.778      338.50063      338.50063      44197.134      44197.134      363.12504      363.12504    
Loop time of 483.561 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.322 hours/ns, 2.068 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.56     | 482.56     | 482.56     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14881    | 0.14881    | 0.14881    |   0.0 |  0.03
Output  | 0.00019022 | 0.00019022 | 0.00019022 |   0.0 |  0.00
Modify  | 0.75529    | 0.75529    | 0.75529    |   0.0 |  0.16
Other   |            | 0.1013     |            |       |  0.02

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

Total # of neighbors = 361188
Ave neighs/atom = 90.297
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.698290512189, Press = -2.48377375379799
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17448.803     -17448.803     -17623.778     -17623.778      338.50063      338.50063      44197.134      44197.134      363.12504      363.12504    
     17000  -17451.515     -17451.515     -17623.678     -17623.678      333.06213      333.06213      44202.687      44202.687      24.078334      24.078334    
Loop time of 486.489 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 135.136 hours/ns, 2.056 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 485.49     | 485.49     | 485.49     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14741    | 0.14741    | 0.14741    |   0.0 |  0.03
Output  | 0.00018842 | 0.00018842 | 0.00018842 |   0.0 |  0.00
Modify  | 0.75217    | 0.75217    | 0.75217    |   0.0 |  0.15
Other   |            | 0.1007     |            |       |  0.02

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

Total # of neighbors = 360682
Ave neighs/atom = 90.1705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.638279971898, Press = -1.52263524410192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17451.515     -17451.515     -17623.678     -17623.678      333.06213      333.06213      44202.687      44202.687      24.078334      24.078334    
     18000  -17459.148     -17459.148     -17626.726     -17626.726      324.19019      324.19019      44180.141      44180.141      543.88846      543.88846    
Loop time of 482.53 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.036 hours/ns, 2.072 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 481.54     | 481.54     | 481.54     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14806    | 0.14806    | 0.14806    |   0.0 |  0.03
Output  | 0.00018938 | 0.00018938 | 0.00018938 |   0.0 |  0.00
Modify  | 0.74375    | 0.74375    | 0.74375    |   0.0 |  0.15
Other   |            | 0.1008     |            |       |  0.02

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

Total # of neighbors = 360640
Ave neighs/atom = 90.16
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.527441571818, Press = -1.92282739862416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17459.148     -17459.148     -17626.726     -17626.726      324.19019      324.19019      44180.141      44180.141      543.88846      543.88846    
     19000  -17453.752     -17453.752     -17623.207     -17623.207      327.82373      327.82373      44198.762      44198.762      109.94754      109.94754    
Loop time of 484.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.451 hours/ns, 2.066 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.02     | 483.02     | 483.02     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14821    | 0.14821    | 0.14821    |   0.0 |  0.03
Output  | 0.00019051 | 0.00019051 | 0.00019051 |   0.0 |  0.00
Modify  | 0.75335    | 0.75335    | 0.75335    |   0.0 |  0.16
Other   |            | 0.1001     |            |       |  0.02

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

Total # of neighbors = 360694
Ave neighs/atom = 90.1735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.527801698335, Press = -2.02540078656943
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17453.752     -17453.752     -17623.207     -17623.207      327.82373      327.82373      44198.762      44198.762      109.94754      109.94754    
     20000  -17452.92      -17452.92      -17625.391     -17625.391      333.65629      333.65629      44194.733      44194.733      173.04234      173.04234    
Loop time of 485.009 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.725 hours/ns, 2.062 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 484        | 484        | 484        |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14902    | 0.14902    | 0.14902    |   0.0 |  0.03
Output  | 0.00018914 | 0.00018914 | 0.00018914 |   0.0 |  0.00
Modify  | 0.7587     | 0.7587     | 0.7587     |   0.0 |  0.16
Other   |            | 0.1012     |            |       |  0.02

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

Total # of neighbors = 361124
Ave neighs/atom = 90.281
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.586768246363, Press = -2.13020899236229
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17452.92      -17452.92      -17625.391     -17625.391      333.65629      333.65629      44194.733      44194.733      173.04234      173.04234    
     21000  -17453.058     -17453.058     -17626.304     -17626.304      335.15644      335.15644      44207.248      44207.248     -500.90945     -500.90945    
Loop time of 478.245 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.846 hours/ns, 2.091 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.25     | 477.25     | 477.25     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1481     | 0.1481     | 0.1481     |   0.0 |  0.03
Output  | 0.00024139 | 0.00024139 | 0.00024139 |   0.0 |  0.00
Modify  | 0.74294    | 0.74294    | 0.74294    |   0.0 |  0.16
Other   |            | 0.09997    |            |       |  0.02

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

Total # of neighbors = 360906
Ave neighs/atom = 90.2265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.598198948238, Press = -2.14624735166784
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17453.058     -17453.058     -17626.304     -17626.304      335.15644      335.15644      44207.248      44207.248     -500.90945     -500.90945    
     22000  -17459.366     -17459.366     -17625.698     -17625.698      321.78078      321.78078      44223.079      44223.079     -1236.077      -1236.077     
Loop time of 486.616 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 135.171 hours/ns, 2.055 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 485.61     | 485.61     | 485.61     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14962    | 0.14962    | 0.14962    |   0.0 |  0.03
Output  | 0.00023227 | 0.00023227 | 0.00023227 |   0.0 |  0.00
Modify  | 0.75443    | 0.75443    | 0.75443    |   0.0 |  0.16
Other   |            | 0.1003     |            |       |  0.02

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

Total # of neighbors = 360764
Ave neighs/atom = 90.191
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.582380632635, Press = -1.13952022801472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17459.366     -17459.366     -17625.698     -17625.698      321.78078      321.78078      44223.079      44223.079     -1236.077      -1236.077     
     23000  -17451.233     -17451.233     -17623.55      -17623.55       333.36017      333.36017      44186.785      44186.785      668.86116      668.86116    
Loop time of 486.937 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.260 hours/ns, 2.054 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 485.93     | 485.93     | 485.93     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14884    | 0.14884    | 0.14884    |   0.0 |  0.03
Output  | 0.00023547 | 0.00023547 | 0.00023547 |   0.0 |  0.00
Modify  | 0.75429    | 0.75429    | 0.75429    |   0.0 |  0.15
Other   |            | 0.1007     |            |       |  0.02

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

Total # of neighbors = 360142
Ave neighs/atom = 90.0355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.569530068397, Press = 1.19940946168413
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17451.233     -17451.233     -17623.55      -17623.55       333.36017      333.36017      44186.785      44186.785      668.86116      668.86116    
     24000  -17458.43      -17458.43      -17627.251     -17627.251      326.59627      326.59627      44135.419      44135.419      2300.6406      2300.6406    
Loop time of 484.492 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.581 hours/ns, 2.064 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.49     | 483.49     | 483.49     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14836    | 0.14836    | 0.14836    |   0.0 |  0.03
Output  | 0.00024027 | 0.00024027 | 0.00024027 |   0.0 |  0.00
Modify  | 0.75336    | 0.75336    | 0.75336    |   0.0 |  0.16
Other   |            | 0.1003     |            |       |  0.02

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

Total # of neighbors = 360998
Ave neighs/atom = 90.2495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.521420559633, Press = -2.56316846366178
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17458.43      -17458.43      -17627.251     -17627.251      326.59627      326.59627      44135.419      44135.419      2300.6406      2300.6406    
     25000  -17450.47      -17450.47      -17626.073     -17626.073      339.71704      339.71704      44233.681      44233.681     -1498.2101     -1498.2101    
Loop time of 482.801 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.111 hours/ns, 2.071 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 481.8      | 481.8      | 481.8      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14815    | 0.14815    | 0.14815    |   0.0 |  0.03
Output  | 0.00019024 | 0.00019024 | 0.00019024 |   0.0 |  0.00
Modify  | 0.75437    | 0.75437    | 0.75437    |   0.0 |  0.16
Other   |            | 0.1003     |            |       |  0.02

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

Total # of neighbors = 361730
Ave neighs/atom = 90.4325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.501054391977, Press = -5.07971984851494
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17450.47      -17450.47      -17626.073     -17626.073      339.71704      339.71704      44233.681      44233.681     -1498.2101     -1498.2101    
     26000  -17447.074     -17447.074     -17625.148     -17625.148      344.49649      344.49649      44243.073      44243.073     -1750.5299     -1750.5299    
Loop time of 479.39 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.164 hours/ns, 2.086 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.39     | 478.39     | 478.39     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14782    | 0.14782    | 0.14782    |   0.0 |  0.03
Output  | 0.00018654 | 0.00018654 | 0.00018654 |   0.0 |  0.00
Modify  | 0.74801    | 0.74801    | 0.74801    |   0.0 |  0.16
Other   |            | 0.09971    |            |       |  0.02

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

Total # of neighbors = 359756
Ave neighs/atom = 89.939
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.566784151833, Press = -0.65167600298506
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17447.074     -17447.074     -17625.148     -17625.148      344.49649      344.49649      44243.073      44243.073     -1750.5299     -1750.5299    
     27000  -17454.495     -17454.495     -17625.076     -17625.076      330.00025      330.00025      44190.012      44190.012      392.23079      392.23079    
Loop time of 483.817 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.394 hours/ns, 2.067 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.82     | 482.82     | 482.82     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14914    | 0.14914    | 0.14914    |   0.0 |  0.03
Output  | 0.00018867 | 0.00018867 | 0.00018867 |   0.0 |  0.00
Modify  | 0.75058    | 0.75058    | 0.75058    |   0.0 |  0.16
Other   |            | 0.1008     |            |       |  0.02

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

Total # of neighbors = 359962
Ave neighs/atom = 89.9905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.672391694991, Press = -0.25992810118464
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17454.495     -17454.495     -17625.076     -17625.076      330.00025      330.00025      44190.012      44190.012      392.23079      392.23079    
     28000  -17446.189     -17446.189     -17623.575     -17623.575      343.16567      343.16567      44198.084      44198.084      382.82982      382.82982    
Loop time of 485.592 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.887 hours/ns, 2.059 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 484.59     | 484.59     | 484.59     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14785    | 0.14785    | 0.14785    |   0.0 |  0.03
Output  | 0.00019016 | 0.00019016 | 0.00019016 |   0.0 |  0.00
Modify  | 0.74992    | 0.74992    | 0.74992    |   0.0 |  0.15
Other   |            | 0.1007     |            |       |  0.02

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

Total # of neighbors = 361004
Ave neighs/atom = 90.251
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.772140482741, Press = -1.74759829951313
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17446.189     -17446.189     -17623.575     -17623.575      343.16567      343.16567      44198.084      44198.084      382.82982      382.82982    
     29000  -17451.001     -17451.001     -17624.71      -17624.71       336.0523       336.0523       44227.534      44227.534     -1076.9089     -1076.9089    
Loop time of 484.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.547 hours/ns, 2.065 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.36     | 483.36     | 483.36     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14849    | 0.14849    | 0.14849    |   0.0 |  0.03
Output  | 0.00018665 | 0.00018665 | 0.00018665 |   0.0 |  0.00
Modify  | 0.75554    | 0.75554    | 0.75554    |   0.0 |  0.16
Other   |            | 0.1        |            |       |  0.02

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

Total # of neighbors = 360862
Ave neighs/atom = 90.2155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.80292206797, Press = -2.30141580257416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17451.001     -17451.001     -17624.71      -17624.71       336.0523       336.0523       44227.534      44227.534     -1076.9089     -1076.9089    
     30000  -17456.611     -17456.611     -17626.866     -17626.866      329.36923      329.36923      44254.085      44254.085     -2512.7906     -2512.7906    
Loop time of 480.188 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.385 hours/ns, 2.083 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 479.19     | 479.19     | 479.19     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14731    | 0.14731    | 0.14731    |   0.0 |  0.03
Output  | 0.00018821 | 0.00018821 | 0.00018821 |   0.0 |  0.00
Modify  | 0.74877    | 0.74877    | 0.74877    |   0.0 |  0.16
Other   |            | 0.09839    |            |       |  0.02

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

Total # of neighbors = 360058
Ave neighs/atom = 90.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 = 332.844447312502, Press = 0.906964354375999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17456.611     -17456.611     -17626.866     -17626.866      329.36923      329.36923      44254.085      44254.085     -2512.7906     -2512.7906    
     31000  -17450.85      -17450.85      -17625.555     -17625.555      337.97877      337.97877      44152.959      44152.959      1894.522       1894.522     
Loop time of 484.074 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.465 hours/ns, 2.066 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.07     | 483.07     | 483.07     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14915    | 0.14915    | 0.14915    |   0.0 |  0.03
Output  | 0.00024218 | 0.00024218 | 0.00024218 |   0.0 |  0.00
Modify  | 0.75775    | 0.75775    | 0.75775    |   0.0 |  0.16
Other   |            | 0.09973    |            |       |  0.02

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

Total # of neighbors = 359350
Ave neighs/atom = 89.8375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.849254163539, Press = 1.46837071020864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17450.85      -17450.85      -17625.555     -17625.555      337.97877      337.97877      44152.959      44152.959      1894.522       1894.522     
     32000  -17455.943     -17455.943     -17627.723     -17627.723      332.31927      332.31927      44165.465      44165.465      1146.2943      1146.2943    
Loop time of 487.227 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.341 hours/ns, 2.052 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 486.22     | 486.22     | 486.22     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14915    | 0.14915    | 0.14915    |   0.0 |  0.03
Output  | 0.00023489 | 0.00023489 | 0.00023489 |   0.0 |  0.00
Modify  | 0.75462    | 0.75462    | 0.75462    |   0.0 |  0.15
Other   |            | 0.09877    |            |       |  0.02

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

Total # of neighbors = 361482
Ave neighs/atom = 90.3705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.831382987521, Press = -2.04611992958593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17455.943     -17455.943     -17627.723     -17627.723      332.31927      332.31927      44165.465      44165.465      1146.2943      1146.2943    
     33000  -17452.469     -17452.469     -17624.926     -17624.926      333.63093      333.63093      44218.811      44218.811     -802.64898     -802.64898    
Loop time of 482.902 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.140 hours/ns, 2.071 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 481.91     | 481.91     | 481.91     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14787    | 0.14787    | 0.14787    |   0.0 |  0.03
Output  | 0.00026219 | 0.00026219 | 0.00026219 |   0.0 |  0.00
Modify  | 0.74545    | 0.74545    | 0.74545    |   0.0 |  0.15
Other   |            | 0.09856    |            |       |  0.02

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

Total # of neighbors = 360936
Ave neighs/atom = 90.234
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.83797852705, Press = -1.7935357800459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17452.469     -17452.469     -17624.926     -17624.926      333.63093      333.63093      44218.811      44218.811     -802.64898     -802.64898    
     34000  -17453.457     -17453.457     -17622.537     -17622.537      327.0971       327.0971       44213.598      44213.598     -382.34431     -382.34431    
Loop time of 478.589 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.941 hours/ns, 2.089 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.6      | 477.6      | 477.6      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14765    | 0.14765    | 0.14765    |   0.0 |  0.03
Output  | 0.00018944 | 0.00018944 | 0.00018944 |   0.0 |  0.00
Modify  | 0.74397    | 0.74397    | 0.74397    |   0.0 |  0.16
Other   |            | 0.0984     |            |       |  0.02

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

Total # of neighbors = 360200
Ave neighs/atom = 90.05
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.815512869839, Press = -0.838019322351384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17453.457     -17453.457     -17622.537     -17622.537      327.0971       327.0971       44213.598      44213.598     -382.34431     -382.34431    
     35000  -17449.827     -17449.827     -17622.721     -17622.721      334.47406      334.47406      44197.962      44197.962      286.33589      286.33589    
Loop time of 477.806 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.724 hours/ns, 2.093 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 476.82     | 476.82     | 476.82     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14536    | 0.14536    | 0.14536    |   0.0 |  0.03
Output  | 0.0002613  | 0.0002613  | 0.0002613  |   0.0 |  0.00
Modify  | 0.7417     | 0.7417     | 0.7417     |   0.0 |  0.16
Other   |            | 0.09897    |            |       |  0.02

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

Total # of neighbors = 360474
Ave neighs/atom = 90.1185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.770759871953, Press = -0.047401526804447
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17449.827     -17449.827     -17622.721     -17622.721      334.47406      334.47406      44197.962      44197.962      286.33589      286.33589    
     36000  -17458.374     -17458.374     -17629.394     -17629.394      330.84831      330.84831      44136.57       44136.57       2031.374       2031.374     
Loop time of 477.956 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.766 hours/ns, 2.092 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 476.98     | 476.98     | 476.98     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14532    | 0.14532    | 0.14532    |   0.0 |  0.03
Output  | 0.00019128 | 0.00019128 | 0.00019128 |   0.0 |  0.00
Modify  | 0.73749    | 0.73749    | 0.73749    |   0.0 |  0.15
Other   |            | 0.098      |            |       |  0.02

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

Total # of neighbors = 360834
Ave neighs/atom = 90.2085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.751510320739, Press = -1.11328754380195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17458.374     -17458.374     -17629.394     -17629.394      330.84831      330.84831      44136.57       44136.57       2031.374       2031.374     
     37000  -17451.938     -17451.938     -17624.85      -17624.85       334.51118      334.51118      44217.503      44217.503     -801.25654     -801.25654    
Loop time of 472.447 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.235 hours/ns, 2.117 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 471.48     | 471.48     | 471.48     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14426    | 0.14426    | 0.14426    |   0.0 |  0.03
Output  | 0.00018591 | 0.00018591 | 0.00018591 |   0.0 |  0.00
Modify  | 0.72288    | 0.72288    | 0.72288    |   0.0 |  0.15
Other   |            | 0.09742    |            |       |  0.02

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

Total # of neighbors = 361708
Ave neighs/atom = 90.427
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.717821987294, Press = -3.03946563407788
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17451.938     -17451.938     -17624.85      -17624.85       334.51118      334.51118      44217.503      44217.503     -801.25654     -801.25654    
     38000  -17454.592     -17454.592     -17626.087     -17626.087      331.76937      331.76937      44241.068      44241.068     -1990.0399     -1990.0399    
Loop time of 475.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 132.213 hours/ns, 2.101 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 474.98     | 474.98     | 474.98     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14635    | 0.14635    | 0.14635    |   0.0 |  0.03
Output  | 0.00049624 | 0.00049624 | 0.00049624 |   0.0 |  0.00
Modify  | 0.73874    | 0.73874    | 0.73874    |   0.0 |  0.16
Other   |            | 0.0989     |            |       |  0.02

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

Total # of neighbors = 360462
Ave neighs/atom = 90.1155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.696068659222, Press = -0.126858720455642
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17454.592     -17454.592     -17626.087     -17626.087      331.76937      331.76937      44241.068      44241.068     -1990.0399     -1990.0399    
     39000  -17455.026     -17455.026     -17625.022     -17625.022      328.86958      328.86958      44184.098      44184.098      478.9505       478.9505     
Loop time of 483.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.440 hours/ns, 2.066 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.97     | 482.97     | 482.97     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14859    | 0.14859    | 0.14859    |   0.0 |  0.03
Output  | 0.00024164 | 0.00024164 | 0.00024164 |   0.0 |  0.00
Modify  | 0.7618     | 0.7618     | 0.7618     |   0.0 |  0.16
Other   |            | 0.09964    |            |       |  0.02

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

Total # of neighbors = 360094
Ave neighs/atom = 90.0235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.746417715492, Press = 0.224941544587302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17455.026     -17455.026     -17625.022     -17625.022      328.86958      328.86958      44184.098      44184.098      478.9505       478.9505     
     40000  -17446.906     -17446.906     -17623.078     -17623.078      340.8181       340.8181       44197.673      44197.673      291.67165      291.67165    
Loop time of 483.393 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.276 hours/ns, 2.069 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.39     | 482.39     | 482.39     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14855    | 0.14855    | 0.14855    |   0.0 |  0.03
Output  | 0.00018876 | 0.00018876 | 0.00018876 |   0.0 |  0.00
Modify  | 0.75612    | 0.75612    | 0.75612    |   0.0 |  0.16
Other   |            | 0.09975    |            |       |  0.02

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

Total # of neighbors = 361272
Ave neighs/atom = 90.318
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.807812411254, Press = -1.17979203433814
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17446.906     -17446.906     -17623.078     -17623.078      340.8181       340.8181       44197.673      44197.673      291.67165      291.67165    
     41000  -17453.588     -17453.588     -17626.784     -17626.784      335.05853      335.05853      44194.047      44194.047     -19.365391     -19.365391    
Loop time of 484.936 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.704 hours/ns, 2.062 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.94     | 483.94     | 483.94     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14861    | 0.14861    | 0.14861    |   0.0 |  0.03
Output  | 0.00019105 | 0.00019105 | 0.00019105 |   0.0 |  0.00
Modify  | 0.75201    | 0.75201    | 0.75201    |   0.0 |  0.16
Other   |            | 0.09787    |            |       |  0.02

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

Total # of neighbors = 361282
Ave neighs/atom = 90.3205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.837919895465, Press = -1.02448362749793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17453.588     -17453.588     -17626.784     -17626.784      335.05853      335.05853      44194.047      44194.047     -19.365391     -19.365391    
     42000  -17452.603     -17452.603     -17624.632     -17624.632      332.80319      332.80319      44201.411      44201.411     -88.581864     -88.581864    
Loop time of 480.951 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.598 hours/ns, 2.079 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 479.96     | 479.96     | 479.96     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14599    | 0.14599    | 0.14599    |   0.0 |  0.03
Output  | 0.00024213 | 0.00024213 | 0.00024213 |   0.0 |  0.00
Modify  | 0.75066    | 0.75066    | 0.75066    |   0.0 |  0.16
Other   |            | 0.0988     |            |       |  0.02

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

Total # of neighbors = 360730
Ave neighs/atom = 90.1825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.884301758356, Press = -0.886603583350549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17452.603     -17452.603     -17624.632     -17624.632      332.80319      332.80319      44201.411      44201.411     -88.581864     -88.581864    
     43000  -17450.631     -17450.631     -17624.783     -17624.783      336.90773      336.90773      44209.763      44209.763     -483.66973     -483.66973    
Loop time of 478.525 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.924 hours/ns, 2.090 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.54     | 477.54     | 477.54     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14686    | 0.14686    | 0.14686    |   0.0 |  0.03
Output  | 0.00018948 | 0.00018948 | 0.00018948 |   0.0 |  0.00
Modify  | 0.7403     | 0.7403     | 0.7403     |   0.0 |  0.15
Other   |            | 0.09859    |            |       |  0.02

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

Total # of neighbors = 360768
Ave neighs/atom = 90.192
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.89409203398, Press = -0.548573443057663
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17450.631     -17450.631     -17624.783     -17624.783      336.90773      336.90773      44209.763      44209.763     -483.66973     -483.66973    
     44000  -17453.68      -17453.68      -17625.168     -17625.168      331.75603      331.75603      44170.457      44170.457      1083.1895      1083.1895    
Loop time of 488.63 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.731 hours/ns, 2.047 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 487.6      | 487.6      | 487.6      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15069    | 0.15069    | 0.15069    |   0.0 |  0.03
Output  | 0.00024636 | 0.00024636 | 0.00024636 |   0.0 |  0.00
Modify  | 0.77773    | 0.77773    | 0.77773    |   0.0 |  0.16
Other   |            | 0.101      |            |       |  0.02

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

Total # of neighbors = 360592
Ave neighs/atom = 90.148
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.865759529863, Press = -0.126309465676503
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17453.68      -17453.68      -17625.168     -17625.168      331.75603      331.75603      44170.457      44170.457      1083.1895      1083.1895    
     45000  -17450.988     -17450.988     -17621.818     -17621.818      330.48263      330.48263      44168.988      44168.988      1544.0969      1544.0969    
Loop time of 481.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 133.810 hours/ns, 2.076 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 480.73     | 480.73     | 480.73     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1469     | 0.1469     | 0.1469     |   0.0 |  0.03
Output  | 0.00018676 | 0.00018676 | 0.00018676 |   0.0 |  0.00
Modify  | 0.7419     | 0.7419     | 0.7419     |   0.0 |  0.15
Other   |            | 0.09807    |            |       |  0.02

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

Total # of neighbors = 361380
Ave neighs/atom = 90.345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.84159701536, Press = -1.94874354627478
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17450.988     -17450.988     -17621.818     -17621.818      330.48263      330.48263      44168.988      44168.988      1544.0969      1544.0969    
     46000  -17456.85      -17456.85      -17626.491     -17626.491      328.18167      328.18167      44238.711      44238.711     -1897.23       -1897.23      
Loop time of 482.47 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.019 hours/ns, 2.073 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 481.47     | 481.47     | 481.47     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14824    | 0.14824    | 0.14824    |   0.0 |  0.03
Output  | 0.0001889  | 0.0001889  | 0.0001889  |   0.0 |  0.00
Modify  | 0.75194    | 0.75194    | 0.75194    |   0.0 |  0.16
Other   |            | 0.09953    |            |       |  0.02

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

Total # of neighbors = 361836
Ave neighs/atom = 90.459
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.81376933462, Press = -1.5572469548496
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17456.85      -17456.85      -17626.491     -17626.491      328.18167      328.18167      44238.711      44238.711     -1897.23       -1897.23      
     47000  -17456.229     -17456.229     -17624.577     -17624.577      325.68197      325.68197      44205.861      44205.861     -440.43782     -440.43782    
Loop time of 479.547 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.208 hours/ns, 2.085 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.56     | 478.56     | 478.56     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1468     | 0.1468     | 0.1468     |   0.0 |  0.03
Output  | 0.00023267 | 0.00023267 | 0.00023267 |   0.0 |  0.00
Modify  | 0.74529    | 0.74529    | 0.74529    |   0.0 |  0.16
Other   |            | 0.09817    |            |       |  0.02

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

Total # of neighbors = 360088
Ave neighs/atom = 90.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 = 332.82201903232, Press = 0.45428747147244
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17456.229     -17456.229     -17624.577     -17624.577      325.68197      325.68197      44205.861      44205.861     -440.43782     -440.43782    
     48000  -17446.335     -17446.335     -17622.862     -17622.862      341.5043       341.5043       44174.759      44174.759      1299.2738      1299.2738    
Loop time of 472.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.252 hours/ns, 2.116 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 471.54     | 471.54     | 471.54     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14371    | 0.14371    | 0.14371    |   0.0 |  0.03
Output  | 0.00024668 | 0.00024668 | 0.00024668 |   0.0 |  0.00
Modify  | 0.72017    | 0.72017    | 0.72017    |   0.0 |  0.15
Other   |            | 0.09736    |            |       |  0.02

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

Total # of neighbors = 360984
Ave neighs/atom = 90.246
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.867869960378, Press = -0.606610293890475
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17446.335     -17446.335     -17622.862     -17622.862      341.5043       341.5043       44174.759      44174.759      1299.2738      1299.2738    
     49000  -17454.321     -17454.321     -17625.51      -17625.51       331.17709      331.17709      44191.433      44191.433      222.70893      222.70893    
Loop time of 477.393 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.609 hours/ns, 2.095 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 476.41     | 476.41     | 476.41     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14614    | 0.14614    | 0.14614    |   0.0 |  0.03
Output  | 0.00018976 | 0.00018976 | 0.00018976 |   0.0 |  0.00
Modify  | 0.7384     | 0.7384     | 0.7384     |   0.0 |  0.15
Other   |            | 0.09817    |            |       |  0.02

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

Total # of neighbors = 361538
Ave neighs/atom = 90.3845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.890730085982, Press = -0.980848651594708
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17454.321     -17454.321     -17625.51      -17625.51       331.17709      331.17709      44191.433      44191.433      222.70893      222.70893    
     50000  -17449.267     -17449.267     -17625.342     -17625.342      340.63022      340.63022      44210.383      44210.383     -450.1168      -450.1168     
Loop time of 481.118 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.644 hours/ns, 2.078 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 480.12     | 480.12     | 480.12     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1471     | 0.1471     | 0.1471     |   0.0 |  0.03
Output  | 0.00023078 | 0.00023078 | 0.00023078 |   0.0 |  0.00
Modify  | 0.74929    | 0.74929    | 0.74929    |   0.0 |  0.16
Other   |            | 0.09873    |            |       |  0.02

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

Total # of neighbors = 360724
Ave neighs/atom = 90.181
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.946737721845, Press = -0.979517317166852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17449.267     -17449.267     -17625.342     -17625.342      340.63022      340.63022      44210.383      44210.383     -450.1168      -450.1168     
     51000  -17456.253     -17456.253     -17627.955     -17627.955      332.16939      332.16939      44195.806      44195.806     -142.19896     -142.19896    
Loop time of 473.07 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.408 hours/ns, 2.114 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 472.09     | 472.09     | 472.09     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14624    | 0.14624    | 0.14624    |   0.0 |  0.03
Output  | 0.00018951 | 0.00018951 | 0.00018951 |   0.0 |  0.00
Modify  | 0.73045    | 0.73045    | 0.73045    |   0.0 |  0.15
Other   |            | 0.09917    |            |       |  0.02

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

Total # of neighbors = 360950
Ave neighs/atom = 90.2375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.942959802232, Press = -0.676337594685073
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17456.253     -17456.253     -17627.955     -17627.955      332.16939      332.16939      44195.806      44195.806     -142.19896     -142.19896    
     52000  -17449.792     -17449.792     -17620.918     -17620.918      331.05467      331.05467      44204.921      44204.921      172.07532      172.07532    
Loop time of 467.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.927 hours/ns, 2.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 466.78     | 466.78     | 466.78     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14482    | 0.14482    | 0.14482    |   0.0 |  0.03
Output  | 0.00026066 | 0.00026066 | 0.00026066 |   0.0 |  0.00
Modify  | 0.71907    | 0.71907    | 0.71907    |   0.0 |  0.15
Other   |            | 0.09718    |            |       |  0.02

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

Total # of neighbors = 360776
Ave neighs/atom = 90.194
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.944122960723, Press = -0.809162182611349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17449.792     -17449.792     -17620.918     -17620.918      331.05467      331.05467      44204.921      44204.921      172.07532      172.07532    
     53000  -17450.284     -17450.284     -17620.475     -17620.475      329.24661      329.24661      44215.618      44215.618     -208.45594     -208.45594    
Loop time of 473.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.625 hours/ns, 2.110 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 472.87     | 472.87     | 472.87     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14569    | 0.14569    | 0.14569    |   0.0 |  0.03
Output  | 0.00018687 | 0.00018687 | 0.00018687 |   0.0 |  0.00
Modify  | 0.73313    | 0.73313    | 0.73313    |   0.0 |  0.15
Other   |            | 0.09775    |            |       |  0.02

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

Total # of neighbors = 361194
Ave neighs/atom = 90.2985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.951738322602, Press = -0.64150112296306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17450.284     -17450.284     -17620.475     -17620.475      329.24661      329.24661      44215.618      44215.618     -208.45594     -208.45594    
     54000  -17453.304     -17453.304     -17623.432     -17623.432      329.12373      329.12373      44208.603      44208.603     -294.10996     -294.10996    
Loop time of 474.989 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.941 hours/ns, 2.105 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 474.01     | 474.01     | 474.01     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14575    | 0.14575    | 0.14575    |   0.0 |  0.03
Output  | 0.00023313 | 0.00023313 | 0.00023313 |   0.0 |  0.00
Modify  | 0.73255    | 0.73255    | 0.73255    |   0.0 |  0.15
Other   |            | 0.09805    |            |       |  0.02

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

Total # of neighbors = 360812
Ave neighs/atom = 90.203
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.005562271534, Press = -0.230911560999557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 11 11 11
  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.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17453.304     -17453.304     -17623.432     -17623.432      329.12373      329.12373      44208.603      44208.603     -294.10996     -294.10996    
     55000  -17452.794     -17452.794     -17626.277     -17626.277      335.61485      335.61485      44161.924      44161.924      1438.7018      1438.7018    
Loop time of 471.957 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.099 hours/ns, 2.119 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 470.99     | 470.99     | 470.99     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14399    | 0.14399    | 0.14399    |   0.0 |  0.03
Output  | 0.00018804 | 0.00018804 | 0.00018804 |   0.0 |  0.00
Modify  | 0.72524    | 0.72524    | 0.72524    |   0.0 |  0.15
Other   |            | 0.09718    |            |       |  0.02

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0