# 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 2.8809780403971668*${_u_distance}
variable latticeconst_converted equal 2.8809780403971668*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.88097804039717
Lattice spacing in x,y,z = 2.880978 2.880978 2.880978
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.80978 28.80978 28.80978)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (28.80978 28.80978 28.80978)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Cr

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

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


mass          1 ${mass_converted}
mass          1 51.9961

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23912.2170404509 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8119.0849     -8119.0849     -8200          -8200           313.15         313.15         23912.217      23912.217      3614.3172      3614.3172    
      1000  -8034.7316     -8034.7316     -8116.9191     -8116.9191      318.07431      318.07431      24192.555      24192.555     -939.11447     -939.11447    
Loop time of 150.486 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.802 hours/ns, 6.645 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.98     | 149.98     | 149.98     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095824   | 0.095824   | 0.095824   |   0.0 |  0.06
Output  | 0.00021544 | 0.00021544 | 0.00021544 |   0.0 |  0.00
Modify  | 0.34885    | 0.34885    | 0.34885    |   0.0 |  0.23
Other   |            | 0.06036    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       224000 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8034.7316     -8034.7316     -8116.9191     -8116.9191      318.07431      318.07431      24192.555      24192.555     -939.11447     -939.11447    
      2000  -8034.3447     -8034.3447     -8118.9608     -8118.9608      327.47303      327.47303      24196.98       24196.98      -1582.3756     -1582.3756    
Loop time of 148.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.165 hours/ns, 6.748 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    | 147.69     | 147.69     | 147.69     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095925   | 0.095925   | 0.095925   |   0.0 |  0.06
Output  | 0.00020524 | 0.00020524 | 0.00020524 |   0.0 |  0.00
Modify  | 0.3508     | 0.3508     | 0.3508     |   0.0 |  0.24
Other   |            | 0.06053    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206564 ave      206564 max      206564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206564
Ave neighs/atom = 103.282
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8034.3447     -8034.3447     -8118.9608     -8118.9608      327.47303      327.47303      24196.98       24196.98      -1582.3756     -1582.3756    
      3000  -8036.7986     -8036.7986     -8119.7713     -8119.7713      321.11318      321.11318      24178.976      24178.976     -506.68684     -506.68684    
Loop time of 150.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.769 hours/ns, 6.650 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    | 149.85     | 149.85     | 149.85     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097315   | 0.097315   | 0.097315   |   0.0 |  0.06
Output  | 0.00020263 | 0.00020263 | 0.00020263 |   0.0 |  0.00
Modify  | 0.35756    | 0.35756    | 0.35756    |   0.0 |  0.24
Other   |            | 0.06144    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206666 ave      206666 max      206666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206666
Ave neighs/atom = 103.333
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8036.7986     -8036.7986     -8119.7713     -8119.7713      321.11318      321.11318      24178.976      24178.976     -506.68684     -506.68684    
      4000  -8033.2416     -8033.2416     -8119.0169     -8119.0169      331.95953      331.95953      24178.751      24178.751     -451.00732     -451.00732    
Loop time of 149.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.610 hours/ns, 6.676 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    | 149.28     | 149.28     | 149.28     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09701    | 0.09701    | 0.09701    |   0.0 |  0.06
Output  | 0.00020817 | 0.00020817 | 0.00020817 |   0.0 |  0.00
Modify  | 0.35543    | 0.35543    | 0.35543    |   0.0 |  0.24
Other   |            | 0.06174    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206678 ave      206678 max      206678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206678
Ave neighs/atom = 103.339
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8033.2416     -8033.2416     -8119.0169     -8119.0169      331.95953      331.95953      24178.751      24178.751     -451.00732     -451.00732    
      5000  -8037.8415     -8037.8415     -8116.7136     -8116.7136      305.24303      305.24303      24165.256      24165.256      1124.7621      1124.7621    
Loop time of 152.005 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.224 hours/ns, 6.579 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    | 151.48     | 151.48     | 151.48     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097765   | 0.097765   | 0.097765   |   0.0 |  0.06
Output  | 0.00016573 | 0.00016573 | 0.00016573 |   0.0 |  0.00
Modify  | 0.36626    | 0.36626    | 0.36626    |   0.0 |  0.24
Other   |            | 0.062      |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206744 ave      206744 max      206744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206744
Ave neighs/atom = 103.372
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.786248607203, Press = 62.1634895402079
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8037.8415     -8037.8415     -8116.7136     -8116.7136      305.24303      305.24303      24165.256      24165.256      1124.7621      1124.7621    
      6000  -8034.5199     -8034.5199     -8117.4716     -8117.4716      321.03154      321.03154      24203.412      24203.412     -2259.4054     -2259.4054    
Loop time of 152.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.368 hours/ns, 6.556 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    | 151.98     | 151.98     | 151.98     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098723   | 0.098723   | 0.098723   |   0.0 |  0.06
Output  | 0.00027588 | 0.00027588 | 0.00027588 |   0.0 |  0.00
Modify  | 0.38649    | 0.38649    | 0.38649    |   0.0 |  0.25
Other   |            | 0.062      |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207024 ave      207024 max      207024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207024
Ave neighs/atom = 103.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.542315191171, Press = -2.22769991829401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8034.5199     -8034.5199     -8117.4716     -8117.4716      321.03154      321.03154      24203.412      24203.412     -2259.4054     -2259.4054    
      7000  -8036.1811     -8036.1811     -8114.7359     -8114.7359      304.01512      304.01512      24184.276      24184.276     -252.31571     -252.31571    
