TPZMatWithMem.h

Go to the documentation of this file.

#ifndef PZMATWITHMEM_H
#define PZMATWITHMEM_H

#include "TPZMaterial.h"
#include "pzadmchunk.h"
#include <memory>

template <class TMEM, class TFather = TPZMaterial>
class TPZMatWithMem : public TFather {
public:

    TPZMatWithMem();

    TPZMatWithMem(int id);

    TPZMatWithMem(const TPZMatWithMem<TMEM, TFather> &mat);

    virtual ~TPZMatWithMem();

    virtual std::string Name()  override {
        return "TPZMatWithMem< >";
    }

    virtual void PrintMem(std::ostream &out = std::cout, const int memory = 0);

    virtual void Print(std::ostream &out) override;

    virtual TMEM &MemItem(const int i) const;

public:
    
    int ClassId() const override;

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

    void Read(TPZStream &buf, void *context) override;

    std::shared_ptr<TPZAdmChunkVector<TMEM>> & GetMemory();

    void SetMemory(std::shared_ptr<TPZAdmChunkVector<TMEM>> & memory);

    virtual int PushMemItem(int sourceIndex = -1) override;

    virtual void FreeMemItem(int index) override;

    void ResetMemItem(int index) {
        this->MemItem(index) = fDefaultMem;
    }

    void ResetMemory() {
        int nmem = fMemory->NElements();
        for (unsigned int im = 0; im < nmem; im++) {
            ResetMemItem(im);
        }
    }

    virtual void SetDefaultMem(TMEM & defaultMem);

    virtual TMEM &GetDefaultMemory()
    {
        return fDefaultMem;
    }

    virtual void SetUpdateMem(bool update = 1);
    
    virtual bool GetUpdateMem();

protected:

    std::shared_ptr<TPZAdmChunkVector<TMEM>> fMemory;

    TMEM fDefaultMem;

    bool fUpdateMem;
};

template <class TMEM, class TFather>
TPZMatWithMem<TMEM, TFather>::TPZMatWithMem() :
TPZRegisterClassId(&TPZMatWithMem::ClassId),
TFather(),
fMemory(new TPZAdmChunkVector<TMEM>()), fDefaultMem(), fUpdateMem(0) {
}

template <class TMEM, class TFather>
TPZMatWithMem<TMEM, TFather>::TPZMatWithMem(int id) :
TPZRegisterClassId(&TPZMatWithMem::ClassId),
TFather(id),
fMemory(new TPZAdmChunkVector<TMEM>()), fDefaultMem(), fUpdateMem(false) {
}

template <class TMEM, class TFather>
TPZMatWithMem<TMEM, TFather>::TPZMatWithMem(const TPZMatWithMem<TMEM, TFather> &mat) :
TPZRegisterClassId(&TPZMatWithMem::ClassId),
TFather(mat),
fMemory(new TPZAdmChunkVector<TMEM>()), fDefaultMem(mat.fDefaultMem), fUpdateMem(mat.fUpdateMem) {
    *fMemory = *mat.fMemory;
}

template <class TMEM, class TFather>
TPZMatWithMem<TMEM, TFather>::~TPZMatWithMem() {
}

template <class TMEM, class TFather>
void TPZMatWithMem<TMEM, TFather>::Print(std::ostream &out) {
    out << __PRETTY_FUNCTION__ << std::endl;
    TFather::Print(out);

    out << "\nfDefaultMem = \n" << fDefaultMem;
    out << "\nfUpdateMem = " << fUpdateMem;
    int size = fMemory->NElements();
    out << "\nfMemory with " << size << " elements";
    for (int i = 0; i < size; i++) {
        out << "\nfMemory element : " << i << std::endl;
        this->MemItem(i).Print(out);
    }

}

template <class TMEM, class TFather>
void TPZMatWithMem<TMEM, TFather>::PrintMem(std::ostream &out, const int memory) {
    int size = fMemory->NElements();
    if (memory >= 0 && memory < size) {
        out << "fMemory element : " << memory << std::endl;
        this->MemItem(memory).Print(out);
    } else {
        out << "Memory index out of range : memory " << memory << " no elements " << size << std::endl;
    }
}

template <class TMEM, class TFather>
TMEM &TPZMatWithMem<TMEM, TFather>::MemItem(const int i) const {
    return fMemory.get()->operator [](i);
}

template <class TMEM, class TFather>
int TPZMatWithMem<TMEM, TFather>::ClassId() const {
    return Hash("TPZMatWithMem") ^ TFather::ClassId() << 1 ^ TMEM().ClassId() << 2;
}

template <class TMEM, class TFather>
void TPZMatWithMem<TMEM, TFather>::Write(TPZStream &buf, int withclassid) const {
    TFather::Write(buf, withclassid);
    int updatemem = fUpdateMem;
    buf.Write(&updatemem);
    fDefaultMem.Write(buf, 0);
    TPZPersistenceManager::WritePointer(fMemory.get(), &buf);
}

template <class TMEM, class TFather>
void TPZMatWithMem<TMEM, TFather>::Read(TPZStream &buf, void *context) {
    TFather::Read(buf, context);
    int updatemem;
    buf.Read(&updatemem);
    if (updatemem) {
        fUpdateMem = true;
    } else {
        fUpdateMem = false;
    }
    fDefaultMem.Read(buf, 0);
    fMemory = std::dynamic_pointer_cast<TPZAdmChunkVector<TMEM> >(TPZPersistenceManager::GetSharedPointer(&buf));

}

template <class TMEM, class TFather>
std::shared_ptr<TPZAdmChunkVector<TMEM>> & TPZMatWithMem<TMEM, TFather>::GetMemory() {
    return fMemory;
}

template <class TMEM, class TFather>
void TPZMatWithMem<TMEM, TFather>::SetMemory(std::shared_ptr<TPZAdmChunkVector<TMEM>> & memory) {
    fMemory = memory;
}

template <class TMEM, class TFather>
int TPZMatWithMem<TMEM, TFather>::PushMemItem(int sourceIndex) {
    int index = fMemory->AllocateNewElement();
    if (sourceIndex < 0) {
        this->ResetMemItem(index);
    } else {
        this->MemItem(index) = this->MemItem(sourceIndex);
    }
    return index;
}

template <class TMEM, class TFather>
void TPZMatWithMem<TMEM, TFather>::FreeMemItem(int index) {
    fMemory->SetFree(index);
}

template <class TMEM, class TFather>
void TPZMatWithMem<TMEM, TFather>::SetDefaultMem(TMEM & defaultMem) {
    fDefaultMem = defaultMem;
}

template <class TMEM, class TFather>
void TPZMatWithMem<TMEM, TFather>::SetUpdateMem(bool update) {
    fUpdateMem = update;
}

template <class TMEM, class TFather>
bool TPZMatWithMem<TMEM, TFather>::GetUpdateMem() {
    return fUpdateMem;
}

#endif