FEDatabase2D.h

// =======================================================================
// @(#)FEDatabase2D.h        1.5 02/08/00
//
// Class:       TFEDatabase
// Purpose:     store all used information for a FEM
//
// Author:      Gunar Matthies  09.07.98
//
// =======================================================================

#ifndef __FEDATABASE2D__
#define __FEDATABASE2D__

#include <Constants.h>
#include <Enumerations.h>

#include <BaseFunct1D.h>
#include <FEDesc1D.h>
#include <FE1D.h>

#include <BaseFunct2D.h>
#include <FEDesc2D.h>
#include <FE2D.h>
#include <FE2DMapper.h>
#include <FE2DMapper1Reg.h>
#include <HNDesc.h>
#include <RefTrans2D.h>

#include <QuadFormula1D.h>
#include <QuadFormulaQuad.h>
#include <QuadFormulaTria.h>


class TFEDatabase2D
{
  protected:
//======================================================================
//      1D data
//======================================================================
    static TQuadFormula1D *QuadFormulas1D[N_QuadFormulas_1D];

    static TBaseFunct1D *BaseFuncts1D[N_BaseFuncts1D];

    static TNodalFunctional1D *NodalFunctionals1D[N_NodalFunctionals1D];

    static TFEDesc1D *FEDescs1D[N_FEDescs1D];

    static TFE1D *FEs1D[N_FEs1D];

    static double **RefElementValues1D[N_BaseFuncts1D][N_QuadFormulas_1D]
    [N_MultiIndices1D];

    static double **OrigElementValues1D[N_BaseFuncts1D][N_MultiIndices1D];

    static QuadFormula1D QFLineFromDegree[MAXDEGREE];

    static int HighestAccuracyLine;

    static TRefTrans1D *ReferenceTrans1D[1];

//======================================================================
//      2D data
//======================================================================
    static TFE2D *FEs2D[N_FEs2D];

    static TFEDesc2D *FEDescs2D[N_FEDescs2D];

    static TBaseFunct2D *BaseFuncts2D[N_BaseFuncts2D];

    static TNodalFunctional2D *NodalFunctionals2D[N_NodalFunctionals2D];

    static TQuadFormula2D *QuadFormulas2D[N_QuadFormulas_2D];

    static TFE2DMapper *FE2DMapper[N_FEDescs2D][N_FEDescs2D];

    static TFE2DMapper1Reg *FE2DMapper1Reg[N_FEDescs2D][N_FEDescs2D];

    static THNDesc *HNDescs2D[N_HNDescs];

    static double **RefElementValues2D[N_BaseFuncts2D][N_QuadFormulas_2D]
    [N_MultiIndices2D];

    static double **JointValues2D[N_BaseFuncts2D][N_QuadFormulas_1D]
    [MAXN_JOINTS];

    static double **JointDerivatives2D[N_BaseFuncts2D][N_QuadFormulas_1D]
    [MAXN_JOINTS][N_MultiIndices2D];

    static double **OrigElementValues2D[N_BaseFuncts2D][N_MultiIndices2D];

    static TRefTrans2D *ReferenceTrans2D[N_RefTrans2D];

    static double *ProlongationMatrix2D[MaxN_BaseFunctions2D]
        [N_REFDESC][MaxN_BaseFunctions2D][MAXN_CHILDREN];

    static double *RestrictionMatrix2D[MaxN_BaseFunctions2D]
        [N_REFDESC][MaxN_BaseFunctions2D][MAXN_CHILDREN];

    static QuadFormula2D QFTriaFromDegree[MAXDEGREE];

    static int HighestAccuracyTria;

    static QuadFormula2D QFQuadFromDegree[MAXDEGREE];

    static int HighestAccuracyQuad;

//======================================================================
//      2D arrays for easier access of information
//======================================================================
     static FEDesc2D FEDesc2D_IDFromFE2D[N_FEs2D];

     static TFEDesc2D *FEDesc2DFromFE2D[N_FEs2D];

     static BaseFunct2D BaseFunct2D_IDFromFE2D[N_FEs2D];

     static int N_BaseFunctFromFE2D[N_FEs2D];