Loop time of 151.029 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.952 hours/ns, 6.621 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.49     | 150.49     | 150.49     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097182   | 0.097182   | 0.097182   |   0.0 |  0.06
Output  | 0.00016768 | 0.00016768 | 0.00016768 |   0.0 |  0.00
Modify  | 0.38045    | 0.38045    | 0.38045    |   0.0 |  0.25
Other   |            | 0.06094    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206110 ave      206110 max      206110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206110
Ave neighs/atom = 103.055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.244196593789, Press = -11.3932463846449
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8036.1811     -8036.1811     -8114.7359     -8114.7359      304.01512      304.01512      24184.276      24184.276     -252.31571     -252.31571    
      8000  -8036.5388     -8036.5388     -8117.0829     -8117.0829      311.71402      311.71402      24156.754      24156.754      1349.8628      1349.8628    
Loop time of 152.676 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.410 hours/ns, 6.550 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    | 152.13     | 152.13     | 152.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098032   | 0.098032   | 0.098032   |   0.0 |  0.06
Output  | 0.00016381 | 0.00016381 | 0.00016381 |   0.0 |  0.00
Modify  | 0.38709    | 0.38709    | 0.38709    |   0.0 |  0.25
Other   |            | 0.06182    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206482 ave      206482 max      206482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206482
Ave neighs/atom = 103.241
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.940472111766, Press = -11.1925400631458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8036.5388     -8036.5388     -8117.0829     -8117.0829      311.71402      311.71402      24156.754      24156.754      1349.8628      1349.8628    
      9000  -8034.8399     -8034.8399     -8115.7998     -8115.7998      313.323        313.323        24183.118      24183.118     -350.26498     -350.26498    
Loop time of 150.632 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.842 hours/ns, 6.639 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    | 150.09     | 150.09     | 150.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096842   | 0.096842   | 0.096842   |   0.0 |  0.06
Output  | 0.00016465 | 0.00016465 | 0.00016465 |   0.0 |  0.00
Modify  | 0.38097    | 0.38097    | 0.38097    |   0.0 |  0.25
Other   |            | 0.0613     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207028 ave      207028 max      207028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207028
Ave neighs/atom = 103.514
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.753916878199, Press = 10.4971474289111
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8034.8399     -8034.8399     -8115.7998     -8115.7998      313.323        313.323        24183.118      24183.118     -350.26498     -350.26498    
     10000  -8038.7255     -8038.7255     -8120.7641     -8120.7641      317.49779      317.49779      24205.292      24205.292     -3030.4903     -3030.4903    
Loop time of 149.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.643 hours/ns, 6.670 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.38     | 149.38     | 149.38     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096146   | 0.096146   | 0.096146   |   0.0 |  0.06
Output  | 0.00016351 | 0.00016351 | 0.00016351 |   0.0 |  0.00
Modify  | 0.37658    | 0.37658    | 0.37658    |   0.0 |  0.25
Other   |            | 0.06076    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206486 ave      206486 max      206486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206486
Ave neighs/atom = 103.243
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.667502170963, Press = -13.0150021871233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8038.7255     -8038.7255     -8120.7641     -8120.7641      317.49779      317.49779      24205.292      24205.292     -3030.4903     -3030.4903    
     11000  -8034.7538     -8034.7538     -8114.2763     -8114.2763      307.76019      307.76019      24147.34       24147.34       2870.3097      2870.3097    
Loop time of 150.627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.841 hours/ns, 6.639 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    | 150.09     | 150.09     | 150.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096878   | 0.096878   | 0.096878   |   0.0 |  0.06
Output  | 0.00016532 | 0.00016532 | 0.00016532 |   0.0 |  0.00
Modify  | 0.37964    | 0.37964    | 0.37964    |   0.0 |  0.25
Other   |            | 0.06117    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206444 ave      206444 max      206444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206444
Ave neighs/atom = 103.222
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.588676958045, Press = -8.96034692869086
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8034.7538     -8034.7538     -8114.2763     -8114.2763      307.76019      307.76019      24147.34       24147.34       2870.3097      2870.3097    
     12000  -8034.9583     -8034.9583     -8116.5262     -8116.5262      315.67636      315.67636      24165.225      24165.225      1281.6871      1281.6871    
Loop time of 149.7 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.583 hours/ns, 6.680 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    | 149.17     | 149.17     | 149.17     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096556   | 0.096556   | 0.096556   |   0.0 |  0.06
Output  | 0.00016535 | 0.00016535 | 0.00016535 |   0.0 |  0.00
Modify  | 0.37424    | 0.37424    | 0.37424    |   0.0 |  0.25
Other   |            | 0.06104    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207212 ave      207212 max      207212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207212
Ave neighs/atom = 103.606
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.746935983083, Press = 6.20601755255497
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8034.9583     -8034.9583     -8116.5262     -8116.5262      315.67636      315.67636      24165.225      24165.225      1281.6871      1281.6871    
     13000  -8034.6673     -8034.6673     -8115.5086     -8115.5086      312.86419      312.86419      24195.607      24195.607     -1234.1156     -1234.1156    
Loop time of 152.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.287 hours/ns, 6.569 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    | 151.69     | 151.69     | 151.69     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098223   | 0.098223   | 0.098223   |   0.0 |  0.06
Output  | 0.00016876 | 0.00016876 | 0.00016876 |   0.0 |  0.00
Modify  | 0.38377    | 0.38377    | 0.38377    |   0.0 |  0.25
Other   |            | 0.06159    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207360 ave      207360 max      207360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207360
Ave neighs/atom = 103.68
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.213793760409, Press = -2.94474747119165
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8034.6673     -8034.6673     -8115.5086     -8115.5086      312.86419      312.86419      24195.607      24195.607     -1234.1156     -1234.1156    
     14000  -8035.2882     -8035.2882     -8116.1837     -8116.1837      313.07401      313.07401      24170.837      24170.837      782.92986      782.92986    
