hamiltonian_cartesian_effective_mass.h++

Go to the documentation of this file.

/*
** hamiltonian_cartesian_effective_mass.h++
**
** Made by Johnny Q. Hacker
** Login   <solarion@nathan>
**

Copyright (C) 2009 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
nnthe 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/>.
** Started on  Fri Jul  3 06:18:08 2009 Johnny Q. Hacker
// Last update Thu Oct  1 15:42:57 2009 Johnny Q. Hacker
*/


#ifndef HAMILTONIAN_EFFECTIVE_MASS_HXX_
#define HAMILTONIAN_EFFECTIVE_MASS_HXX_

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

namespace kdotp {
  namespace libkdotp {
    namespace hamiltonian {

      struct effective_mass_properties {
  /**One over mstar*/
  double ooms;
  /**Electrostatic potential at this point*/
  double potential;
  /**Conduction band at the gamma point at this point*/
  double Ec;
  /**Electrostatic dielectric constant*/
  double epsilon;
      };
      
      enum effective_mass_parameter {
  OOMSTAR,
  MSTAR,
  POTENTIAL,
  TOTAL_POTENTIAL,
  EC,
  EPSILON
      };

      class cartesian_effective_mass {
      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.
   */
  double* matrix;
  /**For periodic multi-neighbor hardwall BCs, we need Q to get the eigenstates back in the original basis.*/
  double* Q;
  /**Number of grid sites*/
  unsigned int L;
  /**Grid spacing*/
  double dx;
  /**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 a second potential to apply (e.g. self-consistent)*/
  double *internal_potential;
  /**Material parameters*/
  struct effective_mass_properties* properties;
  /**Converts row column into matrix array address*/
  inline int get_matrix_index(unsigned int row, unsigned int col) {return col + row*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) {
    /*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.
     */
    return n_neighbors + (row - col) + (n_neighbors+1)*col;
    //return (n_neighbors - subdiagonal) + i*(n_neighbors+1);
  }

  /**This sets the matrices to their new values.*/
  void set_up_matrix();
  /**Call this if only the internal potential was set.*/
  void update_matrix_with_internal_potential(double* old_potential);
  /**Replaces the internal_potential array and then calls update_matrix_with_internal_potential()*/
  void replace_internal_potential(double* new_potential);
  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);
  /**Gets a parameter across the structure
   *\param p the effective mass parameter
   *\param function array to store the function in
   *\return Error code:
   *   1 if the parameter was invalid
   *   0 success
   */
  int get_parameter_function(int p, double* function) {
    for(unsigned int i=0; i<L; i++) {
      switch(p) {
      case OOMSTAR:
        function[i] = properties[i].ooms;
        break;
      case MSTAR:
        function[i] = 1.0/properties[i].ooms;
        break;
      case POTENTIAL:
        function[i] = properties[i].potential;
        break;
      case TOTAL_POTENTIAL:
        function[i] = properties[i].potential + internal_potential[i];
        //fprintf(stderr, "total_potential@%u: %g = extern (%g) + intern (%g)\n", i, function[i], properties[i].potential, internal_potential[i]);
        break;
      case EC:
        function[i] = properties[i].Ec;
        break;
      case EPSILON:
        function[i] = properties[i].epsilon;
        break;
      default:
        return 1;
      }
    }
    return 0;
  }
  cartesian_effective_mass(struct libmodelxx::structure::generic_structure *gs, boundary_condition bc_, bool second_neighbor_);
  ~cartesian_effective_mass();
  libmodelxx::grid::cartesian_grid<libmodelxx::structure::material*,1,1>* matgrid;
  libmodelxx::grid::cartesian_grid<double,1,1>* potgrid;
      private:
  cartesian_effective_mass() {}
  cartesian_effective_mass operator=(const cartesian_effective_mass& em) {return *this;}
      };

    }
  }
}


#endif