P12DElement.h

Go to the documentation of this file.

#ifndef P12DELEMENT
#define P12DELEMENT

#include "Element.h"
#include "P1nDElement.h"

#include "ElementGeometry.h"
#include "Triangle.h"
#include "ElementBoundaryTrace.h"
#include "ShapesEvaluated.h"

#include <iostream>
#include <vector>
#include <cassert>

template<size_t NF>
class P12DElement: public P1nDElement<NF> {
public:
  P12DElement (const Triangle<2>& _elemGeom) :
    P1nDElement<NF> (_elemGeom) {
    ShapesP12D::Bulk modelShape (_elemGeom);
    Element_::addBasisFunctions (modelShape);
  }

  P12DElement (const P12DElement<NF> &that) :
    P1nDElement<NF> (that) {

  }

  virtual P12DElement<NF>* clone () const {
    return new P12DElement<NF> (*this);
  }
};

template<size_t NF>
class P12DTrace: public P1nDTrace<NF> {
public:

  P12DTrace (const P12DElement<NF> & BaseElement, const typename P1nDTrace<NF>::FaceLabel& FaceName,
      const typename P1nDTrace<NF>::ShapeType& Type);

  virtual ~P12DTrace () {
  }

  P12DTrace (const P12DTrace<NF> &that) :
    P1nDTrace<NF> (that) {
  }

  virtual P12DTrace<NF> * clone () const {
    return new P12DTrace<NF> (*this);
  }
private:
  void checkArgs (const typename P1nDTrace<NF>::FaceLabel& faceLabel,
      const typename P1nDTrace<NF>::ShapeType& shapeType) {
    // Triangle has only 3 faces
    assert (faceLabel != P1nDTrace<NF>::FaceFour);

    // valid ShapeTypes are TwoDofs and ThreeDofs
    assert (shapeType == P1nDTrace<NF>::TwoDofs || shapeType == P1nDTrace<NF>::ThreeDofs);
  }

};

template<size_t NF>
P12DTrace<NF>::P12DTrace (const P12DElement<NF> & BaseElement,
    const typename P1nDTrace<NF>::FaceLabel& FaceName, const typename P1nDTrace<NF>::ShapeType& Type) :
  P1nDTrace<NF> (BaseElement) {

  checkArgs (FaceName, Type);

  const ElementGeometry& TriGeom = Element::getGeometry ();
  if (Type == P1nDTrace<NF>::TwoDofs)
    switch (FaceName) {
      case P1nDTrace<NF>::FaceOne: {
        Segment<2> FaceGeom (TriGeom.getConnectivity ()[0], TriGeom.getConnectivity ()[1]);
        ShapesP12D::Faces ModelShape (&FaceGeom);
        Element_::addBasisFunctions (ModelShape);
        break;
      }

      case P1nDTrace<NF>::FaceTwo: {
        Segment<2> FaceGeom (TriGeom.getConnectivity ()[1], TriGeom.getConnectivity ()[2]);
        ShapesP12D::Faces ModelShape (&FaceGeom);
        Element_::addBasisFunctions (ModelShape);
        break;
      }

      case P1nDTrace<NF>::FaceThree: {
        Segment<2> FaceGeom (TriGeom.getConnectivity ()[2], TriGeom.getConnectivity ()[0]);
        ShapesP12D::Faces ModelShape (&FaceGeom);
        Element_::addBasisFunctions (ModelShape);
        break;
      }
    }
  else
    // Type==ThreeDofs
    switch (FaceName) {
      case P1nDTrace<NF>::FaceOne: {
        Segment<2> FaceGeom (TriGeom.getConnectivity ()[0], TriGeom.getConnectivity ()[1]);
        ShapesP12D::FaceOne ModelShape (&FaceGeom);
        Element_::addBasisFunctions (ModelShape);
        break;
      }

      case P1nDTrace<NF>::FaceTwo: {
        Segment<2> FaceGeom (TriGeom.getConnectivity ()[1], TriGeom.getConnectivity ()[2]);
        ShapesP12D::FaceTwo ModelShape (&FaceGeom);
        Element_::addBasisFunctions (ModelShape);
        break;
      }

      case P1nDTrace<NF>::FaceThree: {
        Segment<2> FaceGeom (TriGeom.getConnectivity ()[2], TriGeom.getConnectivity ()[0]);
        ShapesP12D::FaceThree ModelShape (&FaceGeom);
        Element_::addBasisFunctions (ModelShape);
        break;
      }
    }
}

template<size_t NF>
class P12DElementBoundaryTraces: public P1nDBoundaryTraces<NF> {
public:
  P12DElementBoundaryTraces (const P12DElement<NF> &BaseElement,
      const std::vector<typename P1nDTrace<NF>::FaceLabel>& flabels,
      const typename P1nDTrace<NF>::ShapeType& shType):
        P1nDBoundaryTraces<NF> (BaseElement, flabels, shType) {

  }

  virtual ~P12DElementBoundaryTraces () {
  }

  P12DElementBoundaryTraces (const P12DElementBoundaryTraces<NF> & OldElem) :
    P1nDBoundaryTraces<NF> (OldElem) {
  }

  P12DElementBoundaryTraces<NF> * clone () const {
    return new P12DElementBoundaryTraces<NF> (*this);
  }


  size_t dofMap (size_t FaceIndex, size_t field, size_t dof) const;

};

// Class Implementation
template<size_t NF> size_t P12DElementBoundaryTraces<NF>::dofMap (
    size_t FaceIndex, size_t field, size_t dof) const {
  size_t val;
  if (ElementBoundaryTraces::getTrace (FaceIndex).getDof (field) == 3) {
    val = dof;
  } else {
    // getTrace(FaceIndex).getDof(field)=2
    switch (ElementBoundaryTraces::getTraceFaceIds ()[FaceIndex]) {
      case 0:
        val = dof;
        break;

      case 1:
        val = dof + 1;
        break;

      case 2:
        val = (dof == 0 ? 2 : 0);
        break;

      default:
        std::cerr << "P12DElementBoundaryTraces.DofMap Error\n";
        exit (1);
    }
  }

  return val;
}

template<size_t NF> class P12D: public SpecificElementFamily {
public:
  typedef P12DElement<NF> Bulk;

  typedef P12DTrace<NF> Face;

  typedef P12DElementBoundaryTraces<NF> Traces;
};



#endif

---