RefDesc.h

// =======================================================================
// @(#)RefDesc.h        1.11 11/15/99
//
// Class:       TRefDesc
// Purpose:     super class of all refinement descriptors
//
// Author:      Volker Behns  09.07.97
//
// History:     Add enum RefinementMarks 17.10.97 (Gunar Matthies)
//
// =======================================================================

#ifndef __REFDESC__
#define __REFDESC__

#include <ShapeDesc.h>

#define N_REFDESC  74
// Actually there are some more refinement types (the mortar types).
// These will be added dynamicly.
// We use TriBis0 - Quad2Conf3 for generation of closures. Do not
// put any other descriptors between these.
enum Refinements {NoRef, LineReg, TriReg, QuadReg, ParallReg, RectReg,
                  TriBis0, TriBis1, TriBis2, 
                  TriBis01, TriBis02, TriBis10, TriBis12, TriBis20, TriBis21,
                  QuadBis0, QuadBis1,
                  Quad1Conf0, Quad1Conf1, Quad1Conf2, Quad1Conf3,
                  Quad2Conf0, Quad2Conf1, Quad2Conf2, Quad2Conf3,
                  QuadToTri0, QuadToTri1, TetraReg, 
                  TetraReg0, TetraReg1, TetraReg2, 
                  TetraBis0, TetraBis1, TetraBis2, TetraBis3, TetraBis4, TetraBis5,
                  TetraBis01, TetraBis02, TetraBis03, TetraBis04, TetraBis05,
                  TetraBis10, TetraBis12, TetraBis13, TetraBis14, TetraBis15,
                  TetraBis20, TetraBis21, TetraBis23, TetraBis24, TetraBis25,
                  TetraBis30, TetraBis32, TetraBis34, TetraBis35,
                  TetraBis40, TetraBis41, TetraBis43, TetraBis45,
                  TetraBis51, TetraBis52, TetraBis53, TetraBis54,
                  TetraQuad0, TetraQuad1, TetraQuad2, TetraQuad3, TetraQuad4, TetraQuad5,
                  HexaReg, BrickReg,
                  Mortar, MortarLine};

#ifdef __MORTAR__
  #define N_MORTARDESC 5

  #define MORTAR_N1  0
  #define MORTAR_N2  2
  #define MORTAR_N3  4
  #define MORTAR_N4  6
  #define MORTAR_N5  8
#else
  #define N_MORTARDESC 0
#endif

enum RefinementMarks { NoRefinement, Refinement, DeRefinement };

#ifdef __2D__
  #define MAXN_ORIGEDGES    4
  #define MAXN_NEWVERTICES  9
  #define MAXN_NEWJOINTS   12
  #define MAXN_CHILDREN     4
#else
  #define MAXN_ORIGEDGES   12
  #define MAXN_NEWVERTICES 27
  #define MAXN_NEWJOINTS   36
  #define MAXN_NEWEDGES    54
  #define MAXN_CHILDREN     8
#endif

class TRefDesc
{
  protected:
    TShapeDesc *Shape;

    Refinements Type;

    int N_Vertices;
    int N_Edges;
    int N_Children;

    int N_OrigVertices;
    int N_OrigEdges;

    #ifdef __3D__

      int N_Faces;
      int N_OrigFaces;
      int N_InnerFaces;
    #endif

    int N_NewVertEqOldVert;
    int N_InnerVertices;
    int N_NewEdgeEqOldEdge;
    int N_InnerEdges;

    int MaxN_VpC;
    int MaxN_CpV;
    int MaxN_EpC;
    int MaxN_CpE;
    int MaxN_EpV;
    int MaxN_iVpE;
    int MaxN_nVpoE;
    int MaxN_nEpoE;

    const Shapes *ChildType;
    const Refinements *EdgeType;

    const int *ChildVertex;
    const int *ChildVertexLen;
    const int *VertexChild;
    const int *VertexChildIndex;
    const int *VertexChildLen;

    const int *ChildEdge;
    const int *EdgeChild;
    const int *EdgeChildIndex;
    const int *EdgeChildLen;

