pzcmesh.h

Go to the documentation of this file.

#ifndef PZCMESHHPP
#define PZCMESHHPP


#include <stddef.h>               // for NULL
#include <iostream>               // for operator<<, string, cout, ostream
#include <map>                    // for map
#include <set>                    // for set
#include "pzadmchunk.h"           // for TPZAdmChunkVector
#include "pzblock.h"              // for TPZBlock
#include "TPZChunkVector.h"              // for TPZChunkVector
#include "pzconnect.h"            // for TPZConnect
#include "pzcreateapproxspace.h"  // for TPZCreateApproximationSpace
#include "pzgmesh.h"              // for TPZGeoMesh
#include "pzmatrix.h"             // for TPZFMatrix, TPZMatrix
#include "pzreal.h"               // for STATE, REAL
#include "TPZSavable.h"          // for TPZSavable
#include "pzstack.h"              // for TPZStack
#include "pzvec.h"                // for TPZVec
#include "tpzautopointer.h"       // for TPZAutoPointer
#include "pzcheckgeom.h"                          // for TPZCheckGeom
#include <functional>
#include "pzcompel.h"

class TPZGeoEl;
class TPZMaterial;
class TPZStream;
template <class TVar> class TPZTransfer;


class TPZCompMesh : public virtual TPZSavable {
                
protected:
                TPZGeoMesh      *fReference;
    
    TPZAutoPointer<TPZGeoMesh> fGMesh;
                
                std::string fName;
                
                TPZAdmChunkVector<TPZCompEl *>                  fElementVec;    
                TPZAdmChunkVector<TPZConnect>                                   fConnectVec;
                
                std::map<int, TPZMaterial * >   fMaterialVec;
                //TPZBlock<REAL>                                fSolutionBlock;
                TPZBlock<STATE>                 fSolutionBlock;
                
                //TPZFMatrix<REAL>              fSolution;
                TPZFMatrix<STATE>               fSolution;
    
    TPZFMatrix<STATE>  fSolN;
                
                //TPZBlock<REAL>                                fBlock;
                TPZBlock<STATE>                 fBlock;
                
                TPZFMatrix<STATE> fElementSolution;
                
                /* @brief set the dimension of the simulation or the model */
                int fDimModel;
                
                int fDefaultOrder;
    
    TPZCreateApproximationSpace fCreate;
    
    void ModifyPermute(TPZVec<int64_t> &permute, int64_t lagrangeq, int64_t maxeq);
    
    //quantity of meshes associated with a mesh multiphysics
                int64_t fNmeshes;

public:
                
                TPZCompMesh(TPZGeoMesh* gr=0);
    TPZCompMesh(TPZAutoPointer<TPZGeoMesh> &gmesh);
                TPZCompMesh(const TPZCompMesh &copy);
    TPZCompMesh &operator=(const TPZCompMesh &copy);
                
                virtual ~TPZCompMesh();
                
                virtual REAL CompareMesh(int var, char *matname);
                void GetRefPatches(std::set<TPZGeoEl *> &grpatch);
                void GetNodeToElGraph(TPZVec<int64_t> &nodtoelgraph, TPZVec<int64_t> &nodtoelgraphinde,TPZStack<int64_t> &elgraph, TPZVec<int64_t> &elgraphindexx);
                
                void GetElementPatch(TPZVec<int64_t> nodtoelgraph, TPZVec<int64_t> nodtoelgraphindex, TPZStack<int64_t> &elgraph, TPZVec<int64_t> &elgraphindex,int64_t elind ,TPZStack<int64_t> &patch);
                
                void SetName(const std::string &nm);
                
                void SetDimModel(int dim) { fDimModel = dim; }
                
                void SetReference(TPZGeoMesh * gmesh);
                
    void SetReference(TPZAutoPointer<TPZGeoMesh> &gmesh);
    
                int Dimension() const {return fDimModel;}

                std::string &Name() {return fName;}
                
                void CleanUp();
                
                int64_t NConnects() const {return fConnectVec.NElements();}
                
                int64_t NIndependentConnects();
                
                int64_t NElements() const {return fElementVec.NElements();}
                
                size_t NMaterials() const {return fMaterialVec.size();}
                
                
                TPZAdmChunkVector<TPZCompEl *>   &ElementVec() { return fElementVec; }
    
    TPZCompEl * Element(int64_t iel)
    {
        return fElementVec[iel];
    }

    const TPZCompEl * Element(int64_t iel) const {
        return fElementVec[iel];
    }
                
                const TPZAdmChunkVector<TPZCompEl *>   &ElementVec() const { return fElementVec; }
                
                TPZAdmChunkVector<TPZConnect>    &ConnectVec() { return fConnectVec; }
    
                const TPZAdmChunkVector<TPZConnect> &ConnectVec() const { return fConnectVec; }
                
                std::map<int ,TPZMaterial * >   &MaterialVec() { return fMaterialVec; }

