pzdohrstructmatrix.h

Go to the documentation of this file.

#ifndef PZDOHRSTRUCTMATRIX 
#define PZDOHRSTRUCTMATRIX

#include "pzstrmatrix.h"
#include "tpzdohrassembly.h"
#include "pzsubcmesh.h"

template<class TVar>
struct ThreadDohrmanAssembly;

class TPZDohrStructMatrix : public TPZStructMatrix
{
                                
public:
                
        TPZDohrStructMatrix(TPZAutoPointer<TPZCompMesh> compmesh);
                
                TPZDohrStructMatrix(const TPZDohrStructMatrix &copy);
                
                virtual ~TPZDohrStructMatrix();
                
                void SubStructure(int nsub);
                
                virtual TPZMatrix<STATE> * Create() override;
                
                TPZAutoPointer<TPZMatrix<STATE> > Preconditioner()
                {
                                TPZAutoPointer<TPZMatrix<STATE> > result = fDohrPrecond;
                                //fDohrPrecond = 0; Essa linha me ferra pois nao posso pegar as subestruturas depois
                                return result;
                }
                
                virtual TPZMatrix<STATE> * CreateAssemble(TPZFMatrix<STATE> &rhs, TPZAutoPointer<TPZGuiInterface> guiInterface,
                                              unsigned numthreads_assemble, unsigned numthreads_decompose) override;
                
    virtual void Assemble(TPZMatrix<STATE> & mat, TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface,
                          unsigned numthreads_assemble, unsigned numthreads_decompose) override;

    void AssembleTBB(TPZMatrix<STATE> & mat, TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface);

                virtual void Assemble(TPZFMatrix<STATE> & rhs, TPZAutoPointer<TPZGuiInterface> guiInterface) override;
                
                virtual TPZStructMatrix * Clone() override
                {
                                return new TPZDohrStructMatrix(*this);
                }
    
    int NumberCornerEqs() const
    {
        return fCornerEqs.size();
    }
    
    // FOR DEBUG PURPOSES
    TPZAutoPointer<TPZDohrAssembly<STATE> > Assembly() {
        return fDohrAssembly;
    }
                
                int SeparateUnconnected(TPZVec<int> &domain_index, int nsub, int connectdimension);
                
                int ClusterIslands(TPZVec<int> &domain_index,int nsub,int connectdimension);
    
    void Write(TPZStream &str, int withclassid) const override;
    
    void Read(TPZStream &str, void *context) override;
                
                
protected:
                
                TPZAutoPointer<TPZDohrAssembly<STATE> > fDohrAssembly;
                
                TPZAutoPointer<TPZMatrix<STATE> > fDohrPrecond;
                
                /* @brief Get the global equation numbers of a substructure (and their inverse) */
                void IdentifyEqNumbers(TPZSubCompMesh *sub, std::map<int,int> &global, std::map<int,int> &globinv);
                
                void ComputeInternalEquationPermutation(TPZSubCompMesh *sub,
                                                                                                                                                                                TPZVec<int> &scatterpermute, TPZVec<int> &gatherpermute);
                
                void IdentifySubCornerEqs(std::map<int,int> &globaltolocal, TPZVec<int> &cornereqs,
                                                                                                                  TPZVec<int> &coarseindex);
    
    void CorrectNeighbourDomainIndex(TPZCompMesh *cmesh, TPZVec<int> &domainindex);
                
public:
                void IdentifyExternalConnectIndexes();
                
private:
                TPZDohrStructMatrix();
        
                void IdentifyCornerNodes();
                
                TPZManVector<int> fExternalConnectIndexes;
                
                std::set<int> fCornerEqs;
                
                pthread_mutex_t fAccessElement;
                
                friend struct ThreadDohrmanAssembly<STATE>;
        
        friend TPZPersistenceManager;
                
};

#include "tpzdohrsubstructCondense.h"

template<class TVar>
struct ThreadDohrmanAssembly {
                
                enum MTask {ENone, EComputeMatrix, EDecomposeInternal, EDecomposeBig};
                
                MTask fTask;
                TPZAutoPointer<TPZCompMesh> fMesh;
                int fSubMeshIndex;
                TPZAutoPointer<TPZDohrSubstructCondense<TVar> > fSubstruct;
                TPZAutoPointer<TPZDohrAssembly<TVar> > fAssembly;
                
                ThreadDohrmanAssembly(TPZAutoPointer<TPZCompMesh> mesh, int submesh, TPZAutoPointer<TPZDohrSubstructCondense<TVar> > substruct,
                                                                                                  TPZAutoPointer<TPZDohrAssembly<TVar> > assembly) : 
                fTask(ENone), fMesh(mesh), fSubMeshIndex(submesh), fSubstruct(substruct), fAssembly(assembly)
                {
                                
                }
                
                ThreadDohrmanAssembly(const ThreadDohrmanAssembly &copy) : fTask(copy.fTask), fMesh(copy.fMesh), fSubMeshIndex(copy.fSubMeshIndex),
                fSubstruct(copy.fSubstruct),fAssembly(copy.fAssembly)
                {
                }
                
                ThreadDohrmanAssembly(TPZAutoPointer<ThreadDohrmanAssembly> copy) : fTask(copy->fTask), fMesh(copy->fMesh), fSubMeshIndex(copy->fSubMeshIndex),
                fSubstruct(copy->fSubstruct),fAssembly(copy->fAssembly)
                {
                }
                
                ThreadDohrmanAssembly &operator=(const ThreadDohrmanAssembly &copy)
                {
                                fTask = copy.fTask;
                                fMesh = copy.fMesh;
                                fSubMeshIndex = copy.fSubMeshIndex;
                                fSubstruct = copy.fSubstruct;
                                fAssembly = copy.fAssembly;
                                return *this;
                }
                
                void AssembleMatrices(pthread_mutex_t &testthread, int numa_node);
};

template<class TVar>
struct ThreadDohrmanAssemblyList {
                
                ThreadDohrmanAssemblyList();
                ThreadDohrmanAssemblyList(ThreadDohrmanAssemblyList<TVar> &cpy);
                
                ~ThreadDohrmanAssemblyList();
                
                std::list<TPZAutoPointer<ThreadDohrmanAssembly<TVar> > > fList;
                
                void Append(TPZAutoPointer<ThreadDohrmanAssembly<TVar> > object);
                
                TPZAutoPointer<ThreadDohrmanAssembly<TVar> > NextObject();
                
                static void *ThreadWork(void *voidptr);
                
                pthread_mutex_t fAccessElement;
                
                pthread_mutex_t fTestThreads;
};

#endif