FEDatabase3D.h

// =======================================================================
// %W% %G% 
//
// Class:       TFEDatabase3D
// Purpose:     store all used information for a FEM for 3D
//
// Author:      Gunar Matthies  26.11.99
//
// =======================================================================

#ifndef __FEDATABASE3D__
#define __FEDATABASE3D__

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

#include <BaseFunct3D.h>
#include <FEDesc3D.h>
#include <FE3D.h>
#include <FE3DMapper1Reg.h>

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

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

    static QuadFormula1D QFLineFromDegree[MAXDEGREE];

    static int HighestAccuracyLine;

//======================================================================
//      2D arrays for easier access of information
//======================================================================
    static TQuadFormula2D *QuadFormulas2D[N_QuadFormulas_2D];

    static QuadFormula2D QFTriaFromDegree[MAXDEGREE];

    static QuadFormula2D QFQuadFromDegree[MAXDEGREE];

//======================================================================
//      3D arrays for easier access of information
//======================================================================
     static QuadFormula3D QFTetraFromDegree[MAXDEGREE];

     static QuadFormula3D QFHexaFromDegree[MAXDEGREE];

     static QuadFormula3D QFConvolutionHexaFromDegree[MAXDEGREE];

     static FEDesc3D FEDesc3D_IDFromFE3D[N_FEs3D];

     static TFEDesc3D *FEDesc3DFromFE3D[N_FEs3D];

     static BaseFunct3D BaseFunct3D_IDFromFE3D[N_FEs3D];

     static int N_BaseFunctFromFE3D[N_FEs3D];

     static int PolynomialDegreeFromFE3D[N_FEs3D];

     static int AccuracyFromFE3D[N_FEs3D];

     static TBaseFunct3D *BaseFunct3DFromFE3D[N_FEs3D];

     static NodalFunctional3D NodalFunctional3D_IDFromFE3D[N_FEs3D];

     static TNodalFunctional3D *NodalFunctional3DFromFE3D[N_FEs3D];

     static RefTrans3D RefTrans3D_IDFromFE3D[N_FEs3D];

     static BF3DRefElements RefElementFromFE3D[N_FEs3D];

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

    static TFE3D *FEs3D[N_FEs3D];

    static TFEDesc3D *FEDescs3D[N_FEDescs3D];

    static TBaseFunct3D *BaseFuncts3D[N_BaseFuncts3D];

    static TNodalFunctional3D *NodalFunctionals3D[N_NodalFunctionals3D];

    static TFE3DMapper *FE3DMapper[N_FEDescs3D][N_FEDescs3D];

    static TFE3DMapper1Reg *FE3DMapper1Reg[N_FEDescs3D][N_FEDescs3D];

    static THNDesc *HNDescs3D[N_HNDescs];

    static TRefTrans3D *ReferenceTrans3D[N_RefTrans3D];

    static double *ProlongationMatrix3D[MaxN_BaseFunctions3D]
        [N_REFDESC][MaxN_BaseFunctions3D][MAXN_CHILDREN];

    static double *RestrictionMatrix3D[MaxN_BaseFunctions3D]
        [N_REFDESC][MaxN_BaseFunctions3D][MAXN_CHILDREN];

//======================================================================
//      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();

    static double **RefElementValues3D[N_BaseFuncts3D][N_QuadFormulas_3D]
      [N_MultiIndices3D];
    
    static double **JointValues3D[N_BaseFuncts3D][N_QuadFormulas_2D]
      [MAXN_JOINTS];

    static double **JointDerivatives3D[N_BaseFuncts3D][N_QuadFormulas_2D]
    [MAXN_JOINTS][N_MultiIndices3D];

    static double **OrigElementValues3D[N_BaseFuncts3D][N_MultiIndices3D];


//======================================================================
//      constructor
//======================================================================
  public:
    TFEDatabase3D();
//======================================================================
//      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)
       { return QFTriaFromDegree[accuracy]; };

    static QuadFormula2D GetQFQuadFromDegree(int accuracy)
       { return QFQuadFromDegree[accuracy]; };

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

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

     static QuadFormula3D GetQFTetraFromDegree(int accuracy)
       { return QFTetraFromDegree[accuracy]; };
     
     static QuadFormula3D GetQFHexaFromDegree(int accuracy)
       { return QFHexaFromDegree[accuracy]; };   

     static QuadFormula3D GetQFConvolutionHexaFromDegree(int accuracy)
       { return QFConvolutionHexaFromDegree[accuracy]; };   

//======================================================================
//      FEDesc3D
//======================================================================
    static TFEDesc3D *GetFEDesc3D(FEDesc3D FEDesc)
      { return FEDescs3D[FEDesc]; };

    static void RegisterFEDesc3D(FEDesc3D FEDesc, TFEDesc3D *FEDesc3D)
      { FEDescs3D[FEDesc] = FEDesc3D; };

