Class xlifepp::SpectralBasisFun#

class SpectralBasisFun : public xlifepp::SpectralBasis #

defines class of global basis functions given by an analytic expression.

It uses the general Function class (defined in utils lib) with function of the form:

T function(const Point&, Parameters&)
T is either a real_t or a complex_t or a Vector<real_t> or a Vector<complex_t>

providing the computation of the n-th basis function at a given point.

For instance, to define the spectral basis a_n sin(n pi x), define the standard c++ function:

real_t sin_n(const Point &p,Parameters& pa = defaultParameters) {
  real_t x=p.x();
  real_t h=pa("h");                    //get the parameter h (user definition)
  number_t n=pa("basis size");         //get the size of the basis
  number_t id=pa("basis index");       //get the index of function to compute
  return sqrt(2/h)*sin(id*pi*x/h);}  //computation
}

and use it as follows:

Parameters p(1,"h");
SpectralBasisFun sinBasis(Omega,Function(sin_n,p),10); //define the set of basis function
real_t s1;
sinBasis.functions(1,Point(0.5),s1); //compute the basis function n=1 at point x=0.5 in S1
Vector<real_t> sn;
sinBasis.functions(Point(0.5),sn);   //compute all the basis functions at point x=0.5 in Sn

Public Functions

SpectralBasisFun(const Function&, number_t n)#: constructor with no GeomDomain

SpectralBasisFun(const GeomDomain&, const Function&, number_t)#: constructor

SpectralBasisFun(const SpectralBasisFun&)#: copy constructor

inline Function &basis()#: access to functions

inline const Function &basis() const#: access to functions

inline virtual SpectralBasisFun *clone() const#: clone of current returned as pointer (covariant)

inline virtual complex_t &evaluate(const std::vector<real_t> &p, const Vector<complex_t> &a, complex_t &v) const#: evaluate linear combination of complex basis functions

inline virtual real_t &evaluate(const std::vector<real_t> &p, const Vector<real_t> &a, real_t &v) const#: evaluate linear combination of real basis functions

template<typename T> T &evaluateT(const std::vector<real_t>&, const Vector<T>&, T&) const#: evaluate linear combination of basis functions

template<typename T> T &function(number_t, const Point&, T&, DiffOpType = _id) const#: compute n-th function

template<typename T> Vector<T> &functions(const Point &P, Vector<T> &res, DiffOpType = _id) const#: compute all functions

SpectralBasisFun &operator=(const SpectralBasisFun&)#: assign operator

virtual void print(std::ostream&) const#: print utility

inline virtual void setGeomElementPointer(const void *pd) const#: link geomElement pointer to function