hamiltonian_cartesian_8band.h++

Go to the documentation of this file.

/*
 *An 8-band Hamiltonian on a Cartesian grid.

    Copyright (C) 2010 Joseph Pingenot

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef ___HAMILTONIAN_8BAND_CARTESIAN_HXX___
#define ___HAMILTONIAN_8BAND_CARTESIAN_HXX___

#include <libkdotp/hamiltonians.h++>
#include <libmodelxx/generic_structure.h++>
#include <libmodelxx/cartesian_grid.h++>
#include <liblapackwrap/lapackwrap_complex_double.h>
#include <glib.h>

namespace kdotp {
  namespace libkdotp {
    namespace hamiltonian {

      /**\note CS = conduction band S-state
       *VH is valence heavy hole
       *VL is valence light hole
       *VO is valence split-off
       *_P is plus (+ 1/2 or 3/2 depending on state)
       *_M is minus (- 1/2 or 3/2 depending on state)
       */
      enum cartesian_8terms {
  CS_P = 0,
  CS_M,
  VH_P,
  VL_P,
  VL_M,
  VH_M,
  VO_P,
  VO_M
      };

      struct parameters_8band_nostrain {
  /**\var conduction band edge with applied potential*/
  double Ec;
  /**\var valence band energy with applied potential*/
  double Ev;
  /**\var Split-off band energy with applied potential*/
  double Eso;
  /**\var inverse of *reduced* effective mass*/
  double oo_mstar;
  /**\var *reduced* Luttinger parameters*/
  double gamma1;
  double gamma2;
  double gamma3;
  /**inter-band coupling parameter*/
  double P;
      };

      class cartesian_8band {
      public:
  /**Sets up the effective mass Hamiltonian for later calculations
   *\param struc the generic structure to be set up for calculating
   *\param bc the boundary conditions on the calculation
   */
  /*For Hardwall BC with only one neighbor, or for storing the tridiagonal matrix from periodic BCs or more than one neighbor*/
  double* upper_diagonal;
  double* diagonal;
  /**For periodic boundary conditions
   *\note that the matrix here is column-major, for compatibility with ACML
   *\note that this is also used for banded matrices; use banded_index to get the index.
   */
  llw_complex_double* matrix;
  /*For periodic multi-neighbor hardwall BCs, we need Q to get the eigenstates back in the original basis.*/
  llw_complex_double* Q;
  /*Number of grid sites*/
  unsigned int L;
  /*Boundary condition being used*/
  enum boundary_condition bc;
  /*If true, use second neighbor in differentiation, else use first.*/
  bool second_neighbor;
  /*Number of neighbors (if we need to up this in the future)*/
  int n_neighbors;
  /*Array containing the 8band parameters at each point.*/
  struct parameters_8band_nostrain *params;

  /**Converts row column into matrix array address
   *\note for 8-band: we have 8 bands for each row and column address, so
   *  the final row and coumn is (row*8 + band) and (col*8+band).
  */
  inline int get_matrix_index(unsigned int row, unsigned int col, unsigned short band) {return (8*col+band) + (row*8+band)*L;}
  /**Converts an upper subdiagonal and index into an index into the array
   *\note that the 0 subdiagonal is the diagonal
   */
  inline int get_array_index(unsigned int row, unsigned int col, unsigned short band) {
    /*Addresses are (kd+1+i-j), j
     *i = row index
     *j = column index
     *row index = n_neighbors + 1 + i - j - 1 (start at 0 in C)
     *row index = n_neighbors + (i - j)
     *i, i+n (n-th column of 1st superdiag) ->
     *  j = i+n => row index = n_neighbors - n
     *             col index = i + n
     *there are n_neighbors + 1 rows.
     **\note update for 8-band:
     *  For each neighbor, we have 8 bands
     *  n_neighbors -> n_neighbors*8
     *  
     */
    return n_neighbors*8 + ((row*8+band) - (col*8+band)) + ((n_neighbors+1)*8)*(col*8+band);
    //return (n_neighbors - subdiagonal) + i*(n_neighbors+1);
  }

  double* get_eigenvectors_double(double eVmin, double eVmax, double** evals, int *n_eigs, GError **err) {
    return get_eigenvectors('V', eVmin, eVmax, 0, 0, evals, n_eigs, err);
  }
  double* get_eigenvectors_int(int imin, int imax, double** evals, int *n_eigs, GError **err) {
    return get_eigenvectors('I', 0, 0, imin, imax, evals, n_eigs, err);
  }
  double* get_eigenvectors(char VoI, double eVmin, double eVmax, int imin, int imax, double**evals, int *n_eigs, GError **err);
  cartesian_8band(struct libmodelxx::structure::generic_structure *gs, boundary_condition bc_, bool second_neighbor_);
  ~cartesian_8band();
      private:
  cartesian_8band() {}
  cartesian_8band operator=(const cartesian_8band& em) {return *this;}
      };


    }
  }
}

#endif