Loop time of 149.986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.663 hours/ns, 6.667 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.45     | 149.45     | 149.45     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096272   | 0.096272   | 0.096272   |   0.0 |  0.06
Output  | 0.00016616 | 0.00016616 | 0.00016616 |   0.0 |  0.00
Modify  | 0.37707    | 0.37707    | 0.37707    |   0.0 |  0.25
Other   |            | 0.06107    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206466 ave      206466 max      206466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206466
Ave neighs/atom = 103.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 = 312.297952759889, Press = -2.60662171499433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8035.2882     -8035.2882     -8116.1837     -8116.1837      313.07401      313.07401      24170.837      24170.837      782.92986      782.92986    
     15000  -8034.9812     -8034.9812     -8113.564      -8113.564       304.12357      304.12357      24173.439      24173.439      886.07638      886.07638    
Loop time of 150.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.783 hours/ns, 6.648 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    | 149.88     | 149.88     | 149.88     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097265   | 0.097265   | 0.097265   |   0.0 |  0.06
Output  | 0.00016207 | 0.00016207 | 0.00016207 |   0.0 |  0.00
Modify  | 0.37632    | 0.37632    | 0.37632    |   0.0 |  0.25
Other   |            | 0.06083    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207118 ave      207118 max      207118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207118
Ave neighs/atom = 103.559
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.368470371457, Press = -0.817933956220508
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8034.9812     -8034.9812     -8113.564      -8113.564       304.12357      304.12357      24173.439      24173.439      886.07638      886.07638    
     16000  -8034.1172     -8034.1172     -8116.0083     -8116.0083      316.92698      316.92698      24208.859      24208.859     -2336.6576     -2336.6576    
Loop time of 150.441 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.789 hours/ns, 6.647 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    | 149.9      | 149.9      | 149.9      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096887   | 0.096887   | 0.096887   |   0.0 |  0.06
Output  | 0.00016428 | 0.00016428 | 0.00016428 |   0.0 |  0.00
Modify  | 0.3788     | 0.3788     | 0.3788     |   0.0 |  0.25
Other   |            | 0.06063    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206690 ave      206690 max      206690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206690
Ave neighs/atom = 103.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 = 312.39488040261, Press = -2.43420354488976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8034.1172     -8034.1172     -8116.0083     -8116.0083      316.92698      316.92698      24208.859      24208.859     -2336.6576     -2336.6576    
     17000  -8037.0913     -8037.0913     -8115.5971     -8115.5971      303.8254       303.8254       24165.327      24165.327      1139.5622      1139.5622    
Loop time of 150.469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.797 hours/ns, 6.646 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.93     | 149.93     | 149.93     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096628   | 0.096628   | 0.096628   |   0.0 |  0.06
Output  | 0.0001642  | 0.0001642  | 0.0001642  |   0.0 |  0.00
Modify  | 0.37855    | 0.37855    | 0.37855    |   0.0 |  0.25
Other   |            | 0.06107    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206156 ave      206156 max      206156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206156
Ave neighs/atom = 103.078
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.525006246847, Press = -7.34588424439539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8037.0913     -8037.0913     -8115.5971     -8115.5971      303.8254       303.8254       24165.327      24165.327      1139.5622      1139.5622    
     18000  -8033.032      -8033.032      -8117.5715     -8117.5715      327.17657      327.17657      24145.85       24145.85       2352.7869      2352.7869    
Loop time of 152.084 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.246 hours/ns, 6.575 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    | 151.54     | 151.54     | 151.54     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097292   | 0.097292   | 0.097292   |   0.0 |  0.06
Output  | 0.00016696 | 0.00016696 | 0.00016696 |   0.0 |  0.00
Modify  | 0.38425    | 0.38425    | 0.38425    |   0.0 |  0.25
Other   |            | 0.06104    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206822 ave      206822 max      206822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206822
Ave neighs/atom = 103.411
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.541249155574, Press = 1.78939051370105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8033.032      -8033.032      -8117.5715     -8117.5715      327.17657      327.17657      24145.85       24145.85       2352.7869      2352.7869    
     19000  -8036.8255     -8036.8255     -8116.429      -8116.429       308.07365      308.07365      24203.242      24203.242     -1974.3338     -1974.3338    
Loop time of 150.044 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.679 hours/ns, 6.665 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    | 149.51     | 149.51     | 149.51     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096694   | 0.096694   | 0.096694   |   0.0 |  0.06
Output  | 0.00016272 | 0.00016272 | 0.00016272 |   0.0 |  0.00
Modify  | 0.37694    | 0.37694    | 0.37694    |   0.0 |  0.25
Other   |            | 0.06064    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207446 ave      207446 max      207446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207446
Ave neighs/atom = 103.723
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.590929507425, Press = 0.781464765433964
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8036.8255     -8036.8255     -8116.429      -8116.429       308.07365      308.07365      24203.242      24203.242     -1974.3338     -1974.3338    
     20000  -8035.4586     -8035.4586     -8117.048      -8117.048       315.7596       315.7596       24182.167      24182.167     -522.6841      -522.6841     
