app-cwinkelm/bilinearForm.hh

Go to the documentation of this file.

// Bilinear forms for linear DG FEM in 2D

#ifndef linDG2DelasticBilinearForm_hh
#define linDG2DelasticBilinearForm_hh

#include "basics/typedefs.hh"
#include "operator/bilinearForm.hh"
#include "geometry/boundaryConditions.hh"

using concepts::Real;

// ******************************************************** DGElasticVolBf2d **

class DGElasticVolBf2d : public concepts::BilinearForm<Real> {
public:
  DGElasticVolBf2d(const concepts::Mapping<Real, 2> m) 
    : submapping_(m) { }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmU,
                          concepts::ElementMatrix<Real>& em);
  virtual DGElasticVolBf2d* clone() const {
    return new DGElasticVolBf2d(submapping_); }
private:
  const concepts::Mapping<Real, 2> submapping_;
};

// ******************************************************* DGElasticFluxBf2d **

class DGElasticFluxBf2d : public concepts::BilinearForm<Real> {
public:
  DGElasticFluxBf2d(const concepts::Mapping<Real, 2> m,
                    concepts::BoundaryConditions* bc) 
    : bc_(bc), submapping_(m) { }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmU,
                          concepts::ElementMatrix<Real>& em) {
    conceptsAssert(false, concepts::Assertion());
  }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmU,
                          concepts::ElementMatrix<Real>& em,
                          const concepts::ElementPair<Real>& ep);
  virtual DGElasticFluxBf2d* clone() const {
    return new DGElasticFluxBf2d(submapping_, bc_); }
private:
  concepts::BoundaryConditions* bc_;
  const concepts::Mapping<Real, 2> submapping_;
};

// ******************************************************* DGElasticStabBf2d **

class DGElasticStabBf2d : public concepts::BilinearForm<Real> {
public:
  DGElasticStabBf2d(Real omega, concepts::BoundaryConditions* bc)
    : omega_(omega), bc_(bc) {}
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmU,
                          concepts::ElementMatrix<Real>& em) {
    conceptsAssert(false, concepts::Assertion());
  }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmU,
                          concepts::ElementMatrix<Real>& em,
                          const concepts::ElementPair<Real>& ep);
  virtual DGElasticStabBf2d* clone() const {
    return new DGElasticStabBf2d(omega_, bc_); }
private:
  const Real omega_;
  concepts::BoundaryConditions* bc_;
};

// ************************************************* DGElasticNormalStabBf2d **

class DGElasticNormalStabBf2d : public concepts::BilinearForm<Real> {
public:
  DGElasticNormalStabBf2d(const Real omega, const uint dV,
                          const uint dU, concepts::BoundaryConditions* bc)
    : omega_(omega), dV_(dV), dU_(dU), bc_(bc) { }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmU,
                          concepts::ElementMatrix<Real>& em) {
    conceptsAssert(false, concepts::Assertion());
  }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmU,
                          concepts::ElementMatrix<Real>& em,
                          const concepts::ElementPair<Real>& ep);
  virtual DGElasticNormalStabBf2d* clone() const {
    return new DGElasticNormalStabBf2d(omega_, dV_, dU_, bc_); }
private:
  const Real omega_;
  const uint dV_;
  const uint dU_;
  concepts::BoundaryConditions* bc_;
};

// ***************************************************** DGElasticDivVolBf2d **

class DGElasticDivVolBf2d : public concepts::BilinearForm<Real> {
public:
  DGElasticDivVolBf2d(const uint dV, Real scale = 1.0)
    : dV_(dV), scale_(scale) { }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmP,
                          concepts::ElementMatrix<Real>& em) {
    conceptsAssert(false, concepts::Assertion());
  }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmP,
                          concepts::ElementMatrix<Real>& em,
                          const concepts::ElementPair<Real>& ep);
  virtual DGElasticDivVolBf2d* clone() const {
    return new DGElasticDivVolBf2d(dV_, scale_); }
private:
  const uint dV_;
  const Real scale_;
};

// **************************************************** DGElasticDivFluxBf2d **

class DGElasticDivFluxBf2d : public concepts::BilinearForm<Real> {
public:
  DGElasticDivFluxBf2d(const uint dV, concepts::BoundaryConditions* bc,
                       Real scale = 1.0)
    : dV_(dV), bc_(bc) , scale_(scale) { }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmP,
                          concepts::ElementMatrix<Real>& em) {
    conceptsAssert(false, concepts::Assertion());
  }
  virtual void operator()(const concepts::Element<Real>& elmV,
                          const concepts::Element<Real>& elmP,
                          concepts::ElementMatrix<Real>& em,
                          const concepts::ElementPair<Real>& ep);
  virtual DGElasticDivFluxBf2d* clone() const {
    return new DGElasticDivFluxBf2d(dV_, bc_, scale_); }
private:
  const uint dV_;
  concepts::BoundaryConditions* bc_;
  const Real scale_;
};

// ******************************************************* DGElasticCompBf2d **

class DGElasticCompBf2d : public concepts::BilinearForm<Real> {
public:
  DGElasticCompBf2d(Real lambda) : lambda_(lambda) { }
  virtual void operator()(const concepts::Element<Real>& elmQ,
                          const concepts::Element<Real>& elmP,
                          concepts::ElementMatrix<Real>& em);
  virtual DGElasticCompBf2d* clone() const {
    return new DGElasticCompBf2d(lambda_); }
private:
  Real lambda_;
};

#endif // linDG2DelasticBilinearForm_hh