     static int PolynomialDegreeFromFE2D[N_FEs2D];

     static int AccuracyFromFE2D[N_FEs2D];

     static TBaseFunct2D *BaseFunct2DFromFE2D[N_FEs2D];

     static NodalFunctional2D NodalFunctional2D_IDFromFE2D[N_FEs2D];

     static TNodalFunctional2D *NodalFunctional2DFromFE2D[N_FEs2D];

     static RefTrans2D RefTrans2D_IDFromFE2D[N_FEs2D];

     static BF2DRefElements RefElementFromFE2D[N_FEs2D];

//======================================================================
//      3D data
//======================================================================
    static TQuadFormula3D *QuadFormulas3D[N_QuadFormulas_3D];

//======================================================================
//      method only used by constructor
//======================================================================
  protected:
    static void RegisterAllQuadFormulas();

    static void RegisterAllFEDescs();

    static void RegisterAllBaseFunctions();

    static void RegisterAllNodalFunctionals();

    static void RegisterAllFEs();

    static void RegisterAllFEMappers();

    static void RegisterAllHangingNodes();

    static void RegisterAllRefTrans();

    static void GenerateArrays();

//======================================================================
//      constructor
//======================================================================
  public:
    TFEDatabase2D();

//======================================================================
//      FE1D
//======================================================================
    static TFE1D *GetFE1D (FE1D FE)
      { return FEs1D[FE]; };

    static void RegisterFE1D(FE1D FE, TFE1D *element)
     { FEs1D[FE] = element; };

//======================================================================
//      FEDesc1D
//======================================================================
    static TFEDesc1D *GetFEDesc1D(FEDesc1D FEDesc)
      { return FEDescs1D[FEDesc]; };

    static void RegisterFEDesc1D(FEDesc1D FEDesc, TFEDesc1D *FEDesc1D)
      { FEDescs1D[FEDesc] = FEDesc1D; };

//======================================================================
//      BaseFunct1D
//======================================================================
    static TBaseFunct1D *GetBaseFunct1D(BaseFunct1D BaseFunct)
      { return BaseFuncts1D[BaseFunct]; };

    static void RegisterBaseFunct1D(BaseFunct1D BaseFunct, 
                             TBaseFunct1D *BaseFunct1D)
      { BaseFuncts1D[BaseFunct] = BaseFunct1D; };

//======================================================================
//      NodalFunctional1D
//======================================================================
    static TNodalFunctional1D *GetNodalFunctional1D
        (NodalFunctional1D NodalFunctional)
      { return NodalFunctionals1D[NodalFunctional]; };

    static void RegisterNodalFunctional1D
                (NodalFunctional1D NodalFunctional,
                 TNodalFunctional1D *NodalFunctional1D)
     { NodalFunctionals1D[NodalFunctional] = NodalFunctional1D; };

//======================================================================
//      FE function values and derivatives 1D
//======================================================================
    static void RegisterRefElementValues
        (BaseFunct1D BaseFunct, QuadFormula1D QuadFormula,
         MultiIndex1D MultiIndex, double **Values)
    {
      RefElementValues1D[BaseFunct][QuadFormula][MultiIndex]
        = Values;
    }

    static double **GetRefElementValues
        (BaseFunct1D BaseFunct, QuadFormula1D QuadFormula,
         MultiIndex1D MultiIndex)
    {
      return RefElementValues1D[BaseFunct][QuadFormula][MultiIndex];
    }

    static void RegisterOrigElementValues
        (BaseFunct1D BaseFunct, MultiIndex1D MultiIndex, double **Values)
    {
      OrigElementValues1D[BaseFunct][MultiIndex] = Values;
    }

    static double **GetOrigElementValues
        (BaseFunct1D BaseFunct, MultiIndex1D MultiIndex)
    {
      return OrigElementValues1D[BaseFunct][MultiIndex];
    }

     static TRefTrans1D *GetRefTrans1D(RefTrans1D reftrans)
     {
       return ReferenceTrans1D[reftrans];
     }


//======================================================================
//      FEDesc2D
//======================================================================
    static TFEDesc2D *GetFEDesc2D(FEDesc2D FEDesc)
      { return FEDescs2D[FEDesc]; };

