pzconnect.h

Go to the documentation of this file.

#ifndef  PZCONNECTH
#define  PZCONNECTH

#include "pzfmatrix.h"
#include "pzstack.h"
#include "pzlog.h"
#include <iostream>
#include <set>


class TPZBndCond;
class TPZCompMesh;
template<class TVar>
class TPZBlock;

class TPZConnect : public TPZSavable {
public:
    enum EConnectType {ENone = 0, EPressure = 1, ECondensed = 2};
                int64_t                         fSequenceNumber;
                
                int                             fNElConnected;
                    
    union
    {
        unsigned int fFlags;
        struct
        {
            unsigned char fOrder;
            unsigned char fNState;
            unsigned char fLagrangeMultiplier;
            bool fIsCondensed;
        } fCompose;
    };
    unsigned int fNShape;

                
public:
                class TPZDepend : public TPZSavable {
        public :
                                int64_t                                         fDepConnectIndex;
                                TPZFNMatrix<50,REAL> fDepMatrix;
                                TPZDepend                       *fNext;
                                
                                TPZDepend();
                                TPZDepend(int64_t DepConnectIndex,TPZFMatrix<REAL> &depmat,int64_t ipos,int64_t jpos, int isize, int jsize);
                                
                                TPZDepend(const TPZDepend &copy);
                                TPZDepend(int64_t connectindex);
                                
                                ~TPZDepend();
                                TPZDepend *HasDepend(int64_t DepConnectIndex);
                                TPZDepend *RemoveDepend(TPZDepend *Ptr);
                                int ClassId() const override;
                void Read(TPZStream &buf, void *context) override;
                void Write(TPZStream &buf, int withclassid) const override;
                                void CopyFrom(TPZDepend *orig , std::map<int64_t,int64_t>& gl2lcIdx);
                };
                
private:
                TPZDepend *fDependList;
                
public:
                TPZConnect();
    
    TPZConnect(const TPZConnect &copy);
                ~TPZConnect();
                
                TPZConnect &operator=(const TPZConnect &con);
        
        virtual int ClassId() const override{
            return Hash("TPZConnect");
        }
                
    void Reset()
    {
        if (fDependList) {
            DebugStop();
            delete fDependList;
            fDependList = 0;
        }
        SetSequenceNumber(-1);
        SetNState(0);
        SetOrder(0,-1);
        SetNShape(0);
        ResetElConnected();
        SetCondensed(false);
        SetLagrangeMultiplier(0);
    }
                int NDof(TPZCompMesh &mesh);
    
                int NDof() const
    {
        return fNShape*fCompose.fNState;
    }
    
    unsigned char NState() const
    {
        return fCompose.fNState;
    }
    
    unsigned int NShape() const
    {
        return fNShape;
    }

                int64_t SequenceNumber() const
    {
        return fSequenceNumber;
    }

                void SetSequenceNumber(int64_t i) {fSequenceNumber = i;}
                
                void SetOrder(int order, int64_t index) {
#ifdef PZDEBUG
        if(order < 0 || order > 255)
        {
            DebugStop();
        }
//        int64_t crit[] = {5004,5005,4978,5170,5516,5515,5544,5555,4997,4973,4966,4965,5520,5519,5546,5556,5523,5549,5557,5558,4962,5527,5552,5559,5560,5561,5562};
//        static std::set<int64_t> critical;
//        static int once = 1;
//        if (once)
//        {
//            once = 0;
//            for (int i=0; i<27; i++) {
//                critical.insert(crit[i]);
//            }
//        }
//        if (critical.find(index) != critical.end()) {
//            std::cout << "Connect index " << index << " set to order " << order << std::endl;
//            if(order == 5)
//            {
//                StopError();
//            }
//        }
#endif
                                fCompose.fOrder = order;
                }
    
    void SetNState(int nstate)
    {
        if(nstate<0 || nstate > 255)
        {
            DebugStop();
        }
        fCompose.fNState = nstate;
    }
    void SetNShape(int nshape)
    {
#ifdef PZDEBUG
        if(nshape < 0 )
        {
            DebugStop();
        }
#endif
                                fNShape = nshape;
    }
                
                unsigned char Order() const {
                                return fCompose.fOrder;
                }
    
    bool IsCondensed() const
    {
        return fCompose.fIsCondensed;
    }
    
    unsigned char LagrangeMultiplier() const
    {
        return fCompose.fLagrangeMultiplier;
    }
    
    void SetLagrangeMultiplier(unsigned char mult)
    {
        fCompose.fLagrangeMultiplier = mult;
    }

    void SetCondensed(bool flag)
    {
        fCompose.fIsCondensed = flag;
    }

                void Print(const TPZCompMesh &mesh, std::ostream & out = std::cout);
                
                void Print(TPZCompMesh &mesh, TPZVec<REAL> &cp, std::ostream & out = std::cout);
                
                void ResetElConnected() { fNElConnected = 0; }
                void IncrementElConnected() { fNElConnected++; }
                void DecrementElConnected() { fNElConnected--; }
                int NElConnected() const { return fNElConnected; }
                
                TPZDepend *AddDependency(int64_t myindex, int64_t dependindex,TPZFMatrix<REAL> &depmat,int64_t ipos,int64_t jpos, int isize, int jsize);
                
                void RemoveDepend(int64_t myindex, int64_t dependindex);
                
                void RemoveDepend();

                int DependencyDepth(TPZCompMesh &mesh);
    
    int NumDepend() const;
    
                int HasDependency()const { return fDependList != 0; }
                
                int CheckDependency(int nshape, TPZCompMesh *mesh, int nstate);
                
                TPZDepend *FirstDepend() { return fDependList; }
                
                void AddToList(int64_t myindex, TPZCompMesh &mesh, TPZStack<int64_t> &connectlist);
                
                void AddToList(int64_t myindex, TPZCompMesh &mesh, std::set<int64_t> &connectlist);
                
                void SetDependenceOrder(int64_t myindex, TPZCompMesh &mesh, int CurrentOrder,TPZVec<int64_t> &connectlist,TPZVec<int> &DependenceOrder);
                
                void ExpandShape(int64_t cind, TPZVec<int64_t> &connectlist, TPZVec<int> &blocksize, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphi);
                
                void Write(TPZStream &buf, int withclassid) const override;
                
                void Read(TPZStream &buf, void *context) override;
                
                void CopyFrom(TPZConnect &orig,std::map<int64_t,int64_t> & gl2lcIdx);
                
                void BuildConnectList(int64_t index, std::set<int64_t> &indepconnectlist, std::set<int64_t> &depconnectlist, TPZCompMesh &mesh);
                
                static void BuildConnectList(TPZStack<int64_t> &connectlist, TPZVec<int64_t> &ConnectIndex, TPZCompMesh &mesh);
                
                static void BuildConnectList(std::set<int64_t> &connectlist, std::set<int64_t> &additional, TPZCompMesh &mesh);
                
                static void BuildDependencyOrder(TPZVec<int64_t> &connectlist, TPZVec<int> &DependenceOrder, TPZCompMesh &mesh);
                
};

inline std::ostream & operator<<(std::ostream &out,TPZConnect &con)
{
                out << "seq num: " << con.SequenceNumber()
                << " nel con: " << con.NElConnected()
                << " order: " << con.Order()
    << " is condensed " << con.IsCondensed()
                << " hasdepend: " << con.HasDependency();
                return out;
}

#endif