quantumdot/RadialPotential.hpp

#ifndef _RADIAL_POTENTIAL_HPP_
#define _RADIAL_POTENTIAL_HPP_

//
// Copyright (c) 2008 Simen Kvaal
//
// This file is part of OpenFCI.
//
// OpenFCI is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// OpenFCI 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with OpenFCI. If not, see <http://www.gnu.org/licenses/>.
//


#include <vector>
#include "linalg.hpp"

namespace quantumdot
{

  class RadialPotential
  {
    public:
      enum quad_enum { STANDARD_HERMITE_QUAD, GENERALIZED_HERMITE_QUAD };
      enum basis_enum { GENERALIZED_LAGUERRE_BASIS, GENERALIZED_HERMITE_BASIS };
     

    private:
      double lambda;         
      double alpha;          
      double beta;           
      std::vector<double> p; 
      bool p_iseven;         
      quad_enum quad_type;   
      basis_enum basis_type; 

    public:
      RadialPotential()
      {
        // Set default potential parameters: Coulomb potential, lambda = 1.
        alpha = 1;
        beta = 0;
        p.resize(1);
        p_iseven = true;
        p[0] = 1.0;
        lambda = 1;
        quad_type = STANDARD_HERMITE_QUAD;
        basis_type = GENERALIZED_LAGUERRE_BASIS;
      }

      void setIntegrationMethod(quad_enum x) { quad_type = x; }

      void setBasisType(basis_enum x) { basis_type = x; }

      void setPIsEven(bool x) { p_iseven = x; }

      void setP(std::vector<double> poly) 
      { 
        p = poly; 
      }

      void setAlpha(double x) { alpha = x; }
      void setBeta(double x) { beta = x; }
      void setLambda(double x) { lambda = x; }


      void computeMatrix(dense_matrix& C, int n_max, int m = 0);

      void computeEffectiveMatrix(dense_matrix& Ceff, int n_max, int m = 0);

      std::ostream& operator<<(std::ostream& os)
      {
        using namespace std;
        os << "Potential:" << endl;
        os << "  r^(-"<<alpha<<")*p(r)*exp(-r*"<<beta<<")"<<endl;
      }


  };



  void computeHOMatrixGenHer(dense_matrix& H0, int N, int m);

  void computeLagGenHerTrafo(dense_matrix& U, int N_lag, int N_her, int m);

  


}





#endif // _RADIAL_POTENTIAL_HPP_

---