Loop time of 151.327 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.035 hours/ns, 6.608 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.79     | 150.79     | 150.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097749   | 0.097749   | 0.097749   |   0.0 |  0.06
Output  | 0.00016518 | 0.00016518 | 0.00016518 |   0.0 |  0.00
Modify  | 0.38089    | 0.38089    | 0.38089    |   0.0 |  0.25
Other   |            | 0.06108    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206278 ave      206278 max      206278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206278
Ave neighs/atom = 103.139
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.429144463623, Press = -3.25043557437431
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8035.4586     -8035.4586     -8117.048      -8117.048       315.7596       315.7596       24182.167      24182.167     -522.6841      -522.6841     
     21000  -8036.5155     -8036.5155     -8117.3426     -8117.3426      312.80908      312.80908      24163.332      24163.332      843.48498      843.48498    
Loop time of 150.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.718 hours/ns, 6.658 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    | 149.65     | 149.65     | 149.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097258   | 0.097258   | 0.097258   |   0.0 |  0.06
Output  | 0.00016557 | 0.00016557 | 0.00016557 |   0.0 |  0.00
Modify  | 0.37851    | 0.37851    | 0.37851    |   0.0 |  0.25
Other   |            | 0.06138    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206618 ave      206618 max      206618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206618
Ave neighs/atom = 103.309
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.491522937467, Press = -1.74334549148338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8036.5155     -8036.5155     -8117.3426     -8117.3426      312.80908      312.80908      24163.332      24163.332      843.48498      843.48498    
     22000  -8033.7083     -8033.7083     -8116.9176     -8116.9176      322.02835      322.02835      24195.224      24195.224     -1384.6048     -1384.6048    
Loop time of 150.52 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.811 hours/ns, 6.644 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.99     | 149.99     | 149.99     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096732   | 0.096732   | 0.096732   |   0.0 |  0.06
Output  | 0.00016767 | 0.00016767 | 0.00016767 |   0.0 |  0.00
Modify  | 0.37633    | 0.37633    | 0.37633    |   0.0 |  0.25
Other   |            | 0.06084    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206844 ave      206844 max      206844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206844
Ave neighs/atom = 103.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.52016696841, Press = -0.295579725218645
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8033.7083     -8033.7083     -8116.9176     -8116.9176      322.02835      322.02835      24195.224      24195.224     -1384.6048     -1384.6048    
     23000  -8036.4223     -8036.4223     -8117.5271     -8117.5271      313.88389      313.88389      24181.681      24181.681     -562.08438     -562.08438    
Loop time of 149.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.643 hours/ns, 6.671 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    | 149.38     | 149.38     | 149.38     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097061   | 0.097061   | 0.097061   |   0.0 |  0.06
Output  | 0.000166   | 0.000166   | 0.000166   |   0.0 |  0.00
Modify  | 0.37965    | 0.37965    | 0.37965    |   0.0 |  0.25
Other   |            | 0.06049    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206356 ave      206356 max      206356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206356
Ave neighs/atom = 103.178
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.441952107759, Press = -4.17953463530997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8036.4223     -8036.4223     -8117.5271     -8117.5271      313.88389      313.88389      24181.681      24181.681     -562.08438     -562.08438    
     24000  -8032.8507     -8032.8507     -8114.33       -8114.33        315.33354      315.33354      24149.156      24149.156      2743.9393      2743.9393    
Loop time of 149.064 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.407 hours/ns, 6.709 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    | 148.53     | 148.53     | 148.53     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097284   | 0.097284   | 0.097284   |   0.0 |  0.07
Output  | 0.00016661 | 0.00016661 | 0.00016661 |   0.0 |  0.00
Modify  | 0.37498    | 0.37498    | 0.37498    |   0.0 |  0.25
Other   |            | 0.06095    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206622 ave      206622 max      206622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206622
Ave neighs/atom = 103.311
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.452568243515, Press = -0.56030929239591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8032.8507     -8032.8507     -8114.33       -8114.33        315.33354      315.33354      24149.156      24149.156      2743.9393      2743.9393    
     25000  -8036.7576     -8036.7576     -8115.4104     -8115.4104      304.39452      304.39452      24190.815      24190.815     -860.24847     -860.24847    
Loop time of 150.003 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.668 hours/ns, 6.667 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.47     | 149.47     | 149.47     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096681   | 0.096681   | 0.096681   |   0.0 |  0.06
Output  | 0.00016371 | 0.00016371 | 0.00016371 |   0.0 |  0.00
Modify  | 0.37665    | 0.37665    | 0.37665    |   0.0 |  0.25
Other   |            | 0.06109    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207226 ave      207226 max      207226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207226
Ave neighs/atom = 103.613
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.471117562208, Press = 1.45988415926359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8036.7576     -8036.7576     -8115.4104     -8115.4104      304.39452      304.39452      24190.815      24190.815     -860.24847     -860.24847    
     26000  -8033.9972     -8033.9972     -8114.5972     -8114.5972      311.93039      311.93039      24200.15       24200.15      -1569.5391     -1569.5391    
Loop time of 150.655 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.849 hours/ns, 6.638 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    | 150.12     | 150.12     | 150.12     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096727   | 0.096727   | 0.096727   |   0.0 |  0.06
Output  | 0.0001659  | 0.0001659  | 0.0001659  |   0.0 |  0.00
Modify  | 0.37917    | 0.37917    | 0.37917    |   0.0 |  0.25
Other   |            | 0.06146    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206296 ave      206296 max      206296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206296
Ave neighs/atom = 103.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 = 312.459608239065, Press = -3.71684779084348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8033.9972     -8033.9972     -8114.5972     -8114.5972      311.93039      311.93039      24200.15       24200.15      -1569.5391     -1569.5391    
     27000  -8037.2105     -8037.2105     -8116.9565     -8116.9565      308.6252       308.6252       24145.424      24145.424      2339.971       2339.971     
