ope_elementary.h

/*
 *  Definition of Lorene classes Ope_elementary
 *
 */

/*
 *   Copyright (c) 2003 Philippe Grandclement
 *
 *   This file is part of LORENE.
 *
 *   LORENE is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   LORENE 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 LORENE; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef __OPE_ELEMENTARY_H_ 
#define __OPE_ELEMENTARY_H_ 

/*
 * $Id: ope_elementary.h,v 1.11 2007/05/06 10:48:08 p_grandclement Exp $
 * $Log: ope_elementary.h,v $
 * Revision 1.11  2007/05/06 10:48:08  p_grandclement
 * Modification of a few operators for the vorton project
 *
 * Revision 1.10  2007/04/24 09:04:11  p_grandclement
 * Addition of an operator for the vortons
 *
 * Revision 1.9  2004/12/23 16:30:14  j_novak
 * New files and class for the solution of the rr component of the tensor Poisson
 * equation.
 *
 * Revision 1.8  2004/08/24 09:14:40  p_grandclement
 * Addition of some new operators, like Poisson in 2d... It now requieres the
 * GSL library to work.
 *
 * Also, the way a variable change is stored by a Param_elliptic is changed and
 * no longer uses Change_var but rather 2 Scalars. The codes using that feature
 * will requiere some modification. (It should concern only the ones about monopoles)
 *
 * Revision 1.7  2004/06/22 08:49:57  p_grandclement
 * Addition of everything needed for using the logarithmic mapping
 *
 * Revision 1.6  2004/06/14 15:07:10  j_novak
 * New methods for the construction of the elliptic operator appearing in
 * the vector Poisson equation (acting on eta).
 *
 * Revision 1.5  2004/05/10 15:28:21  j_novak
 * First version of functions for the solution of the r-component of the
 * vector Poisson equation.
 *
 * Revision 1.4  2004/03/23 14:54:45  j_novak
 * More documentation
 *
 * Revision 1.3  2004/03/09 09:15:11  p_grandclement
 * Correction pour le raccord...
 *
 * Revision 1.2  2004/03/05 09:18:48  p_grandclement
 * Addition of operator sec_order_r2
 *
 * Revision 1.1  2003/12/11 14:57:00  p_grandclement
 * I had forgotten the .h (sorry folks...)
 *
 * Revision 1.2  2001/12/11 06:44:41  e_gourgoulhon
 *
 * $Header: /cvsroot/Lorene/C++/Include/ope_elementary.h,v 1.11 2007/05/06 10:48:08 p_grandclement Exp $
 *
 */

#include "matrice.h"

class Ope_elementary {

 protected:

  int nr ; 
  int base_r ; 
  double alpha ; 
  double beta ; 
  
  mutable Matrice* ope_mat ;
  mutable Matrice* ope_cl ;
  mutable Matrice* non_dege ;

  mutable double s_one_plus ;
  mutable double s_one_minus ;
  mutable double ds_one_plus ;
  mutable double ds_one_minus ;
  
  mutable double s_two_plus ;
  mutable double s_two_minus ;
  mutable double ds_two_plus ;
  mutable double ds_two_minus ;
 
  mutable double sp_minus ;
  mutable double sp_plus ;
  mutable double dsp_minus ;
  mutable double dsp_plus ;

  // Constructors destructor
 protected:
  explicit Ope_elementary (int nbr , int baser , double alf, double eta) ;
  Ope_elementary (const Ope_elementary&) ; 

 public:
  virtual ~Ope_elementary() ; 

 public: 
  double val_sh_one_minus() const {return s_one_minus ;} ; 
  double val_sh_one_plus() const {return s_one_plus ;} ; 
  double der_sh_one_minus() const {return ds_one_minus ;} ; 
  double der_sh_one_plus() const {return ds_one_plus ;} ;
 
  double val_sh_two_minus() const {return s_two_minus ;} ;
  double val_sh_two_plus() const {return s_two_plus ;} ;
  double der_sh_two_minus() const {return ds_two_minus ;} ;
  double der_sh_two_plus() const {return ds_two_plus ;} ;

  double val_sp_minus() const {return sp_minus ;} ;
  double val_sp_plus() const {return sp_plus ;} ; 
  double der_sp_minus() const {return dsp_minus ;} ;
  double der_sp_plus() const {return dsp_plus ;} ;

  double get_alpha() const {return alpha ;} ; 

  double get_beta() const {return beta ;} ; 

  int get_base_r() const {return base_r ;} ;

   Matrice get_ope_mat() {
    if (ope_mat ==0x0)
        do_ope_mat() ;
    return *ope_mat ;
}

   Matrice get_ope_cl() {
    if (ope_cl ==0x0)
        do_ope_cl() ;
    return *ope_cl ;
} 
 
   Matrice get_non_dege() {
    if (non_dege ==0x0)
        do_non_dege() ;
    return *non_dege ;
}
 private:
  virtual void do_ope_mat() const = 0 ;
  virtual void do_ope_cl() const = 0 ;
  virtual void do_non_dege() const = 0 ;  
 
 public:
  virtual Tbl get_solp(const Tbl& so) const = 0 ;
  virtual Tbl get_solh() const = 0 ;
  virtual void inc_l_quant() = 0 ;
} ;

class Ope_poisson : public Ope_elementary {

 protected:
  int l_quant ; 
  int dzpuis ; 
  
 public:
  Ope_poisson (int nbr, int baser, double alf, double bet, int lq, int dz) ;
  Ope_poisson (const Ope_poisson&) ; 
  virtual ~Ope_poisson() ; 

  int get_dzpuis() {return dzpuis ;} ;

