tpzdohrmatrix.h

Go to the documentation of this file.

#ifndef TPZDOHRMATRIX_H
#define TPZDOHRMATRIX_H

#include "pzmatrix.h"
#include <list>
#include <sstream>
#include "tpzautopointer.h"
#include "tpzdohrsubstruct.h"
#include "tpzdohrsubstructCondense.h"
#include "tpzdohrassembly.h"

#include "tpzdohrassemblelist.h"

#include "pz_pthread.h"

template <class TVar, class TSubStruct>
class TPZDohrMatrix : public TPZMatrix<TVar>
{
public:
                typedef typename std::list<TPZAutoPointer<TSubStruct> > SubsList;
private:
                SubsList fGlobal;
                
                int fNumCoarse; //n(c)
                
                int fNumThreads;
                
public:
                
                TPZAutoPointer<TPZDohrAssembly<TVar> > fAssembly;
                
                TPZDohrMatrix(TPZAutoPointer<TPZDohrAssembly<TVar> > dohrassembly);
                
                TPZDohrMatrix() : TPZMatrix<TVar>()
    {
        
    }
                
                TPZDohrMatrix(const TPZDohrMatrix &cp) : fGlobal(cp.fGlobal), fNumCoarse(cp.fNumCoarse), fNumThreads(cp.fNumThreads),
                fAssembly(cp.fAssembly)
                {
                }
                
                //              CLONEDEF(TPZDohrMatrix)
                virtual TPZMatrix<TVar>*Clone() const  override { return new TPZDohrMatrix(*this); }
                
                ~TPZDohrMatrix();
                
                const SubsList &SubStructures() const
                {
                                return fGlobal;
                }
                
                int NumCoarse() const
                {
                                return fNumCoarse;
                }
                
                int NumThreads() const
                {
                                return fNumThreads;
                }
                
                void SetNumThreads(int numthreads)
                {
                                fNumThreads = numthreads;
                }
                
                TPZAutoPointer<TSubStruct> GetFirstSub() {
                                return (*fGlobal.begin());
                }
                void Print(const char *name, std::ostream& out,const MatrixOutputFormat form = EFormatted) const override
                {
                                out << __PRETTY_FUNCTION__ << std::endl;
                                out << name << std::endl;
                                out << "Number of coarse equations " << fNumCoarse << std::endl;
                                typename SubsList::const_iterator iter;
                                for (iter=fGlobal.begin();iter!=fGlobal.end();iter++) {
                                                (*iter)->Print(out);
                                }
                }
                
                void SetNumCornerEqs(int nc)
                {
                                fNumCoarse = nc;
                }
                void Initialize();
                void AddSubstruct(TPZAutoPointer<TSubStruct> substruct)
                {
                                fGlobal.push_back(substruct);
                }
                
                virtual void MultAddTBB(const TPZFMatrix<TVar> &x,const TPZFMatrix<TVar> &y, TPZFMatrix<TVar> &z,const TVar alpha,const TVar beta,const int opt) const;
    
                virtual void MultAdd(const TPZFMatrix<TVar> &x,const TPZFMatrix<TVar> &y, TPZFMatrix<TVar> &z,const TVar alpha,const TVar beta,const int opt) const override;
                
                void AdjustResidual(TPZFMatrix<TVar> &res);
                
                void AddInternalSolution(TPZFMatrix<TVar> &solution);
    
                void Read(TPZStream &buf, void *context) override;
                void Write(TPZStream &buf, int withclassid) const override;
    
                public:
int ClassId() const override;

};

template <class TVar, class TSubStruct>
int TPZDohrMatrix<TVar, TSubStruct>::ClassId() const{
    return Hash("TPZDohrMatrix") ^ TPZMatrix<TVar>::ClassId() << 1 ^ TSubStruct().ClassId() << 2;
}

template <class TSubStruct>
struct TPZDohrThreadMultData
{
                TPZDohrThreadMultData() : fisub(-1), fSub(0)
                {
                }
                TPZDohrThreadMultData(int isub, TPZAutoPointer<TSubStruct> submesh) : fisub(isub), fSub(submesh)
                {
                }
                TPZDohrThreadMultData(const TPZDohrThreadMultData<TSubStruct> &cp) : fisub(cp.fisub), fSub(cp.fSub)
                {
                }
                TPZDohrThreadMultData<TSubStruct> &operator=(const TPZDohrThreadMultData<TSubStruct> &cp)
                {
                                fisub = cp.fisub;
                                fSub = cp.fSub;
                                return *this;
                }
                int fisub;
                TPZAutoPointer<TSubStruct> fSub;
                
                bool IsValid()
                {
                                return (fisub >= 0);
                }
};

template <class TVar, class TSubStruct>
struct TPZDohrThreadMultList
{
                const TPZFMatrix<TVar> *fInput;
                TVar fAlpha;
                pthread_mutex_t fAccessLock;
                TPZAutoPointer<TPZDohrAssembly<TVar> > fAssembly;
                std::list<TPZDohrThreadMultData<TSubStruct> > fWork;
                TPZAutoPointer<TPZDohrAssembleList<TVar> > fAssemblyStructure;
                
                TPZDohrThreadMultList(const TPZFMatrix<TVar> &x, TVar alpha, TPZAutoPointer<TPZDohrAssembly<TVar> > assembly, TPZAutoPointer<TPZDohrAssembleList<TVar> > &assemblestruct) : fInput(&x), fAlpha(alpha),
                fAssembly(assembly), fAssemblyStructure(assemblestruct)
                {
        PZ_PTHREAD_MUTEX_INIT(&fAccessLock, 0, "TPZDohrThreadMultList::TPZDohrThreadMultList(...)");
                }
                ~TPZDohrThreadMultList()
                {
        PZ_PTHREAD_MUTEX_DESTROY(&fAccessLock, "TPZDohrThreadMultList::TPZDohrThreadMultList()");
                }
                
                static void *ThreadWork(void *voidptr);
                void AddItem(TPZDohrThreadMultData<TSubStruct> &data)
                {
        PZ_PTHREAD_MUTEX_LOCK(&fAccessLock, "TPZDohrThreadMultList::AddItem()");
                                fWork.push_back(data);
        PZ_PTHREAD_MUTEX_UNLOCK(&fAccessLock, "TPZDohrThreadMultList::AddItem()");
                }
                TPZDohrThreadMultData<TSubStruct> PopItem()
                {
                                TPZDohrThreadMultData<TSubStruct> result;
        PZ_PTHREAD_MUTEX_LOCK(&fAccessLock, "TPZDohrThreadMultList::PopItem()");
                                if (fWork.size()) {
                                                result = *fWork.begin();
                                                fWork.pop_front();
                                }
        PZ_PTHREAD_MUTEX_UNLOCK(&fAccessLock, "TPZDohrThreadMultList::PopItem()");
                                return result;
                }
};

#endif