    std::map<int ,TPZMaterial * >   MaterialVec() const { return fMaterialVec; }
    
                TPZGeoMesh *Reference() const { return fReference; }
                
                //const TPZBlock<REAL> &Block() const { return fBlock;}
                const TPZBlock<STATE> &Block() const { return fBlock;}
                
                TPZBlock<STATE> &Block() { return fBlock;}
                
                TPZFMatrix<STATE> &Solution(){ return fSolution;}
    
    TPZFMatrix<STATE> &SolutionN(){ return fSolN;}
                
                TPZFMatrix<STATE> &ElementSolution() { return fElementSolution;}
                
                virtual  int64_t AllocateNewConnect(int nshape, int nstate, int order);
                
                virtual  int64_t AllocateNewConnect(const TPZConnect &connect);
                
                int InsertMaterialObject(TPZMaterial * mat);
                
                void InitializeBlock();
                
                virtual void ExpandSolution();
                
                void SetElementSolution(int64_t i, TPZVec<STATE> &sol);
                
                virtual void Print(std::ostream & out = std::cout) const;
                
                void ConnectSolution(std::ostream & out);

                TPZMaterial * FindMaterial(int id);
                
                void LoadReferences();
                
                virtual void ComputeNodElCon();
                
                virtual void ComputeNodElCon(TPZVec<int> &nelconnected) const;
                
                virtual void CleanUpUnconnectedNodes();

                void ComputeElGraph(TPZStack<int64_t> &elgraph, TPZVec<int64_t> &elgraphindex);
    
    void ComputeElGraph(TPZStack<int64_t> &elgraph, TPZVec<int64_t> &elgraphindex, std::set<int> & mat_ids);

    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const;
    

                virtual TPZCompMesh *FatherMesh() const { return NULL; }
                
                virtual void MakeInternal(int64_t local) {;}
                
                virtual void MakeAllInternal() {;}
                
                virtual TPZCompMesh* RootMesh (int64_t local) { return this; }
                
                virtual int64_t TransferElementFrom(TPZCompMesh *mesh, int64_t elindex) { return elindex; }
                
                virtual int64_t TransferElementTo(TPZCompMesh *mesh, int64_t elindex) { return elindex; }
                
                virtual int64_t TransferElement(TPZCompMesh *mesh, int64_t elindex) { return elindex; }
                
                virtual int64_t PutinSuperMesh (int64_t local, TPZCompMesh *super);
                
                virtual int64_t GetFromSuperMesh (int64_t superind, TPZCompMesh *super);
    
                virtual TPZCompMesh * CommonMesh (TPZCompMesh *mesh);
                


                int GetDefaultOrder()
                {
                                return fDefaultOrder;
                }
                
                void SetDefaultOrder( int order )
                {
                                fDefaultOrder = order;
                }

                int64_t NEquations();
                
                int BandWidth();
                
                virtual void Skyline(TPZVec<int64_t> &skyline);
                
                void AssembleError(TPZFMatrix<REAL> &estimator, int errorid);
                
                void BuildTransferMatrix(TPZCompMesh &coarsemesh, TPZTransfer<STATE> &transfer);
                
                void BuildTransferMatrixDesc(TPZCompMesh &transfermesh,TPZTransfer<STATE> &transfer);
                void ProjectSolution(TPZFMatrix<STATE> &projectsol);
    
    //set nummber of meshs
    void SetNMeshes(int64_t nmeshes){
        fNmeshes = nmeshes;
    }
    
    int64_t GetNMeshes(){
        return fNmeshes;
    }
                
private:
                
                virtual void AutoBuild(const std::set<int> *MaterialIDs);
                
public:
                
    TPZCompEl *CreateCompEl(TPZGeoEl *gel, int64_t &index)
    {
        return fCreate.CreateCompEl(gel, *this, index);
    }
    
                virtual void AutoBuild(const std::set<int> &MaterialIDs){
                                fCreate.BuildMesh(*this,MaterialIDs);
                }
                
                virtual void AutoBuild(){
#ifdef PZDEBUG
        {
            TPZGeoMesh *gmesh = Reference();
            TPZCheckGeom check(gmesh);
            check.CheckUniqueId();
        }
#endif
                                fCreate.BuildMesh(*this);
                }
    
    void AutoBuild(const TPZVec<int64_t> &gelindexes)
    {
        fCreate.BuildMesh(*this,gelindexes);
    }
                                
                virtual void AutoBuildContDisc(const TPZVec<TPZGeoEl*> &continuous, const TPZVec<TPZGeoEl*> &discontinuous);
    
    TPZCreateApproximationSpace &ApproxSpace()
    {
        return fCreate;
    }
                
    void SetAllCreateFunctionsDiscontinuous()
    {
        fCreate.SetAllCreateFunctionsDiscontinuous();
    }
    
    void SetAllCreateFunctionsContinuous()
    {
        fCreate.SetAllCreateFunctionsContinuous();
    }
    