//======================================================================
//      BaseFunct3D
//======================================================================
    static TBaseFunct3D *GetBaseFunct3D(BaseFunct3D BaseFunct)
      { return BaseFuncts3D[BaseFunct]; };

    static void RegisterBaseFunct3D(BaseFunct3D BaseFunct, 
                             TBaseFunct3D *BaseFunct3D)
      { BaseFuncts3D[BaseFunct] = BaseFunct3D; };

//======================================================================
//      NodalFunctional3D
//======================================================================
    static TNodalFunctional3D *GetNodalFunctional3D
        (NodalFunctional3D NodalFunctional)
      { return NodalFunctionals3D[NodalFunctional]; };

    static void RegisterNodalFunctional3D
                (NodalFunctional3D NodalFunctional,
                 TNodalFunctional3D *NodalFunctional3D)
     { NodalFunctionals3D[NodalFunctional] = NodalFunctional3D; };

//======================================================================
//      FE3D
//======================================================================
    static TFE3D *GetFE3D (FE3D FE)
      { return FEs3D[FE]; };

    static void RegisterFE3D(FE3D FE, TFE3D *element)
     { FEs3D[FE] = element; };

//======================================================================
//      access to some arrays
//======================================================================
    static FEDesc3D GetFEDesc3D_IDFromFE3D(FE3D ele)
      { return FEDesc3D_IDFromFE3D[ele]; };

    static TFEDesc3D *GetFEDesc3DFromFE3D(FE3D ele)
      { return FEDesc3DFromFE3D[ele]; };

    static BaseFunct3D GetBaseFunct3D_IDFromFE3D(FE3D ele)
      { return BaseFunct3D_IDFromFE3D[ele]; };

    static int GetN_BaseFunctFromFE3D(FE3D ele)
      { return N_BaseFunctFromFE3D[ele]; };

    static int GetPolynomialDegreeFromFE3D(FE3D ele)
      { return PolynomialDegreeFromFE3D[ele]; };

    static int GetAccuracyFromFE3D(FE3D ele)
      { return AccuracyFromFE3D[ele]; };

    static TBaseFunct3D *GetBaseFunct3DFromFE3D(FE3D ele)
      { return BaseFunct3DFromFE3D[ele]; };

    static NodalFunctional3D GetNodalFunctional3D_IDFromFE3D(FE3D ele)
      { return NodalFunctional3D_IDFromFE3D[ele]; };

    static TNodalFunctional3D *GetNodalFunctional3DFromFE3D(FE3D ele)
      { return NodalFunctional3DFromFE3D[ele]; };

    static RefTrans3D GetRefTrans3D_IDFromFE3D(FE3D ele)
      { return RefTrans3D_IDFromFE3D[ele]; };

    static BF3DRefElements GetRefElementFromFE3D(FE3D ele)
      { return RefElementFromFE3D[ele]; };


    static FEDesc3D *GetFEDesc3D_IDFromFE3D()
      { return FEDesc3D_IDFromFE3D; };

    static TFEDesc3D **GetFEDesc3DFromFE3D()
      { return FEDesc3DFromFE3D; };

    static BaseFunct3D *GetBaseFunct3D_IDFromFE3D()
      { return BaseFunct3D_IDFromFE3D; };

    static int *GetN_BaseFunctFromFE3D()
      { return N_BaseFunctFromFE3D; };

    static int *GetPolynomialDegreeFromFE3D()
      { return PolynomialDegreeFromFE3D; };

    static int *GetAccuracyFromFE3D()
      { return AccuracyFromFE3D; };

    static TBaseFunct3D **GetBaseFunct3DFromFE3D()
      { return BaseFunct3DFromFE3D; };

    static NodalFunctional3D *GetNodalFunctional3D_IDFromFE3D()
      { return NodalFunctional3D_IDFromFE3D; };

    static TNodalFunctional3D **GetNodalFunctional3DFromFE3D()
      { return NodalFunctional3DFromFE3D; };

    static RefTrans3D *GetRefTrans3D_IDFromFE3D()
      { return RefTrans3D_IDFromFE3D; };

    static BF3DRefElements *GetRefElementFromFE3D()
      { return RefElementFromFE3D; };

//======================================================================
//      prolongation matrices in 3D
//======================================================================
    static double *GetProlongationMatrix3D (FE3D parent, 
        Refinements refine, FE3D child, int childnumber);

    static void RegisterProlongationMatrix3D(BaseFunct3D parent, 
        Refinements refine, BaseFunct3D child, int childnumber, 
        double *matrix)
     { ProlongationMatrix3D[parent][refine][child][childnumber] = 
                matrix; };