    const int *EdgeVertex;
    const int *VertexEdge;
    const int *VertexEdgeIndex;
    const int *VertexEdgeLen;

    const int *NewVertexEqOldVertex;
    const int *NewVertexEqOldVertexIndex;

    const int *NewEdgeEqOldEdge;
    const int *NewEdgeEqOldEdgeIndex;

    const int *InteriorVertexOfCell;
    const double *PositionOfIntVert;

    const int *InteriorEdgeOfCell;
    const int *InteriorVertexOfEdge;
    const int *InteriorVertexOfEdgeLen;

    const int *OldEdgeNewVertex;
    const int *OldEdgeNewVertexLen;

    const int *OldEdgeNewLocEdge;

    const int *OldEdgeNewEdge;
    const int *OldEdgeNewEdgeLen;
    const int *NewEdgeOldEdge;

    #ifdef __3D__

      int MaxN_VpF;
      int MaxN_oVpoF;
      int MaxN_FpV;
      int MaxN_EpF;
      int MaxN_FpE;
      int MaxN_CpF;
      int MaxN_FpC;
      int MaxN_iVpF;
      int MaxN_iEpF;
      int MaxN_nEpoF;
      int MaxN_nVpoF;
      int MaxN_niVpoF;
      int MaxN_nFpoF;
      const Refinements *FaceType;
      const int *FaceChild;
      const int *FaceChildIndex;
      const int *FaceChildLen;

      const int *FaceEdge;
      const int *EdgeFace;
      const int *EdgeFaceLen;
      const int *EdgeFaceIndex;

      const int *FaceVertex;
      const int *VertexFace;
      const int *VertexFaceLen;
      const int *VertexFaceIndex;

      const int *InteriorFaceOfCell;

      const int *InteriorVertexOfFace;
      const int *InteriorVertexOfFaceLen;

      const int *InteriorEdgeOfFace;
      const int *InteriorEdgeOfFaceLen;

      const int *OldFaceNewInnerVertices;
      const int *OldFaceNewInnerVerticesLen;

      int N_NewFaceEqOldFace;
      const int *NewFaceEqOldFace;
      const int *NewFaceEqOldFaceIndex;

      const int *N_NewVertsOnOldFace;
      const int *NewVertsOnOldFace;
      const double *NewVertsOnOldFacePos;

      const int *ChildFace;

      const int *OldFaceNewVertex;
      const double *OldFaceNewVertexPos;
      const int *OldFaceNewVertexLen;

      const int *OldFaceNewEdge;
      const int *OldFaceNewEdgeLen;

      const int *OldFaceNewFace;
      const int *OldFaceNewFaceLen;

      const int *NewFaceOldFace;

      const int *OldFaceNewLocFace;

      const int *ChildTwistIndex;
    #endif

  public:
    // Constructor
    TRefDesc(TShapeDesc *shape);

    // Methods
    Refinements GetType()
    { return Type; }
    int GetN_Children()
    { return N_Children; }
    int GetN_Edges()
    { return N_Edges; }
    int GetN_Vertices()
    { return N_Vertices; }

    int GetN_OrigEdges()
    { return N_OrigEdges; }
    int GetN_OrigVertices()
    { return N_OrigVertices; }

    #ifdef __3D__

      int GetN_OrigFaces()
      { return N_OrigFaces; }
      int GetN_Faces()
      { return N_Faces; }
    #endif

    virtual int IsToRefine()
    { return TRUE; }
    
    TShapeDesc *GetShapeDesc()
    { return Shape; }
    Refinements GetEdgeRef(int J_i)
    { return EdgeType[J_i]; }
    Shapes GetChildType(int C_i)
    { return ChildType[C_i]; }

    int GetN_NewVertEqOldVert()
    { return N_NewVertEqOldVert; }
    int GetN_InnerVertices()
    { return N_InnerVertices; }
    int GetN_NewEdgeEqOldEdge() 
    { return N_NewEdgeEqOldEdge; }
    int GetN_InnerEdges()
    { return N_InnerEdges; }