  int get_lquant() {return l_quant;} ;

 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
  virtual void dec_l_quant() ;
} ;

class Ope_helmholtz_minus : public Ope_elementary {

 protected: 
  int lq ; 
  double masse ; 
 
 public:
  Ope_helmholtz_minus (int nbr, int baser, int lq, double alf, double bet, 
               double mas) ;
  Ope_helmholtz_minus (const Ope_helmholtz_minus&) ; 
  virtual ~Ope_helmholtz_minus() ; 
  
 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
} ;

class Ope_helmholtz_plus : public Ope_elementary {

 protected:
  int lq ; 
  double masse ; 

 public:
  Ope_helmholtz_plus (int nbr, int baser, int lq, double alf, double bet, 
              double mas) ;
  Ope_helmholtz_plus (const Ope_helmholtz_plus&) ; 
  virtual ~Ope_helmholtz_plus() ; 
  
 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
} ;

class Ope_sec_order_r2 : public Ope_elementary {

 protected:

  double a_param ; 
  double b_param ; 
  double c_param ; 

 public:
  Ope_sec_order_r2 (int nbr, int baser, double alf, double bet, 
              double a, double b, double c) ;

  Ope_sec_order_r2 (const Ope_sec_order_r2&) ; 
  virtual ~Ope_sec_order_r2() ; 
  
 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
} ;

class Ope_sec_order : public Ope_elementary {

 protected:

  double a_param ; 
  double b_param ; 
  double c_param ; 

 public:
  Ope_sec_order (int nbr, int baser, double alf, double bet, 
              double a, double b, double c) ;

  Ope_sec_order (const Ope_sec_order&) ; 
  virtual ~Ope_sec_order() ; 
  
 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:

  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
} ;

class Ope_pois_vect_r : public Ope_poisson {

 public:
  Ope_pois_vect_r (int nbr, int baser, double alf, double bet, int lq, int dz) ;
  Ope_pois_vect_r (const Ope_pois_vect_r&) ; 
  virtual ~Ope_pois_vect_r() ; 

 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solh() const ;
} ;

class Ope_pois_tens_rr : public Ope_poisson {

 public:
  Ope_pois_tens_rr (int nbr, int baser, double alf, double bet, int lq, int dz) ;
  Ope_pois_tens_rr (const Ope_pois_tens_rr&) ; 
  virtual ~Ope_pois_tens_rr() ; 

 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solh() const ;
} ;

class Ope_poisson_2d : public Ope_elementary {

 protected:
  int l_quant ; 
  int dzpuis ; 
  
 public:
  Ope_poisson_2d (int nbr, int baser, double alf, double bet, int lq, int dz) ;
  Ope_poisson_2d (const Ope_poisson_2d&) ; 
  virtual ~Ope_poisson_2d() ; 

  int get_dzpuis() {return dzpuis ;} ;

  int get_lquant() {return l_quant;} ;

 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
  virtual void dec_l_quant() ;

} ;

class Ope_helmholtz_minus_2d : public Ope_elementary {

 protected:
  int l_quant ; 
  double masse ; 
  int dzpuis ; 
  
 public:
  Ope_helmholtz_minus_2d (int nbr, int baser, double alf, double bet, int lq, double masse, int dz) ;
  Ope_helmholtz_minus_2d (const Ope_helmholtz_minus_2d&) ; 
  virtual ~Ope_helmholtz_minus_2d() ; 

  int get_dzpuis() {return dzpuis ;} ;

  int get_lquant() {return l_quant;} ;

  double get_masse() {return masse;} ;

 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
  virtual void dec_l_quant() ;
} ;

class Ope_poisson_pseudo_1d : public Ope_elementary {

 protected:
  int l_quant ; 
    
 public:
  Ope_poisson_pseudo_1d (int nbr, int baser, double alf, double bet, int lq) ;
  Ope_poisson_pseudo_1d (const Ope_poisson_pseudo_1d&) ; 
  virtual ~Ope_poisson_pseudo_1d() ; 

  int get_lquant() {return l_quant;} ;

 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
  virtual void dec_l_quant() ;

} ;


class Ope_helmholtz_minus_pseudo_1d : public Ope_elementary {

 protected:
  int l_quant ; 
  double masse ; 
  int dzpuis ; 
  
 public:
  Ope_helmholtz_minus_pseudo_1d (int nbr, int baser, double alf, double bet, 
                 int lq, double masse, int dz) ;
  Ope_helmholtz_minus_pseudo_1d (const Ope_helmholtz_minus_pseudo_1d&) ; 
  virtual ~Ope_helmholtz_minus_pseudo_1d() ; 

  int get_dzpuis() {return dzpuis ;} ;

  int get_lquant() {return l_quant;} ;

  double get_masse() {return masse;} ;

 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
  virtual void dec_l_quant() ;
} ;

class Ope_vorton : public Ope_elementary {

 protected:
  int l_quant ; 
  int dzpuis ; 
  
 public:
  Ope_vorton (int nbr, int baser, double alf, double bet, int lq, int dz) ;
  Ope_vorton (const Ope_vorton&) ; 
  virtual ~Ope_vorton() ; 

  int get_dzpuis() {return dzpuis ;} ;

  int get_lquant() {return l_quant;} ;

 private:
  virtual void do_ope_mat() const ;
  virtual void do_ope_cl() const ;
  virtual void do_non_dege() const ;  
  
 public:
  virtual Tbl get_solp(const Tbl& so) const ;
  virtual Tbl get_solh() const ;
  virtual void inc_l_quant() ;
  virtual void dec_l_quant() ;
} ;

# endif

---