Loop time of 149.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.437 hours/ns, 6.704 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    | 148.64     | 148.64     | 148.64     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096323   | 0.096323   | 0.096323   |   0.0 |  0.06
Output  | 0.00016644 | 0.00016644 | 0.00016644 |   0.0 |  0.00
Modify  | 0.37381    | 0.37381    | 0.37381    |   0.0 |  0.25
Other   |            | 0.06112    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206204 ave      206204 max      206204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206204
Ave neighs/atom = 103.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.365076514807, Press = -1.55202116724096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8037.2105     -8037.2105     -8116.9565     -8116.9565      308.6252       308.6252       24145.424      24145.424      2339.971       2339.971     
     28000  -8036.2423     -8036.2423     -8118.6231     -8118.6231      318.82217      318.82217      24182.995      24182.995     -743.4014      -743.4014     
Loop time of 149.648 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.569 hours/ns, 6.682 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    | 149.12     | 149.12     | 149.12     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096823   | 0.096823   | 0.096823   |   0.0 |  0.06
Output  | 0.00016485 | 0.00016485 | 0.00016485 |   0.0 |  0.00
Modify  | 0.37353    | 0.37353    | 0.37353    |   0.0 |  0.25
Other   |            | 0.06061    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207266 ave      207266 max      207266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207266
Ave neighs/atom = 103.633
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.361717480526, Press = 0.949727132342434
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8036.2423     -8036.2423     -8118.6231     -8118.6231      318.82217      318.82217      24182.995      24182.995     -743.4014      -743.4014     
     29000  -8032.6877     -8032.6877     -8116.47       -8116.47        324.24631      324.24631      24200.289      24200.289     -1586.2497     -1586.2497    
Loop time of 149.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.580 hours/ns, 6.681 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    | 149.16     | 149.16     | 149.16     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096586   | 0.096586   | 0.096586   |   0.0 |  0.06
Output  | 0.00016559 | 0.00016559 | 0.00016559 |   0.0 |  0.00
Modify  | 0.37585    | 0.37585    | 0.37585    |   0.0 |  0.25
Other   |            | 0.06089    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206948 ave      206948 max      206948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206948
Ave neighs/atom = 103.474
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.355337450119, Press = -2.40647268760254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8032.6877     -8032.6877     -8116.47       -8116.47        324.24631      324.24631      24200.289      24200.289     -1586.2497     -1586.2497    
     30000  -8035.4617     -8035.4617     -8116.1841     -8116.1841      312.40404      312.40404      24140.865      24140.865      2936.7731      2936.7731    
Loop time of 149.562 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.545 hours/ns, 6.686 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    | 149.03     | 149.03     | 149.03     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097089   | 0.097089   | 0.097089   |   0.0 |  0.06
Output  | 0.00020511 | 0.00020511 | 0.00020511 |   0.0 |  0.00
Modify  | 0.37855    | 0.37855    | 0.37855    |   0.0 |  0.25
Other   |            | 0.06044    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206214 ave      206214 max      206214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206214
Ave neighs/atom = 103.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.434923362081, Press = -1.86467724825808
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8035.4617     -8035.4617     -8116.1841     -8116.1841      312.40404      312.40404      24140.865      24140.865      2936.7731      2936.7731    
     31000  -8034.9569     -8034.9569     -8116.1228     -8116.1228      314.12064      314.12064      24173.701      24173.701      307.12813      307.12813    
Loop time of 151.022 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.951 hours/ns, 6.622 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.49     | 150.49     | 150.49     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096375   | 0.096375   | 0.096375   |   0.0 |  0.06
Output  | 0.00016471 | 0.00016471 | 0.00016471 |   0.0 |  0.00
Modify  | 0.37836    | 0.37836    | 0.37836    |   0.0 |  0.25
Other   |            | 0.06119    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207446 ave      207446 max      207446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207446
Ave neighs/atom = 103.723
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.593578260859, Press = 3.34783819994711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8034.9569     -8034.9569     -8116.1228     -8116.1228      314.12064      314.12064      24173.701      24173.701      307.12813      307.12813    
     32000  -8033.131      -8033.131      -8115.33       -8115.33        318.11874      318.11874      24205.473      24205.473     -1929.3449     -1929.3449    
Loop time of 151.236 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.010 hours/ns, 6.612 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    | 150.7      | 150.7      | 150.7      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096531   | 0.096531   | 0.096531   |   0.0 |  0.06
Output  | 0.00020354 | 0.00020354 | 0.00020354 |   0.0 |  0.00
Modify  | 0.3772     | 0.3772     | 0.3772     |   0.0 |  0.25
Other   |            | 0.06196    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206766 ave      206766 max      206766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206766
Ave neighs/atom = 103.383
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.638742626187, Press = -1.44146467765796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8033.131      -8033.131      -8115.33       -8115.33        318.11874      318.11874      24205.473      24205.473     -1929.3449     -1929.3449    
     33000  -8038.1634     -8038.1634     -8118.632      -8118.632       311.42177      311.42177      24172.988      24172.988     -119.55897     -119.55897    
Loop time of 151.839 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.178 hours/ns, 6.586 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.29     | 151.29     | 151.29     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097815   | 0.097815   | 0.097815   |   0.0 |  0.06
Output  | 0.00016493 | 0.00016493 | 0.00016493 |   0.0 |  0.00
Modify  | 0.38525    | 0.38525    | 0.38525    |   0.0 |  0.25
Other   |            | 0.06166    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206014 ave      206014 max      206014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206014
Ave neighs/atom = 103.007
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.721657686938, Press = -1.63323482137752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8038.1634     -8038.1634     -8118.632      -8118.632       311.42177      311.42177      24172.988      24172.988     -119.55897     -119.55897    
     34000  -8035.8801     -8035.8801     -8118.0802     -8118.0802      318.12287      318.12287      24165.505      24165.505      840.9759       840.9759     
