pzcreateapproxspace.h

Go to the documentation of this file.

#ifndef CREATECONTINUOUSHPP
#define CREATECONTINUOUSHPP

class TPZCompEl;
class TPZCompMesh;
class TPZGeoEl;
class TPZCompEl;
class TPZCompMesh;
#include <set>
#include "pzvec.h"
#include "TPZSavable.h"

typedef TPZCompEl *(*TCreateFunction)(TPZGeoEl *el,TPZCompMesh &mesh,int64_t &index);
/*
 * @brief Administer the creation of approximation spaces
 * @author Philippe Devloo
 * @since 2009
 * @ingroup interpolation
 */
class TPZCreateApproximationSpace : public TPZSavable {
    TPZCompEl *(*fp[8])(TPZGeoEl *el,TPZCompMesh &mesh,int64_t &index);
    

    bool fCreateHybridMesh;
    
    bool fCreateLagrangeMultiplier;
    
    bool fCreateWithMemory;

public:
    
    TPZCreateApproximationSpace() : fCreateHybridMesh(false), fCreateLagrangeMultiplier(false), fCreateWithMemory(false)
    {
        SetAllCreateFunctionsContinuous();
    }
    
    TPZCreateApproximationSpace(const TPZCreateApproximationSpace &copy) : fCreateHybridMesh(copy.fCreateHybridMesh), fCreateLagrangeMultiplier(copy.fCreateLagrangeMultiplier)
    ,fCreateWithMemory(copy.fCreateWithMemory)
    {
        for (int i=0; i<8; i++) {
            fp[i] = copy.fp[i];
        }
    }
    
    TPZCreateApproximationSpace &operator=(const TPZCreateApproximationSpace &copy)
    {
        for (int i=0; i<8; i++) {
            fp[i] = copy.fp[i];
        }
        fCreateHybridMesh = copy.fCreateHybridMesh;
        fCreateLagrangeMultiplier = copy.fCreateLagrangeMultiplier;
        fCreateWithMemory = copy.fCreateWithMemory;
        return *this;
    }
        int ClassId() const override;
    
    void Read(TPZStream &buf, void *context) override;
    
    void Write(TPZStream &buf, int withclassid) const override;
    
    void SetCreateLagrange(bool flag)
    {
        fCreateLagrangeMultiplier = flag;
    }
    
    void CreateWithMemory(bool flag)
    {
        fCreateWithMemory = flag;
    }
    
    void SetAllCreateFunctionsDiscontinuous();
                void SetAllCreateFunctionsContinuous();
                void SetAllCreateFunctionsDiscontinuousReferred();
                void SetAllCreateFunctionsContinuousReferred();
                void SetAllCreateFunctionsHDiv(int meshdim);
    void SetAllCreateFunctionsHDivReferred(int meshdim);
//    void SetAllCreateFunctionsHDivFull(int meshdim);
    
#if defined(USING_MKL) && defined(USING_LAPACK) && !defined(STATE_COMPLEX)

    void SetAllCreateFunctionsSBFem(int meshdim);
#endif

#ifndef STATE_COMPLEX

                void SetAllCreateFunctionsHDivPressure(int meshdim);
#endif

                void SetAllCreateFunctions(TPZCompEl &cel, TPZCompMesh *mesh);
                void SetAllCreateFunctionsMultiphysicElem();
                void SetAllCreateFunctionsMultiphysicElemWithMem();
    void SetAllCreateFunctionsContinuousWithMem();
    
    void SetCreateFunctions(TPZVec<TCreateFunction> &createfuncs);
    
    TPZCompEl *CreateCompEl(TPZGeoEl *gel, TPZCompMesh &mesh, int64_t &index) const;
    
                void BuildMesh(TPZCompMesh &cmesh, const std::set<int> &MaterialIDs) const;
                
                void BuildMesh(TPZCompMesh &cmesh) const;
    
    void BuildMesh(TPZCompMesh &cmesh, const TPZVec<int64_t> &gelindexes) const;
    
                static void CreateInterfaces(TPZCompMesh &cmesh, const std::set<int> &MaterialIDs);
                
                static void CreateInterfaces(TPZCompMesh &cmesh);

                static void AutoBuildContDisc(const TPZVec<TPZGeoEl*> &continuous, const TPZVec<TPZGeoEl*> &discontinuous);
    
    static void CondenseLocalEquations(TPZCompMesh &cmesh);
    
    static void UndoCondenseLocalEquations(TPZCompMesh &cmesh);
    
    static void MakeRaviartThomas(TPZCompMesh &cmesh);
    
    static void UndoMakeRaviartThomas(TPZCompMesh &cmesh);
    
    static void CreateInterfaceElements(TPZCompMesh *mesh, bool onlydiscontinuous = true, bool multiphysics = false);
    
    void CreateDisconnectedElements(bool create)
    {
        fCreateHybridMesh = create;
    }
    
    bool NeedsMemory()
    {
        return fCreateWithMemory;
    }
    
    static void Hybridize(TPZCompMesh &cmesh,const std::set<int> &matids, bool isconnectedElem = false);
};

#endif