Helper.hpp

#ifndef Helper_hpp
#define Helper_hpp
 
#include <iostream>
#include <sstream>
#include <iomanip>
 
//#include "AssembleFE_decl.hpp"
#include "feddlib/core/FEDDCore.hpp"
#include "feddlib/core/LinearAlgebra/Matrix.hpp"
#include "feddlib/core/General/SmallMatrix.hpp"
 
namespace FEDD {

class Helper {
 
public:
    typedef double SC; // TODO: [JK] Does this not clash with the default definition in DefaultTypeDefs.hpp, which is used elsewhere?

    enum VarType {
        Deriv0 = 0, 
        Deriv1 = 1  
    };

    static void computeSurfaceNormal(int dim,
                                     vec2D_dbl_ptr_Type pointsRep,
                                     vec_int_Type nodeList,
                                     vec_dbl_Type &v_E,
                                     double &norm_v_E);
 

    static void buildTransformation(const vec_int_Type& element,
                             vec2D_dbl_ptr_Type pointsRep,
                             SmallMatrix<SC>& B,
                             std::string FEType="P");

    static void buildTransformation(const vec_int_Type& element,
                             vec2D_dbl_ptr_Type pointsRep,
                             SmallMatrix<SC>& B,
                             vec_dbl_Type& b,
                             std::string FEType="P");
 

    static void buildTransformationSurface(const vec_int_Type& element,
                                    vec2D_dbl_ptr_Type pointsRep,
                                    SmallMatrix<SC>& B,
                                    vec_dbl_Type& b,
                                    std::string FEType="P");

    static void gradPhi(int Dimension,
                    int intFE,
                    int i,
                    vec_dbl_Type &QuadPts,
                    vec_dbl_ptr_Type &value);
    
    static void getQuadratureValues(int Dimension,
                            int Degree,
                            vec2D_dbl_ptr_Type &QuadPts,
                            vec_dbl_ptr_Type &QuadW,
                            std::string FEType);

    static vec2D_dbl_Type getQuadratureValuesOnSurface(int dim,
                                                       std::string FEType,
                                                       vec_dbl_Type &QuadW,
                                                       vec_LO_Type surfaceIDs,
                                                       vec2D_dbl_ptr_Type points);
    
    static int getDPhi(  vec3D_dbl_ptr_Type &DPhi,
                    vec_dbl_ptr_Type &weightsDPhi,
                    int Dimension,
                    std::string FEType,
                    int Degree);
 
    //  @brief Natalie new function to get viscosity at center of mass
    static void getDPhiAtCM(vec3D_dbl_ptr_Type &DPhi,
                            int dim,
                            std::string FEType);
 

    static void applyBTinv( vec3D_dbl_ptr_Type& dPhiIn,
                    vec3D_dbl_Type& dPhiOut,
                    const SmallMatrix<SC>& Binv);
 

    static UN determineDegree(UN dim,
                              std::string FEType,
                              VarType orderOfDerivative);
                       

    static int getPhi(vec2D_dbl_ptr_Type &Phi,
                            vec_dbl_ptr_Type &weightsPhi,
                            int dim,
                            std::string FEType,
                            int Degree,
                            std::string FETypeQuadPoints="");
 
    static int getFuncAtQuadNodes(vec_dbl_ptr_Type &funcVals, RhsFunc_Type &rhsFunc, int dim, std::string FEType,
                                  int Degree, std::string FETypeQuadPoints = "");

    static void phi(int dim, int intFE, int i, vec_dbl_Type &p, double *value);
 
    static int getPhiGlobal(vec2D_dbl_ptr_Type &Phi,
                            vec_dbl_ptr_Type &weightsPhi,
                            int dim,
                            std::string FEType,
                            int Degree)
    { TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "getPhiGlobal not implemented yet.");};
 
 
private:
    
    Helper(){};

    static UN requiredQuadratureDegreeForBasisfunction(UN dim, std::string FEType);

    static UN requiredQuadratureDegreeForGradientOfBasisfunction(UN dim, std::string FEType);
 
};
}
#endif