linDG3D/bilinearForm.hh

Go to the documentation of this file.

/* Classes for DG bilinear forms
 */

#ifndef dgBilinearForms_hh
#define dgBilinearForms_hh

#include "basics/typedefs.hh"
#include "elementPair.hh"
#include "operator/bilinearForm.hh"
#include "operator/matrix.hh"

#define DEBUG_ASSEMBLY 0
#define DEBUG_IDENTITY 0
#define DEBUG_LAPLACE 0

namespace linDG3D {

  using concepts::Real;
  // ***************************************************** FvdgBilinearForm  **
  
  class FvdgBilinearForm {
  public:
    virtual void operator()(const FvdgElement& elmX, const FvdgElement& elmY,
          concepts::ElementMatrix<Real>& em,
          const FvdgElementPair& ep) = 0;
  };
  

  // ************************************************************** Assembly **

  class Assembly
  {
  public:
    static void inner(concepts::Matrix<Real>& dest,
          FvdgBilinearForm& bf,
          const concepts::ElementPairList<Real>& pairs,
          bool transpose = false);
    static void boundary(concepts::Matrix<Real>& dest,
       FvdgBilinearForm& bf,
       const concepts::ElementPairList<Real>& pairs,
       bool transpose = false);
  private:
    Assembly() {};
  };
  
  // ************************************************************** Identity **
  class Identity : public concepts::BilinearForm<Real> {
  public:
    Identity() {}
    virtual void operator()(const concepts::Element<Real>& elmX,
          const concepts::Element<Real>& elmY,
          concepts::ElementMatrix<Real>& em);
    void operator()(const FvdgP0TetElem& eX,
        const FvdgP0TetElem& eY,
        concepts::ElementMatrix<Real>& em);
    void operator()(const FvdgP1TetElem& eX,
        const FvdgP1TetElem& eY,
        concepts::ElementMatrix<Real>& em);
    virtual Identity* clone() const { return new Identity(); }
  };
  
  //*********************************************************** LaplaceVolBF **
  class LaplaceVolBF : public concepts::BilinearForm<Real> {
  public:
    LaplaceVolBF() {}
    virtual void operator()(const concepts::Element<Real>& elmX,
          const concepts::Element<Real>& elmY,
          concepts::ElementMatrix<Real>& em);
    void operator()(const FvdgP1TetElem& eX,
        const FvdgP1TetElem& eY,
        concepts::ElementMatrix<Real>& em);
    virtual LaplaceVolBF* clone() const { return new LaplaceVolBF(); }
  };
  
  //********************************************************* LaplaceInnerBF **
  class LaplaceInnerBF : public FvdgBilinearForm {
  public:
    LaplaceInnerBF(bool symm = false) { symm_ = symm ? -1 : 1; }
    virtual void operator()(const FvdgElement& elmX, const FvdgElement& elmY,
          concepts::ElementMatrix<Real>& em,
          const FvdgElementPair& ep);
    virtual LaplaceInnerBF* clone() const { return new LaplaceInnerBF(symm_); }
  private:
    int symm_;
  };

  //****************************************************** LaplaceBoundaryBF **
  class LaplaceBoundaryBF : public FvdgBilinearForm {
  public:
    LaplaceBoundaryBF(bool symm = false) {
      symm_ = symm ? -1 : 1;
    }
    virtual void operator()(const FvdgElement& elmX, const FvdgElement& elmY,
          concepts::ElementMatrix<Real>& em,
          const FvdgElementPair& ep);
    virtual LaplaceBoundaryBF* clone() const {
      return new LaplaceBoundaryBF(symm_); }
  private:
    int symm_;
  };
  
  //************************************************************** PenaltyBF **
  class PenaltyBF : public FvdgBilinearForm {
  public:
    PenaltyBF() {}
    virtual void operator()(const FvdgElement& elmX, const FvdgElement& elmY,
          concepts::ElementMatrix<Real>& em,
          const FvdgElementPair& ep);
    virtual PenaltyBF* clone() const { return new PenaltyBF(); }
  };
  
} // namespace linDG3D

#endif // dgBilinearForms_hh