Loop time of 149.248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.458 hours/ns, 6.700 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    | 148.72     | 148.72     | 148.72     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096147   | 0.096147   | 0.096147   |   0.0 |  0.06
Output  | 0.00019728 | 0.00019728 | 0.00019728 |   0.0 |  0.00
Modify  | 0.37253    | 0.37253    | 0.37253    |   0.0 |  0.25
Other   |            | 0.06075    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206816 ave      206816 max      206816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206816
Ave neighs/atom = 103.408
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.70873449207, Press = -0.211285022618873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8035.8801     -8035.8801     -8118.0802     -8118.0802      318.12287      318.12287      24165.505      24165.505      840.9759       840.9759     
     35000  -8035.7748     -8035.7748     -8118.6227     -8118.6227      320.62989      320.62989      24191.279      24191.279     -1451.7154     -1451.7154    
Loop time of 150.16 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.711 hours/ns, 6.660 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    | 149.62     | 149.62     | 149.62     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09718    | 0.09718    | 0.09718    |   0.0 |  0.06
Output  | 0.00016379 | 0.00016379 | 0.00016379 |   0.0 |  0.00
Modify  | 0.3785     | 0.3785     | 0.3785     |   0.0 |  0.25
Other   |            | 0.06138    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207336 ave      207336 max      207336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207336
Ave neighs/atom = 103.668
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.629988240905, Press = 0.382966005224623
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8035.7748     -8035.7748     -8118.6227     -8118.6227      320.62989      320.62989      24191.279      24191.279     -1451.7154     -1451.7154    
     36000  -8037.5442     -8037.5442     -8117.7397     -8117.7397      310.36481      310.36481      24182.121      24182.121     -636.28093     -636.28093    
Loop time of 151.098 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.972 hours/ns, 6.618 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.56     | 150.56     | 150.56     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09742    | 0.09742    | 0.09742    |   0.0 |  0.06
Output  | 0.0001643  | 0.0001643  | 0.0001643  |   0.0 |  0.00
Modify  | 0.38054    | 0.38054    | 0.38054    |   0.0 |  0.25
Other   |            | 0.06117    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206658 ave      206658 max      206658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206658
Ave neighs/atom = 103.329
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.675150950923, Press = -2.95441683255392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8037.5442     -8037.5442     -8117.7397     -8117.7397      310.36481      310.36481      24182.121      24182.121     -636.28093     -636.28093    
     37000  -8035.1728     -8035.1728     -8117.9343     -8117.9343      320.29541      320.29541      24135.367      24135.367      2958.0243      2958.0243    
Loop time of 149.476 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.521 hours/ns, 6.690 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    | 148.94     | 148.94     | 148.94     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097063   | 0.097063   | 0.097063   |   0.0 |  0.06
Output  | 0.00019966 | 0.00019966 | 0.00019966 |   0.0 |  0.00
Modify  | 0.37902    | 0.37902    | 0.37902    |   0.0 |  0.25
Other   |            | 0.06052    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206812 ave      206812 max      206812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206812
Ave neighs/atom = 103.406
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.796168082813, Press = 0.0064996255204511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8035.1728     -8035.1728     -8117.9343     -8117.9343      320.29541      320.29541      24135.367      24135.367      2958.0243      2958.0243    
     38000  -8032.7368     -8032.7368     -8115.699      -8115.699       321.07228      321.07228      24208.417      24208.417     -2173.3199     -2173.3199    
Loop time of 151.102 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.973 hours/ns, 6.618 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.56     | 150.56     | 150.56     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098215   | 0.098215   | 0.098215   |   0.0 |  0.06
Output  | 0.0002128  | 0.0002128  | 0.0002128  |   0.0 |  0.00
Modify  | 0.3822     | 0.3822     | 0.3822     |   0.0 |  0.25
Other   |            | 0.06129    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207690 ave      207690 max      207690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207690
Ave neighs/atom = 103.845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.843504074329, Press = 0.846220300665265
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8032.7368     -8032.7368     -8115.699      -8115.699       321.07228      321.07228      24208.417      24208.417     -2173.3199     -2173.3199    
     39000  -8037.3477     -8037.3477     -8116.6204     -8116.6204      306.79367      306.79367      24187.926      24187.926     -1012.8582     -1012.8582    
Loop time of 150.393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.776 hours/ns, 6.649 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.85     | 149.85     | 149.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097149   | 0.097149   | 0.097149   |   0.0 |  0.06
Output  | 0.00016684 | 0.00016684 | 0.00016684 |   0.0 |  0.00
Modify  | 0.38109    | 0.38109    | 0.38109    |   0.0 |  0.25
Other   |            | 0.06105    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205974 ave      205974 max      205974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205974
Ave neighs/atom = 102.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.853832226915, Press = -2.8186729057809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8037.3477     -8037.3477     -8116.6204     -8116.6204      306.79367      306.79367      24187.926      24187.926     -1012.8582     -1012.8582    
     40000  -8034.1324     -8034.1324     -8115.9168     -8115.9168      316.51417      316.51417      24152.036      24152.036      2064.4105      2064.4105    