    static void RegisterFEDesc2D(FEDesc2D FEDesc, TFEDesc2D *FEDesc2D)
      { FEDescs2D[FEDesc] = FEDesc2D; };

//======================================================================
//      BaseFunct2D
//======================================================================
    static TBaseFunct2D *GetBaseFunct2D(BaseFunct2D BaseFunct)
      { return BaseFuncts2D[BaseFunct]; };

    static void RegisterBaseFunct2D(BaseFunct2D BaseFunct, 
                             TBaseFunct2D *BaseFunct2D)
      { BaseFuncts2D[BaseFunct] = BaseFunct2D; };

//======================================================================
//      NodalFunctional2D
//======================================================================
    static TNodalFunctional2D *GetNodalFunctional2D
        (NodalFunctional2D NodalFunctional)
      { return NodalFunctionals2D[NodalFunctional]; };

    static void RegisterNodalFunctional2D
                (NodalFunctional2D NodalFunctional,
                 TNodalFunctional2D *NodalFunctional2D)
     { NodalFunctionals2D[NodalFunctional] = NodalFunctional2D; };

//======================================================================
//      FE2D
//======================================================================
    static TFE2D *GetFE2D(FE2D FE)
      { return FEs2D[FE]; };

    static void RegisterFE2D(FE2D FE, TFE2D *element)
     { FEs2D[FE] = element; };

//======================================================================
//      access to some arrays
//======================================================================
    static FEDesc2D GetFEDesc2D_IDFromFE2D(FE2D ele)
      { return FEDesc2D_IDFromFE2D[ele]; };

    static TFEDesc2D *GetFEDesc2DFromFE2D(FE2D ele)
      { return FEDesc2DFromFE2D[ele]; };

    static BaseFunct2D GetBaseFunct2D_IDFromFE2D(FE2D ele)
      { return BaseFunct2D_IDFromFE2D[ele]; };

    static int GetN_BaseFunctFromFE2D(FE2D ele)
      { return N_BaseFunctFromFE2D[ele]; };

    static int GetPolynomialDegreeFromFE2D(FE2D ele)
      { return PolynomialDegreeFromFE2D[ele]; };

    static int GetAccuracyFromFE2D(FE2D ele)
      { return AccuracyFromFE2D[ele]; };

    static TBaseFunct2D *GetBaseFunct2DFromFE2D(FE2D ele)
      { return BaseFunct2DFromFE2D[ele]; };

    static NodalFunctional2D GetNodalFunctional2D_IDFromFE2D(FE2D ele)
      { return NodalFunctional2D_IDFromFE2D[ele]; };

    static TNodalFunctional2D *GetNodalFunctional2DFromFE2D(FE2D ele)
      { return NodalFunctional2DFromFE2D[ele]; };

    static RefTrans2D GetRefTrans2D_IDFromFE2D(FE2D ele)
      { return RefTrans2D_IDFromFE2D[ele]; };

    static BF2DRefElements GetRefElementFromFE2D(FE2D ele)
      { return RefElementFromFE2D[ele]; };


    static FEDesc2D *GetFEDesc2D_IDFromFE2D()
      { return FEDesc2D_IDFromFE2D; };

    static TFEDesc2D **GetFEDesc2DFromFE2D()
      { return FEDesc2DFromFE2D; };

    static BaseFunct2D *GetBaseFunct2D_IDFromFE2D()
      { return BaseFunct2D_IDFromFE2D; };

    static int *GetN_BaseFunctFromFE2D()
      { return N_BaseFunctFromFE2D; };

    static int *GetPolynomialDegreeFromFE2D()
      { return PolynomialDegreeFromFE2D; };

    static int *GetAccuracyFromFE2D()
      { return AccuracyFromFE2D; };

    static TBaseFunct2D **GetBaseFunct2DFromFE2D()
      { return BaseFunct2DFromFE2D; };

    static NodalFunctional2D *GetNodalFunctional2D_IDFromFE2D()
      { return NodalFunctional2D_IDFromFE2D; };

    static TNodalFunctional2D **GetNodalFunctional2DFromFE2D()
      { return NodalFunctional2DFromFE2D; };

