pzsubcmesh.h

Go to the documentation of this file.

#ifndef SUBCMESH_H
#define SUBCMESH_H

#if _MSC_VER > 1000
#pragma once
#endif

#include <stdlib.h>

#include "pzcompel.h"
#include "pzcmesh.h"
#include "pzvec.h"
#include "pzreal.h"
#include "pzanalysis.h"

#include <list>

class TPZSubMeshFrontalAnalysis;
class TPZSubMeshAnalysis;
class TPZAnalysis;
class TPZGuiInterface;

class TPZSubCompMesh :
public TPZCompMesh,
public TPZCompEl
{
protected:
                TPZAutoPointer<TPZAnalysis> fAnalysis;
                
                TPZManVector<int64_t> fConnectIndex;
                
                TPZManVector<int64_t> fExternalLocIndex;
                std::map<int64_t,int64_t> fFatherToLocal;
    
    int64_t fSingularConnect;
    
    std::list<std::pair<int64_t,int> > fLagrangeEquations;
                
private:
                int64_t TransferElementTo(TPZCompMesh * mesh, int64_t elindex) override;
                int64_t TransferElementFrom(TPZCompMesh *mesh, int64_t elindex) override;
                
                void MakeInternalFast(int64_t local);
    
                void TransferDependencies(int64_t local);
                
public:
                TPZSubCompMesh(TPZCompMesh &mesh, int64_t &index);
                TPZSubCompMesh();
                virtual ~TPZSubCompMesh();
                
                virtual int NConnectShapeF(int inod, int order){
                                PZError << "\nPLEASE IMPLEMENT ME: " << __PRETTY_FUNCTION__ << "\n";
                                return 0;
                }
                
                virtual TPZCompEl *Clone(TPZCompMesh &mesh) const  override {
                                std::cout << "TPZSubCompMesh::Clone should be implemented\n";
                                return 0;
                }
                
                virtual TPZCompEl *ClonePatchEl(TPZCompMesh &mesh,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcConMap,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap) const  override
                {
                                std::cout << "TPZSubCompMesh::Clone should be implemented\n";
                                return 0;
                }
                
                void SetAnalysisFrontal(int numThreads, TPZAutoPointer<TPZGuiInterface> guiInterface);
    
                void SetAnalysisSkyline(int numThreads, int preconditioned, TPZAutoPointer<TPZGuiInterface> guiInterface);
                
    void SetAnalysisSkyline(int numThreads, int preconditioned, TPZAutoPointer<TPZRenumbering> renumber);
    
                TPZAutoPointer<TPZAnalysis> Analysis()
                {
                                return fAnalysis;
                }
                
                virtual void LoadElementReference() override;
                
                virtual REAL CompareElement(int var, char *matname) override;
                
                int IsAllowedElement(TPZCompMesh *mesh, int64_t elindex);
                
                int64_t NumInternalEquations();
                
                virtual void SkylineInternal(TPZVec<int64_t> &skyline);
                
                void PotentialInternal(std::list<int64_t> &connectindices) const;

                void MakeExternal(int64_t local);
                
                virtual int64_t TransferElement(TPZCompMesh *mesh, int64_t elindex) override;
                
                virtual void MakeAllInternal() override;
                
                virtual TPZCompMesh * RootMesh(int64_t local) override;
                
                virtual void MakeInternal(int64_t local) override;
                
                virtual int64_t PutinSuperMesh(int64_t local, TPZCompMesh *super) override;
                
                virtual int64_t GetFromSuperMesh(int64_t superind, TPZCompMesh *super) override;
                
                virtual TPZCompMesh * CommonMesh (TPZCompMesh *mesh) override;
                
                virtual TPZCompMesh * FatherMesh() const override;

                void PermuteExternalConnects();
                
                void ComputePermutationInternalFirst(TPZVec<int64_t> &permute) const;
                
                void PermuteInternalFirst(TPZVec<int64_t> &permute);
                
                virtual void Print(std::ostream &out = std::cout) const override;
                
                bool NeedsComputing(const std::set<int> &matids) override;
    
                virtual int64_t AllocateNewConnect(int nshape, int nstate, int order) override;
                
                virtual int64_t AllocateNewConnect(const TPZConnect &connect) override;
                
                int64_t NodeIndex(int64_t nolocal, TPZCompMesh *super);
    
    int64_t InternalIndex(int64_t IndexinFather);
                
                virtual int Dimension() const override;
                
                virtual void ComputeNodElCon() override;
                
                virtual void ComputeNodElCon(TPZVec<int> &nelconnected) const override;

                virtual void SetConnectIndex(int inode, int64_t index) override;
                
    virtual void Assemble() override;
    
                virtual void CalcStiff(TPZElementMatrix &ek,TPZElementMatrix &ef) override;
                
    void InitializeEF(TPZElementMatrix &ef);
    
    virtual void CalcResidual(TPZElementMatrix &ef) override;
    

                virtual void CreateGraphicalElement(TPZGraphMesh & graphmesh, int dimension) override;

                virtual int64_t ConnectIndex(int i) const override;
                
                virtual int NConnects() const override;
                
    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const override;

                virtual void LoadSolution() override;
    
    virtual void TransferMultiphysicsElementSolution() override;
    
    virtual TPZVec<STATE> IntegrateSolution(const std::string &varname, const std::set<int> &matids) override;
    

                virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZSolVec &sol, TPZGradSolVec &dsol,TPZFMatrix<REAL> &axes) override;
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZVec<REAL> &normal,
                                                                                                                                 TPZSolVec &leftsol, TPZGradSolVec &dleftsol,TPZFMatrix<REAL> &leftaxes,
                                                                                                                                 TPZSolVec &rightsol, TPZGradSolVec &drightsol,TPZFMatrix<REAL> &rightaxes) override;
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphix,
                                                                                                                                 const TPZFMatrix<REAL> &axes, TPZSolVec &sol, TPZGradSolVec &dsol) override;
  
    virtual void EvaluateError(std::function<void(const TPZVec<REAL> &loc,TPZVec<STATE> &val,TPZFMatrix<STATE> &deriv)> func,
                                     TPZVec<REAL> &errors, bool store_error) override;
                
                public:

virtual int ClassId() const override;

                virtual void Write(TPZStream &buf, int withclassid) const override;
                
                virtual void Read(TPZStream &buf, void *context) override;
                
                bool VerifyDatastructureConsistency();
    
    void AddLagrangeDOF(int64_t connectindex, int idf)
    {
        fLagrangeEquations.push_back(std::pair<int64_t,int>(connectindex,idf));
        SetNumberRigidBodyModes(fLagrangeEquations.size());
    }
    
    void SetNumberRigidBodyModes(int nrigid, unsigned char lagrange = 0);
    
    int NumberRigidBodyModes();
        
    virtual bool HasMaterial(const std::set<int> &materialids) const override;

                static int main();
};

#endif