Loop time of 150.286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.746 hours/ns, 6.654 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    | 149.74     | 149.74     | 149.74     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097185   | 0.097185   | 0.097185   |   0.0 |  0.06
Output  | 0.00020306 | 0.00020306 | 0.00020306 |   0.0 |  0.00
Modify  | 0.38989    | 0.38989    | 0.38989    |   0.0 |  0.26
Other   |            | 0.0613     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206468 ave      206468 max      206468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206468
Ave neighs/atom = 103.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 = 312.774896440348, Press = -0.34386560018412
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8034.1324     -8034.1324     -8115.9168     -8115.9168      316.51417      316.51417      24152.036      24152.036      2064.4105      2064.4105    
     41000  -8037.1003     -8037.1003     -8115.8876     -8115.8876      304.91503      304.91503      24181.019      24181.019     -266.88282     -266.88282    
Loop time of 150.251 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.736 hours/ns, 6.656 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.71     | 149.71     | 149.71     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096578   | 0.096578   | 0.096578   |   0.0 |  0.06
Output  | 0.00027847 | 0.00027847 | 0.00027847 |   0.0 |  0.00
Modify  | 0.37809    | 0.37809    | 0.37809    |   0.0 |  0.25
Other   |            | 0.06075    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207030 ave      207030 max      207030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207030
Ave neighs/atom = 103.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.78101319246, Press = 0.281018968574841
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8037.1003     -8037.1003     -8115.8876     -8115.8876      304.91503      304.91503      24181.019      24181.019     -266.88282     -266.88282    
     42000  -8033.7763     -8033.7763     -8116.5738     -8116.5738      320.4351       320.4351       24190.742      24190.742     -935.77613     -935.77613    
Loop time of 147.66 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.017 hours/ns, 6.772 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    | 147.13     | 147.13     | 147.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095258   | 0.095258   | 0.095258   |   0.0 |  0.06
Output  | 0.00024818 | 0.00024818 | 0.00024818 |   0.0 |  0.00
Modify  | 0.3699     | 0.3699     | 0.3699     |   0.0 |  0.25
Other   |            | 0.06053    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206564 ave      206564 max      206564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206564
Ave neighs/atom = 103.282
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.800738698165, Press = -1.21948545766577
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8033.7763     -8033.7763     -8116.5738     -8116.5738      320.4351       320.4351       24190.742      24190.742     -935.77613     -935.77613    
     43000  -8034.6839     -8034.6839     -8118.0467     -8118.0467      322.623        322.623        24171.226      24171.226      466.33463      466.33463    
Loop time of 148.897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.360 hours/ns, 6.716 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    | 148.37     | 148.37     | 148.37     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096425   | 0.096425   | 0.096425   |   0.0 |  0.06
Output  | 0.00016605 | 0.00016605 | 0.00016605 |   0.0 |  0.00
Modify  | 0.3741     | 0.3741     | 0.3741     |   0.0 |  0.25
Other   |            | 0.06056    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206458 ave      206458 max      206458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206458
Ave neighs/atom = 103.229
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.878570325843, Press = -0.984454436913494
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8034.6839     -8034.6839     -8118.0467     -8118.0467      322.623        322.623        24171.226      24171.226      466.33463      466.33463    
     44000  -8034.1936     -8034.1936     -8116.7124     -8116.7124      319.35645      319.35645      24185.949      24185.949     -535.76209     -535.76209    
Loop time of 149.389 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.497 hours/ns, 6.694 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    | 148.85     | 148.85     | 148.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097339   | 0.097339   | 0.097339   |   0.0 |  0.07
Output  | 0.0001653  | 0.0001653  | 0.0001653  |   0.0 |  0.00
Modify  | 0.37788    | 0.37788    | 0.37788    |   0.0 |  0.25
Other   |            | 0.06066    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206944 ave      206944 max      206944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206944
Ave neighs/atom = 103.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.914653768639, Press = -0.604353302547101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8034.1936     -8034.1936     -8116.7124     -8116.7124      319.35645      319.35645      24185.949      24185.949     -535.76209     -535.76209    
     45000  -8037.0225     -8037.0225     -8117.6603     -8117.6603      312.07652      312.07652      24183.018      24183.018     -546.74037     -546.74037    
Loop time of 148.46 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.239 hours/ns, 6.736 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    | 147.93     | 147.93     | 147.93     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096668   | 0.096668   | 0.096668   |   0.0 |  0.07
Output  | 0.00016547 | 0.00016547 | 0.00016547 |   0.0 |  0.00
Modify  | 0.37489    | 0.37489    | 0.37489    |   0.0 |  0.25
Other   |            | 0.06035    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206418 ave      206418 max      206418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206418
Ave neighs/atom = 103.209
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.993302049298, Press = -1.04418694610777
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8037.0225     -8037.0225     -8117.6603     -8117.6603      312.07652      312.07652      24183.018      24183.018     -546.74037     -546.74037    
     46000  -8033.9259     -8033.9259     -8115.5073     -8115.5073      315.72826      315.72826      24182.71       24182.71      -122.58522     -122.58522    
Loop time of 149.626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.563 hours/ns, 6.683 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    | 149.09     | 149.09     | 149.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096935   | 0.096935   | 0.096935   |   0.0 |  0.06
Output  | 0.00016384 | 0.00016384 | 0.00016384 |   0.0 |  0.00
Modify  | 0.37788    | 0.37788    | 0.37788    |   0.0 |  0.25
Other   |            | 0.06077    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206716 ave      206716 max      206716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206716
Ave neighs/atom = 103.358
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.010459047223, Press = -1.23558323631377
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8033.9259     -8033.9259     -8115.5073     -8115.5073      315.72826      315.72826      24182.71       24182.71      -122.58522     -122.58522    
     47000  -8035.5169     -8035.5169     -8113.5501     -8113.5501      301.99671      301.99671      24160.399      24160.399      1952.4611      1952.4611    