    void SetAllCreateFunctionsDiscontinuousReferred()
    {
        fCreate.SetAllCreateFunctionsDiscontinuousReferred();
    }
    
    void SetAllCreateFunctionsContinuousReferred()
    {
        fCreate.SetAllCreateFunctionsContinuousReferred();
    }
    
    void SetAllCreateFunctionsHDiv()
    {
        fCreate.SetAllCreateFunctionsHDiv(Dimension());
    }
                
                

#ifndef STATE_COMPLEX
    void SetAllCreateFunctionsHDivPressure()
    {
        fCreate.SetAllCreateFunctionsHDivPressure(Dimension());
    }
#endif
    
    void SetAllCreateFunctions(TPZCompEl &cel)
    {
        fCreate.SetAllCreateFunctions(cel, this);
    }

    void SetAllCreateFunctionsMultiphysicElem()
    {
        fCreate.SetAllCreateFunctionsMultiphysicElem();
    }

    void SetAllCreateFunctionsMultiphysicElemWithMem()
    {
        fCreate.SetAllCreateFunctionsMultiphysicElemWithMem();
    }
                
    void SetAllCreateFunctionsContinuousWithMem()
    {
        fCreate.SetAllCreateFunctionsContinuousWithMem();
    }
                                
                int Consolidate();
                
                int Check();

                void LoadSolution(const TPZFMatrix<STATE> &sol);
    
    void UpdatePreviousState(STATE mult = 1.0);
    
    void TransferMultiphysicsSolution();
                
                void Divide(int64_t index,TPZVec<int64_t> &subindex,int interpolate = 0);
                
                void Coarsen(TPZVec<int64_t> &elements, int64_t &index, bool CreateDiscontinuous = false);
                
                void RemakeAllInterfaceElements();
                
                void AdjustBoundaryElements();
                
                void Permute(TPZVec<int64_t> &permute);
    
    void SaddlePermute();
    void SaddlePermute2();

    /*
     * @param varname name of the variable that will be integrated
     * @param matids ids of the materials that will contribute to the integral
     */
    TPZVec<STATE> Integrate(const std::string &varname, const std::set<int> &matids);

                
    void EvaluateError(std::function<void (const TPZVec<REAL> &loc,TPZVec<STATE> &val,TPZFMatrix<STATE> &deriv)> fp, bool store_error,
                                                                                   TPZVec<REAL> &errorSum);
                
                void ConvertDiscontinuous2Continuous(REAL eps, int opt, int dim, TPZVec<STATE> &celJumps);
                
                void Discontinuous2Continuous(int64_t disc_index, int64_t &new_index);
                
                TPZCompMesh * Clone() const;
                
                void CopyMaterials(TPZCompMesh &mesh) const ;
                
                REAL DeltaX();
                
                REAL MaximumRadiusOfMesh();
                
                REAL LesserEdgeOfMesh();
                
                TPZCompMesh *ComputeMesh(TPZVec<int64_t> &accumlist,int64_t numaggl);
                
                void ComputeFillIn(int64_t resolution, TPZFMatrix<REAL> &fillin);
                
                public:
int ClassId() const override;

                void Write(TPZStream &buf, int withclassid) const override;
                
                void Read(TPZStream &buf, void *context) override;

};

inline int64_t TPZCompMesh::AllocateNewConnect(int nshape, int nstate, int order) {
                int64_t connectindex = fConnectVec.AllocateNewElement();
    TPZConnect &c = fConnectVec[connectindex];
    c.SetNShape(nshape);
    c.SetNState(nstate);
    c.SetOrder(order,connectindex);
    c.SetLagrangeMultiplier(0);
                int64_t blocknum = fBlock.NBlocks();
                fBlock.SetNBlocks(blocknum+1);
                fBlock.Set(blocknum,nshape*nstate);
                c.SetSequenceNumber(blocknum);
                return connectindex;
}

inline int64_t TPZCompMesh::AllocateNewConnect(const TPZConnect &connect)
{
                int64_t connectindex = fConnectVec.AllocateNewElement();
    TPZConnect &c = fConnectVec[connectindex];
    c = connect;
    c.RemoveDepend();
    int nshape = c.NShape();
    int nstate = c.NState();
                int64_t blocknum = fBlock.NBlocks();
                fBlock.SetNBlocks(blocknum+1);
                fBlock.Set(blocknum,nshape*nstate);
                c.SetSequenceNumber(blocknum);
                return connectindex;
}


inline void TPZCompMesh::SetReference(TPZGeoMesh * gmesh){
                this->fReference = gmesh;
    this->fDimModel = gmesh->Dimension();
    fGMesh = TPZAutoPointer<TPZGeoMesh>(0);
}

inline void TPZCompMesh::SetReference(TPZAutoPointer<TPZGeoMesh> & gmesh){
    this->fReference = gmesh.operator->();
    this->fDimModel = gmesh->Dimension();
    fGMesh = gmesh;
}

#endif