    static RefTrans2D *GetRefTrans2D_IDFromFE2D()
      { return RefTrans2D_IDFromFE2D; };

    static BF2DRefElements *GetRefElementFromFE2D()
      { return RefElementFromFE2D; };

//======================================================================
//      prolongation matrices in 2D
//======================================================================
    static double *GetProlongationMatrix2D (FE2D parent, 
        Refinements refine, FE2D child, int childnumber);

    static void RegisterProlongationMatrix2D(BaseFunct2D parent, 
        Refinements refine, BaseFunct2D child, int childnumber, 
        double *matrix)
     { ProlongationMatrix2D[parent][refine][child][childnumber] = 
                matrix; };

//======================================================================
//      function restriction matrices in 2D
//======================================================================
    static double *GetRestrictionMatrix2D (FE2D parent, 
        Refinements refine, FE2D child, int childnumber);

    static void RegisterRestrictionMatrix2D(BaseFunct2D parent, 
        Refinements refine, BaseFunct2D child, int childnumber, 
        double *matrix)
     { RestrictionMatrix2D[parent][refine][child][childnumber] = 
                matrix; };

//======================================================================
//      FE mapper, regular
//======================================================================
    static TFE2DMapper *GetFE2DMapper(FEDesc2D FE1, FEDesc2D FE2)
      { return FE2DMapper[FE1][FE2]; };

    static void RegisterFE2DMapper(FEDesc2D FE1, FEDesc2D FE2, 
                                   TFE2DMapper *mapper)
     { FE2DMapper[FE1][FE2] = mapper; };

//======================================================================
//      FE mapper, one regular
//======================================================================
    static TFE2DMapper1Reg *GetFE2DMapper1Reg (FEDesc2D FE1, FEDesc2D FE2)
      { return FE2DMapper1Reg[FE1][FE2]; };

    static void RegisterFE2DMapper1Reg(FEDesc2D FE1, FEDesc2D FE2, 
                                   TFE2DMapper1Reg *mapper)
     { FE2DMapper1Reg[FE1][FE2] = mapper; };

//======================================================================
//      HNDesc
//======================================================================
    static THNDesc *GetHNDesc2D(HNDesc Desc)
      { return HNDescs2D[Desc]; };

    static void RegisterHNDesc2D(HNDesc Desc, THNDesc *HNDesc_Obj)
      { HNDescs2D[Desc] = HNDesc_Obj; };

//======================================================================
//      FE function values and derivatives 2D
//======================================================================
    static void RegisterRefElementValues
        (BaseFunct2D BaseFunct, QuadFormula2D QuadFormula,
         MultiIndex2D MultiIndex, double **Values)
    {
      RefElementValues2D[BaseFunct][QuadFormula][MultiIndex]
        = Values;
    }

    static double **GetRefElementValues
        (BaseFunct2D BaseFunct, QuadFormula2D QuadFormula,
         MultiIndex2D MultiIndex)
    {
      return RefElementValues2D[BaseFunct][QuadFormula][MultiIndex];
    }

    static void RegisterJointValues2D
        (BaseFunct2D BaseFunct, QuadFormula1D formula, int joint, 
         double **Values)
    {
      JointValues2D[BaseFunct][formula][joint] = Values;
    }

    static double **GetJointValues2D
        (BaseFunct2D BaseFunct, QuadFormula1D formula, int joint)
    {
      return JointValues2D[BaseFunct][formula][joint];
    }

    static void RegisterJointDerivatives2D
        (BaseFunct2D BaseFunct, QuadFormula1D formula, int joint, 
         MultiIndex2D MultiIndex, double **Values)
    {
      JointDerivatives2D[BaseFunct][formula][joint][MultiIndex] = Values;
    }

    static double **GetJointDerivatives2D
        (BaseFunct2D BaseFunct, QuadFormula1D formula, int joint,
        MultiIndex2D MultiIndex)
    {
      return JointDerivatives2D[BaseFunct][formula][joint][MultiIndex];
    }