    int GetNewVertEqOldVert(const int *&TmpValues, const int *&TmpIndex)
    {
        TmpValues = NewVertexEqOldVertex;
        TmpIndex = NewVertexEqOldVertexIndex;
        return 0;
     }

    int GetInnerVerts(const int *&TmpValues, const double *&TmpPos,
          int &MaxLen)
    {
      TmpValues = InteriorVertexOfCell;
      TmpPos = PositionOfIntVert;
      MaxLen = N_OrigVertices;
      return 0;
    }

    int GetNewEdgeEqOldEdge(const int *&TmpValues, const int *&TmpIndex)
    {
      TmpValues = NewEdgeEqOldEdge;
      TmpIndex = NewEdgeEqOldEdgeIndex;
      return 0;
    }

    int GetInnerEdges(const int *&TmpinE, const int *&TmpEC, int &MaxLen)
    {
       TmpinE = InteriorEdgeOfCell;
       TmpEC = EdgeChild;
       MaxLen = MaxN_CpE;
       return 0;
    }

    int GetOldEdgeNewEdge(const int *&TmpoEnE, const int *&TmpLen,
          int &MaxLen)
    {
      TmpoEnE = OldEdgeNewEdge;
      TmpLen = InteriorVertexOfEdgeLen;
      MaxLen = MaxN_nEpoE;
      return 0;
    }

    int GetOldEdgeNewLocEdge(const int *&TmpoEnlE)
    {
      TmpoEnlE=OldEdgeNewLocEdge;
      return 0;
    }

    int GetNewEdgeOldEdge(const int *&TmpnEoE)
    {
      TmpnEoE = NewEdgeOldEdge;
      return 0;
    }

    int GetEdgeChild(const int *&TmpEC, const int *&TmpLen, int &MaxLen)
    {
        TmpEC = EdgeChild;
        TmpLen = EdgeChildLen;
        MaxLen = MaxN_CpE;
        return 0;
    }

    int GetEdgeChildIndex(const int *&TmpECI, const int *&TmpLen,
          int &MaxLen)
    {
      TmpECI = EdgeChildIndex;
      TmpLen = EdgeChildLen;
      MaxLen = MaxN_CpE;
      return 0;
    }

    int GetOldEdgeNewVertex(const int *&TmpoEnV, const int *&TmpLen,
          int &MaxLen)
    {
      TmpoEnV = OldEdgeNewVertex;
      TmpLen = InteriorVertexOfEdgeLen;
      MaxLen = MaxN_nVpoE;
      return 0;
    }
    
    int GetEdgeVertex(const int *&TmpEV)
    {
      TmpEV = EdgeVertex;
      return 0;
    }

    int GetVertexEdge(const int *&TmpVE, const int *&TmpLen,
          int &MaxLen)
    {
      TmpVE = VertexEdge;
      TmpLen = VertexEdgeLen;
      MaxLen = MaxN_EpV;
      return 0;
    }

    int GetVertexEdgeIndex(const int *&TmpVEI, const int *&TmpLen,
          int &MaxLen)
    {
      TmpVEI = VertexEdgeIndex;
      TmpLen = VertexEdgeLen;
      MaxLen = MaxN_EpV;
      return 0;
    }

    int GetVertexChild(const int *&TmpVC, const int *&TmpLen,
          int &MaxLen)
    {
      TmpVC = VertexChild;
      TmpLen = VertexChildLen;
      MaxLen = MaxN_CpV;
      return 0;
    }

    int GetVertexChildIndex(const int *&TmpVCI, const int *&TmpLen,
          int &MaxLen)
    {
      TmpVCI = VertexChildIndex;
      TmpLen = VertexChildLen;
      MaxLen = MaxN_CpV;
      return 0;
    }

    int GetChildVertex(const int *&TmpCV, int &MaxLen)
    {
      TmpCV =  ChildVertex;
      MaxLen = MaxN_VpC;
      return 0;
    }

    int GetChildEdge(const int *&TmpCE, int &MaxLen)
    {
      TmpCE =  ChildEdge;
      MaxLen = MaxN_EpC;
      return 0;
    }

    #ifdef __3D__

