TPZAgglomerateEl.h

Go to the documentation of this file.

#ifndef AGGLOMERATEELEMHPP
#define AGGLOMERATEELEMHPP

#include "pzreal.h"
#include "pzstack.h"
#include "pzeltype.h"
#include "TPZCompElDisc.h"
#include <iostream>
#include <map>
#include <set>

#include <stdlib.h>

class TPZGeoEl;
class TPZCompEl;
class TPZCompMesh;
class TPZGeoElSide;
class TPZInterfaceElement;
struct TPZElementMatrix;
class TPZAgglomerateMesh;

class TPZAgglomerateElement : public TPZCompElDisc {
                
private:
                
                TPZStack<int64_t> fIndexes;
                
                TPZCompMesh *fMotherMesh;
                
                REAL fInnerRadius;
                
                int fNFaces;
                
                int fMaterialId;
                
public:
                
                TPZAgglomerateElement(int nummat,int64_t &index,TPZCompMesh &aggcmesh,TPZCompMesh *finemesh);
                
                TPZAgglomerateElement();
                
                void InitializeElement();
                
                void SetInnerRadius(REAL InnerRadius) override { fInnerRadius = InnerRadius;}
                
                REAL InnerRadius2() {return fInnerRadius;}
                
                REAL InnerRadius() override {
                                int64_t nsubel = this->NIndexes();
                                REAL value = 0.;
                                TPZCompElDisc * disc;
                                for (int64_t i = 0; i < nsubel; i++){
                                                disc = dynamic_cast<TPZCompElDisc *>(this->SubElement(i) );
#ifdef PZDEBUG
                                                if (!disc) {
                                                                PZError << "TPZAgglomerateElement::InnerRadius FineElement must be a TPZCompElDisc" << std::endl;
                                                                exit (-1);
                                                }
#endif
                                                value += disc->InnerRadius() * disc->VolumeOfEl();
                                }
                                value = value / this->VolumeOfEl();
                                return value;  
                }
                
                void SetNInterfaces(int nfaces)  override {fNFaces = nfaces; }
                
                int NInterfaces() override {return fNFaces;}
                
                static void AddSubElementIndex(TPZCompMesh *aggcmesh,int64_t subel,int64_t destind);
                
                ~TPZAgglomerateElement(){};
                
                MElementType Type() override {return EAgglomerate;}
                
                TPZCompMesh *MotherMesh(){return fMotherMesh;}
                
                virtual void AccumulateIntegrationRule(int degree, TPZStack<REAL> &point, TPZStack<REAL> &weight) override;
                
                virtual void AccumulateVertices(TPZStack<TPZGeoNode *> &nodes) override;
                
                void CenterPoint();
                
                virtual void CenterPoint(TPZVec<REAL> &center) override;
                
                REAL VolumeOfEl() override;
                
                void CalcResidual(TPZFMatrix<REAL> &Rhs,TPZCompElDisc *el);
                
                void CalcResidual(TPZElementMatrix &ef) override
                {
                                std::cout << __PRETTY_FUNCTION__ << " is not implemented\n";
                                exit(-1);
                }
                
                void CalcStiff(TPZElementMatrix &ek, TPZElementMatrix &ef) override;
                
                int64_t NIndexes() const { return fIndexes.NElements(); }
                
                TPZGeoEl *CalculateReference();
                
                //  /**os geométricos agrupados apontam para o computacional*/
                /*  void SetReference(){
                 int nindex = NIndexes(),i;
                 for(i=0;i<nindex;i++){
                 TPZCompEl *cel = SubElement(i);
                 int type = cel->Type();
                 //caso comp é aglomerado: chamada recursiva
                 if(type == EAgglomerate){//aglomerado
                 SetReference();
                 } else if(type == EDiscontinuous){//descontínuo
                 //o geométrico agrupado apontará para o atual computacional
                 cel->Reference()->SetReference(this);
                 }
                 }
                 }
                 
                 void SetReference2(int sub){
                 
                 TPZCompEl *cel = SubElement(sub);
                 int type = cel->Type();
                 //caso comp é aglomerado: chamada recursiva
                 if(type == EAgglomerate){//aglomerado
                 dynamic_cast<TPZAgglomerateElement *>(cel)->SetReference();
                 } else if(type == EDiscontinuous){//descontínuo
                 //o geométrico agrupado apontará para o atual computacional
                 cel->Reference()->SetReference(this);
                 }
                 } */
                
                virtual REAL LesserEdgeOfEl();
                
                TPZCompEl *SubElement(int64_t sub) const;
                
                REAL NormalizeConst() override;
                
                virtual int64_t CreateMidSideConnect() override;
                
                int Dimension() const override;
                
                virtual void Print(std::ostream & out = std::cout) const override;

                void ListOfDiscEl(TPZStack<TPZCompEl *> &elvec);
                void IndexesDiscSubEls(TPZStack<int64_t> &elvec);
                
                int NSides();
                
                void CreateGraphicalElement(TPZGraphMesh &grmesh, int dimension) override;
                                
                static void ListOfGroupings(TPZCompMesh *finemesh,TPZVec<int64_t> &accumlist,int nivel,int64_t &numaggl,int dim);
                
                //  void FineSolution(TPZVec<REAL> &x,TPZCompElDisc *disc,TPZVec<REAL> &uh);
                
                void Print(TPZStack<int64_t> &listindex);
                
                void ProjectSolution(TPZFMatrix<STATE> &projectsol);
                
                
                static TPZAgglomerateMesh *CreateAgglomerateMesh(TPZCompMesh *finemesh,TPZVec<int64_t> &accumlist,int64_t numaggl);
                
                static void ComputeNeighbours(TPZCompMesh *mesh, std::map<TPZCompElDisc *,std::set<TPZCompElDisc *> > &neighbours);
                
                public:
int ClassId() const override;

                /*@brief Save the element data to a stream */
                void Write(TPZStream &buf, int withclassid) const override;
                
                void Read(TPZStream &buf, void *context) override;

};

#endif