    static void RegisterOrigElementValues
        (BaseFunct2D BaseFunct, MultiIndex2D MultiIndex, double **Values)
    {
      OrigElementValues2D[BaseFunct][MultiIndex] = Values;
    }

    static double **GetOrigElementValues
        (BaseFunct2D BaseFunct, MultiIndex2D MultiIndex)
    {
      return OrigElementValues2D[BaseFunct][MultiIndex];
    }

    /*
    static RefTrans2D GetOrigValues(TBaseCell *cell, TFE2D *element, 
                                    int N_Points, 
                                    double *xi, double *eta,
                                    int N_Functs,
                                    BaseFunct2D BaseFunct,
                                    QuadFormula2D QuadFormula);
    */

    static void GetOrigValues(RefTrans2D RefTrans,
                double xi, double eta, TBaseFunct2D *bf,
                TCollection *Coll, TGridCell *cell,
                double *uref, double *uxiref, double *uetaref,
                double *uorig, double *uxorig, double *uyorig);
    
    static void GetOrigValues(RefTrans2D RefTrans,
                              double zeta, TBaseFunct2D *bf, int edgeNumber,
                              double *uref, double *uxiref, double *uetaref,
                              double *uorig, double *uxorig, double *uyorig);

//======================================================================
//      reference transformation 2D
//======================================================================
     static TRefTrans2D *GetRefTrans2D(RefTrans2D reftrans)
     {
       return ReferenceTrans2D[reftrans];
     }

     static void GetOrigFromRef(RefTrans2D RefTrans, int n_points, 
                        double *xi, double *eta,
                        double *X, double *Y, double *absdetjk);

     static RefTrans2D GetOrig(int N_LocalUsedElements, FE2D *LocalUsedElements,
                         TCollection *Coll,
                         TBaseCell *cell, bool *Needs2ndDer,
                         int &N_Points, double* &xi, double* &eta, 
                         double* &weights, double* X, double* Y,
                         double* absdetjk);

     static void GetRefFromOrig(RefTrans2D RefTrans,
                        double X, double Y,
                        double &xi, double &eta);

     static void SetCellForRefTrans(TBaseCell *cell,
                                    RefTrans2D reftrans);

//======================================================================
//      QuadFormula1D
//======================================================================
     static TQuadFormula1D *GetQuadFormula1D(QuadFormula1D QF)
       { return QuadFormulas1D[QF]; };

     static void RegisterQuadFormula1D(QuadFormula1D QF,
                                 TQuadFormula1D *QuadForm)
       { QuadFormulas1D[QF] = QuadForm; };

    static QuadFormula1D GetQFLineFromDegree(int accuracy)
    {
      if(accuracy<=HighestAccuracyLine)
         return QFLineFromDegree[accuracy];
      else
        return QFLineFromDegree[HighestAccuracyLine];
    };

//======================================================================
//      QuadFormula2D
//======================================================================
     static TQuadFormula2D *GetQuadFormula2D(QuadFormula2D QF)
       { return QuadFormulas2D[QF]; };

     static void RegisterQuadFormula2D(QuadFormula2D QF,
                                 TQuadFormula2D *QuadForm)
       { QuadFormulas2D[QF] = QuadForm; };

    static QuadFormula2D GetQFTriaFromDegree(int accuracy)
    {
      if(accuracy<=HighestAccuracyTria)
         return QFTriaFromDegree[accuracy];
      else
        return QFTriaFromDegree[HighestAccuracyTria];
    };
    static QuadFormula2D GetQFQuadFromDegree(int accuracy)
    {
      if(accuracy<=HighestAccuracyQuad)
         return QFQuadFromDegree[accuracy];
      else
        return QFQuadFromDegree[HighestAccuracyQuad];
    };
    
    static QuadFormula2D GetQFFromDegree(int accuracy, BF2DRefElements RefElem);


//======================================================================
//      QuadFormula3D
//======================================================================
     static TQuadFormula3D *GetQuadFormula3D(QuadFormula3D QF)
       { return QuadFormulas3D[QF]; };

     static void RegisterQuadFormula3D(QuadFormula3D QF,
                                 TQuadFormula3D *QuadForm)
       { QuadFormulas3D[QF] = QuadForm; };
  
};

#endif