Loop time of 151.937 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.205 hours/ns, 6.582 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    | 151.39     | 151.39     | 151.39     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097921   | 0.097921   | 0.097921   |   0.0 |  0.06
Output  | 0.00016452 | 0.00016452 | 0.00016452 |   0.0 |  0.00
Modify  | 0.38497    | 0.38497    | 0.38497    |   0.0 |  0.25
Other   |            | 0.06101    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206606 ave      206606 max      206606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206606
Ave neighs/atom = 103.303
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.948912786591, Press = 0.450675453303849
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8035.5169     -8035.5169     -8113.5501     -8113.5501      301.99671      301.99671      24160.399      24160.399      1952.4611      1952.4611    
     48000  -8034.7725     -8034.7725     -8117.3166     -8117.3166      319.45427      319.45427      24221.164      24221.164     -3601.4791     -3601.4791    
Loop time of 150.147 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.708 hours/ns, 6.660 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    | 149.61     | 149.61     | 149.61     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096782   | 0.096782   | 0.096782   |   0.0 |  0.06
Output  | 0.00020344 | 0.00020344 | 0.00020344 |   0.0 |  0.00
Modify  | 0.37978    | 0.37978    | 0.37978    |   0.0 |  0.25
Other   |            | 0.06112    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206878 ave      206878 max      206878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206878
Ave neighs/atom = 103.439
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.924640968862, Press = -0.949956180988761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8034.7725     -8034.7725     -8117.3166     -8117.3166      319.45427      319.45427      24221.164      24221.164     -3601.4791     -3601.4791    
     49000  -8033.4229     -8033.4229     -8115.1948     -8115.1948      316.46565      316.46565      24168.33       24168.33       1237.4407      1237.4407    
Loop time of 150.718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.866 hours/ns, 6.635 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.18     | 150.18     | 150.18     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097699   | 0.097699   | 0.097699   |   0.0 |  0.06
Output  | 0.00016259 | 0.00016259 | 0.00016259 |   0.0 |  0.00
Modify  | 0.38104    | 0.38104    | 0.38104    |   0.0 |  0.25
Other   |            | 0.06088    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205808 ave      205808 max      205808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205808
Ave neighs/atom = 102.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.896483338084, Press = -2.9496329792949
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8033.4229     -8033.4229     -8115.1948     -8115.1948      316.46565      316.46565      24168.33       24168.33       1237.4407      1237.4407    
     50000  -8037.0759     -8037.0759     -8116.7403     -8116.7403      308.30939      308.30939      24150.501      24150.501      1907.4565      1907.4565    
Loop time of 150.08 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.689 hours/ns, 6.663 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    | 149.55     | 149.55     | 149.55     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096468   | 0.096468   | 0.096468   |   0.0 |  0.06
Output  | 0.00016649 | 0.00016649 | 0.00016649 |   0.0 |  0.00
Modify  | 0.3773     | 0.3773     | 0.3773     |   0.0 |  0.25
Other   |            | 0.061      |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206864 ave      206864 max      206864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206864
Ave neighs/atom = 103.432
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.930221551222, Press = -0.0138670803023382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8037.0759     -8037.0759     -8116.7403     -8116.7403      308.30939      308.30939      24150.501      24150.501      1907.4565      1907.4565    
     51000  -8032.8004     -8032.8004     -8112.0516     -8112.0516      306.71043      306.71043      24194.112      24194.112     -437.93922     -437.93922    
Loop time of 150.097 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.694 hours/ns, 6.662 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    | 149.56     | 149.56     | 149.56     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096519   | 0.096519   | 0.096519   |   0.0 |  0.06
Output  | 0.00020084 | 0.00020084 | 0.00020084 |   0.0 |  0.00
Modify  | 0.37594    | 0.37594    | 0.37594    |   0.0 |  0.25
Other   |            | 0.06125    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207188 ave      207188 max      207188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207188
Ave neighs/atom = 103.594
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.994942018834, Press = -0.539407049462558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8032.8004     -8032.8004     -8112.0516     -8112.0516      306.71043      306.71043      24194.112      24194.112     -437.93922     -437.93922    
     52000  -8036.6114     -8036.6114     -8116.1129     -8116.1129      307.67911      307.67911      24171.725      24171.725      417.55031      417.55031    
Loop time of 150.49 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.803 hours/ns, 6.645 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.95     | 149.95     | 149.95     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097647   | 0.097647   | 0.097647   |   0.0 |  0.06
Output  | 0.00016693 | 0.00016693 | 0.00016693 |   0.0 |  0.00
Modify  | 0.37761    | 0.37761    | 0.37761    |   0.0 |  0.25
Other   |            | 0.06073    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205996 ave      205996 max      205996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205996
Ave neighs/atom = 102.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.006478339015, Press = -1.41896245090408
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 9 9 9
  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.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8036.6114     -8036.6114     -8116.1129     -8116.1129      307.67911      307.67911      24171.725      24171.725      417.55031      417.55031    
     53000  -8035.3939     -8035.3939     -8116.9314     -8116.9314      315.55883      315.55883      24170.276      24170.276      578.55478      578.55478    
Loop time of 151.607 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.113 hours/ns, 6.596 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.07     | 151.07     | 151.07     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096994   | 0.096994   | 0.096994   |   0.0 |  0.06
Output  | 0.00016453 | 0.00016453 | 0.00016453 |   0.0 |  0.00
Modify  | 0.38191    | 0.38191    | 0.38191    |   0.0 |  0.25
Other   |            | 0.0616     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206808 ave      206808 max      206808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206808
Ave neighs/atom = 103.404
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
24178.0556688829

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0