TPZRefPattern.h

Go to the documentation of this file.

#ifndef PZREFPATTERNH 
#define PZREFPATTERNH

#include "pzvec.h"
#include "pztrnsform.h"
#include "pzgeoelside.h"
#include "pzgmesh.h"
#include "tpzpermutation.h"

// #include <iostream>
// #include <string>
// #include <map>
// #include <list>
// #include <set>
// #include "TPZRefPatternDataBase.h"
// #include "TPZRefPatternTools.h"

// class TPZGeoNode;
// class TPZCompMesh;
// //class TPZGeoElBC;
// class TPZGeoEl;
// class TPZGeoElSideIndex;
// class TPZGeoElSide;

// /** \addtogroup refine
//  @{
//  */
// /// Id for non initialized pattern
// const int nonInitializedId = -50;
// /// Name for non initialized pattern
// const std::string nonInitializedName = "noname";

class TPZRefPattern : public TPZSavable {
protected:
    static const int fNonInitializedId;
    static const std::string fNonInitializedName;
                TPZVec<TPZVec<std::pair<int,TPZTransform<REAL>>>> fSubElSideInfo;

                struct SPZFatherSideInfo{
        TPZVec<int> fSideNodes;
        TPZVec<TPZGeoElSide> fSideSons;
        SPZFatherSideInfo(const TPZVec<int> &sideNodes,
                const TPZVec<TPZGeoElSide> &sideSons,
                const int64_t &midSideIndex) :
        fSideNodes(sideNodes), fSideSons(sideSons) {}
        SPZFatherSideInfo() = default;
        SPZFatherSideInfo(const SPZFatherSideInfo &) = default;
        void Read(TPZStream &buf, void *context);

        void Write(TPZStream &buf, int withclassid) const;
        ~SPZFatherSideInfo() = default;
                };
                TPZVec<SPZFatherSideInfo> fFatherSideInfo;



                std::string fName;

                int fId;

    TPZVec<int> fSideRefPattern;

    TPZVec<int> fPermutedRefPatterns;

    TPZGeoMesh fRefPatternMesh;

    int fNSubEl;


    class TPZRefPatternPermute : public TPZSavable {
    public:
        TPZPermutation fPermute;

        TPZTransform<> fTransform;
        TPZRefPatternPermute(): fPermute(0)
        {}
        TPZRefPatternPermute(const TPZRefPatternPermute &copy) : fPermute(copy.fPermute), fTransform(copy.fTransform)
        {
        }
        TPZRefPatternPermute &operator=(const TPZRefPatternPermute &copy)
        {
            fPermute = copy.fPermute;
            fTransform = copy.fTransform;
            return *this;
        }
        int ClassId() const override;
        void Read(TPZStream &buf, void *context) override;
        void Write(TPZStream &buf, int withclassid) const override;
    };

    static std::map<MElementType, std::list<TPZRefPatternPermute> > fPermutations;


    friend class
    TPZRefPatternDataBase;

    friend class
    TPZRefPatternTools;

    int FindSubEl(TPZGeoEl *) const;

    bool CheckSideConsistency(const int fatherSide) const;

    bool CheckSideAndSubElConsistency(const int fatherSide, const int subEl) const;

    void SetRefPatternMeshToMasterDomain();

    void GeneratePermutations(TPZGeoEl *gel);

    void ComputeTransforms();

    void ComputePartition();

    void BuildSideMesh(int side, TPZGeoMesh &SideRefPatternMesh);

    void BuildName();

    void PermuteMesh(const TPZPermutation &permute);

    void ReadAndCreateRefinementPattern(std::istream &file);

    void CreateRefinementPattern();

    TPZTransform<> ComputeParamTransform(TPZGeoEl *geoElFrom, TPZGeoEl *geoElTo, int sideFrom, int sideTo);
public:

    TPZRefPattern();
    TPZRefPattern(std::istream &file);

    TPZRefPattern(const std::string &file);

    TPZRefPattern(const TPZRefPattern &copy);

    explicit TPZRefPattern(TPZGeoMesh &gmesh);

    TPZRefPattern(const TPZRefPattern &copy, const TPZPermutation &permute);

    int operator==(const TPZAutoPointer<TPZRefPattern> compare) const;

                virtual ~TPZRefPattern() = default;

    void PrintMore(std::ostream &out = std::cout) const;

    void ShortPrint(std::ostream &out = std::cout) const;

    void Print(std::ostream &out = std::cout) const;

    void PrintVTK(std::ofstream &file, bool matColor = false) const;

    void ExportPattern(std::ostream &out) const;

    void WritePattern(std::ofstream &out) const;

    int ClassId() const override;

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

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

    int NSubElements() const;
    int FatherSide(int side, int sub) const;


    int NSideSubGeoElSides(int fatherSide) const;
    void SideSubGeoElSide(int fatherSide, int subElPos, TPZGeoElSide & subGeoEl) const;
                
    TPZTransform<> Transform(int subElSide, int sub);
                
     void SideNodes(int fatherSide, TPZVec<int> &vecNodes);
                
     int NSideNodes(int fatherSide) const;
                
     int NNodes() const;

    bool IsFatherNeighbour(TPZGeoElSide fatherSide,TPZGeoEl *son) const;

    TPZGeoEl *Element(int iel);

    /*
    * @brief Fill a vector with TPZGeoElSideIndex_s  with respect to internal
    * subelements of zero dimension of a given side
    * @param side - side of father element that will be searched for internal nodes (generated from subelements)
    * @param nodeIndexes - vector of subelements index/Sides (stored as TPZGeoElSideIndex objects that have dimension = 0) that
    * belongs to the interior of given side of father element.
    */
    void InternalNodesIndexes(int side, TPZVec<TPZGeoElSideIndex> &nodeIndexes);

    void InternalSidesIndexes(int side, TPZVec<TPZGeoElSideIndex> &sideIndexes);

    int Id() const{
        return fId;
    }

    bool IdInitialized(){
        return (fId != fNonInitializedId);
    }

    void SetId(int id) {
        fId = id;

        TPZGeoEl *el = fRefPatternMesh.ElementVec()[0];
        int nSides = el->NSides();
        fSideRefPattern[nSides - 1] = id;
    }

    bool NameInitialized(){
        return (fName != fNonInitializedName);
    }

    void SetName(std::string name){
        fName = name;
    }

    std::string Name(){
        return fName;
    }
    int SidePartition(TPZVec<TPZGeoElSide> &gelvec, int side);

    void CreateNewNodes(TPZGeoEl *gel, TPZVec<int64_t> &newnodeindexes);

    void CreateMidSideNodes(TPZGeoEl *gel, int side, TPZVec<int64_t> &newnodeindexes);

    TPZAutoPointer<TPZRefPattern> SideRefPattern(int side);

    void GenerateSideRefPatterns();

    void InsertPermuted();
    TPZAutoPointer<TPZRefPattern> SideRefPattern(int side, TPZTransform<> &trans);

    TPZAutoPointer<TPZRefPattern> FindRefPattern(TPZTransform<> &trans);

    TPZGeoMesh &RefPatternMesh(){
                                return fRefPatternMesh;
                }

    MElementType Type(){
        return Element(0)->Type();
    }
};

#endif