//======================================================================
//      function restriction matrices in 3D
//======================================================================
    static double *GetRestrictionMatrix3D (FE3D parent, 
        Refinements refine, FE3D child, int childnumber);

    static void RegisterRestrictionMatrix3D(BaseFunct3D parent, 
        Refinements refine, BaseFunct3D child, int childnumber, 
        double *matrix)
     { RestrictionMatrix3D[parent][refine][child][childnumber] = 
                matrix; };

//======================================================================
//      FE mapper 3D, regular
//======================================================================
    static TFE3DMapper *GetFE3DMapper (FEDesc3D FE1, FEDesc3D FE2)
      { return FE3DMapper[FE1][FE2]; };

    static void RegisterFE3DMapper(FEDesc3D FE1, FEDesc3D FE2, 
                                   TFE3DMapper *mapper)
     { FE3DMapper[FE1][FE2] = mapper; };

//======================================================================
//      FE mapper 3D, 1-regular
//======================================================================
    static TFE3DMapper1Reg *GetFE3DMapper1Reg (FEDesc3D FE1, FEDesc3D FE2)
      { return FE3DMapper1Reg[FE1][FE2]; };

    static void RegisterFE3DMapper1Reg(FEDesc3D FE1, FEDesc3D FE2, 
                                       TFE3DMapper1Reg *mapper)
     { FE3DMapper1Reg[FE1][FE2] = mapper; };

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

//======================================================================
//      HNDesc
//======================================================================
    static THNDesc *GetHNDesc3D(HNDesc Desc)
      { return HNDescs3D[Desc]; }

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

//======================================================================
//      reference transformation 3D
//======================================================================
     static TRefTrans3D *GetRefTrans3D(RefTrans3D reftrans)
     {
       return ReferenceTrans3D[reftrans];
     }

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

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

     static void GetRefFromOrig(RefTrans3D RefTrans,
                        double X, double Y, double Z,
                        double &xi, double &eta, double &zeta);

//======================================================================
//      FE function values and derivatives 3D
//======================================================================
    static void RegisterRefElementValues
        (BaseFunct3D BaseFunct, QuadFormula3D QuadFormula,
         MultiIndex3D MultiIndex, double **Values)
    {
      RefElementValues3D[BaseFunct][QuadFormula][MultiIndex]
        = Values;
    }

    static double **GetRefElementValues
        (BaseFunct3D BaseFunct, QuadFormula3D QuadFormula,
         MultiIndex3D MultiIndex)
    {
      return RefElementValues3D[BaseFunct][QuadFormula][MultiIndex];
    }

    static void RegisterJointValues3D
        (BaseFunct3D BaseFunct, QuadFormula2D formula, int joint, 
         double **Values)
    {
      JointValues3D[BaseFunct][formula][joint] = Values;
    }

    static double **GetJointValues3D
        (BaseFunct3D BaseFunct, QuadFormula2D formula, int joint)
    {
      return JointValues3D[BaseFunct][formula][joint];
    }

    static void RegisterJointDerivatives3D
        (BaseFunct3D BaseFunct, QuadFormula2D formula, int joint, 
         MultiIndex3D MultiIndex, double **Values)
    {
      JointDerivatives3D[BaseFunct][formula][joint][MultiIndex] = Values;
    }

    static double **GetJointDerivatives3D
        (BaseFunct3D BaseFunct, QuadFormula2D formula, int joint,
        MultiIndex3D MultiIndex)
    {
      return JointDerivatives3D[BaseFunct][formula][joint][MultiIndex];
    }

    static void RegisterOrigElementValues
        (BaseFunct3D BaseFunct, MultiIndex3D MultiIndex, double **Values)
    {
      OrigElementValues3D[BaseFunct][MultiIndex] = Values;
    }

    static double **GetOrigElementValues
        (BaseFunct3D BaseFunct, MultiIndex3D MultiIndex)
    {
      return OrigElementValues3D[BaseFunct][MultiIndex];
    }

    static RefTrans3D GetOrigValues(TBaseCell *cell, TFE3D *element, 
                                    int N_Points, 
                                    double *xi, double *eta, double *zeta,
                                    int N_Functs,
                                    BaseFunct3D BaseFunct,
                                    QuadFormula3D QuadFormula);

    static void GetOrigValues(RefTrans3D RefTrans,
                double xi, double eta, double zeta,
                TBaseFunct3D *bf, TCollection *Coll, TBaseCell *cell,
                double *uref, double *uxiref, double *uetaref, double *uzetaref,
                double *uorig, double *uxorig, double *uyorig, double *uzorig);

};

#endif