      int GetN_InnerFaces()
      { return N_InnerFaces; }
    
      int GetInnerFaces(const int *&TmpinF, const int *&TmpFC, int &MaxLen)
      {
         TmpinF = InteriorFaceOfCell;
         TmpFC = FaceChild;
         MaxLen = MaxN_CpF;
         return 0;
      }

      int GetOldFaceNewInnerVertex(const int *&TmpoFniV,
                                   const int *&TmpLen, int &MaxLen)
      {
        TmpoFniV = OldFaceNewInnerVertices;
        TmpLen = OldFaceNewInnerVerticesLen;
        MaxLen = MaxN_niVpoF;
        return 0;
      }

      int GetOldFaceNewFace(const int *&TmpoFnF, const int *&TmpLen,
                            int &MaxLen)
      {
        TmpoFnF = OldFaceNewFace;
        TmpLen = OldFaceNewFaceLen;
        MaxLen = MaxN_nFpoF;
        return 0;
      }

      Refinements GetFaceRef(int i)
      { return FaceType[i]; }

      int GetN_NewFaceEqOldFace()
      { return N_NewFaceEqOldFace; }

      int GetNewFaceEqOldFace(const int *&TmpValues, const int *&TmpIndex)
      {
        TmpValues = NewFaceEqOldFace;
        TmpIndex = NewFaceEqOldFaceIndex;
        return 0;
      }

      int GetFaceChild(const int *&TmpFC, const int *&TmpLen, int &MaxLen)
      {
          TmpFC = FaceChild;
          TmpLen = FaceChildLen;
          MaxLen = MaxN_CpF;
          return 0;
      }

      int GetFaceChildIndex(const int *&TmpFCI, const int *&TmpLen, int &MaxLen)
      {
          TmpFCI = FaceChildIndex;
          TmpLen = FaceChildLen;
          MaxLen = MaxN_CpF;
          return 0;
      }

      int GetFaceEdge(const int *&TmpFE, int &MaxLen)
      {
        TmpFE =  FaceEdge;
        MaxLen = MaxN_EpF;
        return 0;
      }

      int GetNewVertsOnOldFace(const int *&TmpNV, const double *&TmpPos,
                               int &MaxLen)
      {
        TmpNV = NewVertsOnOldFace;
        TmpPos = NewVertsOnOldFacePos;
        MaxLen = MaxN_nVpoF;

        return 0;
      }

      int GetChildFace(const int *&TmpCF, int &MaxLen)
      {
        TmpCF = ChildFace;
        MaxLen = MaxN_FpC;

        return 0;
      }

      int GetOldFaceNewVertex(const int *&TmpoFnV, const int *&TmpLen,
                              int &MaxLen)
      {
        TmpoFnV = OldFaceNewVertex;
        TmpLen = OldFaceNewVertexLen;
        MaxLen = MaxN_nVpoF;

        return 0;
      }

      int GetOldFaceNewVertex(const int *&TmpoFnV, const double *&TmpPos,
            const int *&TmpLen, int &MaxLen1, int &MaxLen2)
      {
        TmpoFnV = OldFaceNewVertex;
        TmpPos = OldFaceNewVertexPos;
        TmpLen = OldFaceNewVertexLen;
        MaxLen1 = MaxN_nVpoF;
        MaxLen2 = MaxN_oVpoF;

        return 0;
      }

      int GetNewFaceOldFace(const int *&TmpnFoF)
      {
        TmpnFoF = NewFaceOldFace;

        return 0;
      }

      int GetOldFaceNewLocFace(const int *&TmpoFnlF)
      {
        TmpoFnlF = OldFaceNewLocFace;

        return 0;
      }

      int GetChildTwistIndex(const int *&TmpCTI)
      {
        TmpCTI = ChildTwistIndex;

        return 0;
      }
      
      // added 25.04.2010 for fixing refinement problem
      int GetFaceVertex (const int *&TmpFV, int &TmpLen)
      {
    TmpFV = FaceVertex;
    TmpLen = MaxN_VpF;
    
    return 0;
      }

    #endif
};

#endif