pzcompel.h

Go to the documentation of this file.

#ifndef COMPELEMHPP
#define COMPELEMHPP

#include "pzreal.h"
#include <iostream>
#include <fstream>
#include "pzgmesh.h"
#include "pzgeoel.h"
#include "TPZSavable.h"
#include "pzfmatrix.h"
#include "pzmatrix.h"
#include "pzblock.h"
#include "pzblockdiag.h"
#include "pzcreateapproxspace.h"
#include "pzmaterialdata.h"
#include "TPZOneShapeRestraint.h"
#include "pztransfer.h"
#include <functional>


struct TPZElementMatrix;
class TPZCompMesh;
class TPZBndCond;
class TPZInterpolatedElement;
class TPZInterfaceElement;
class TPZConnect;
class TPZMaterial;
class TPZGeoEl;
class TPZGeoNode;

class TPZMaterialData;

template<class T>
class TPZVec;
template<class T, int N>
class TPZManVector;
template<class T, int N>
class TPZStack;

class TPZGraphMesh;
class TPZIntPoints;

template<class T>
class TPZTransform;

#include "pzeltype.h"

#include <set>

class TPZCompEl : public virtual TPZSavable {
                
protected:
                
                TPZCompMesh     *fMesh;
                
                int64_t fIndex;
                
private:        
                int64_t fReferenceIndex;
                
public:
                
    static int StaticClassId();
    
    virtual int ClassId() const override;

    
                TPZCompEl();
                
                virtual ~TPZCompEl();
                
                virtual TPZCompEl *Clone(TPZCompMesh &mesh) const = 0;
                
                virtual TPZCompEl *ClonePatchEl(TPZCompMesh &mesh,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcConMap,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap) const = 0;
                
                
                TPZCompEl(TPZCompMesh &mesh, const TPZCompEl &copy);
                
                TPZCompEl(TPZCompMesh &mesh, const TPZCompEl &copy, std::map<int64_t,int64_t> &gl2lcElMap);
                
                TPZCompEl(TPZCompMesh &mesh, const TPZCompEl &copy, int64_t &index);
                
                TPZCompEl(TPZCompMesh &mesh, TPZGeoEl *gel, int64_t &index);
                
                static void SetgOrder( int order );
                
                static int GetgOrder();
                
                virtual void SetCreateFunctions(TPZCompMesh *mesh);
                
                virtual  REAL VolumeOfEl()
                {
                                if(fReferenceIndex == -1) return 0.;
                                return Reference()->Volume();
                }
                
                virtual void LoadElementReference();
                
                virtual REAL CompareElement(int var, char *matname);
                
                /* the types are listed in parameter : ENoType, EOned, ETriangle, EQuadrilateral, ESubstructure */
                virtual MElementType Type();
                
                virtual int IsInterface() { return 0; }
                
                TPZGeoEl *Reference() const;

                void SetReference(int64_t referenceindex)
                {
                                fReferenceIndex = referenceindex;
                }
                
    virtual bool NeedsComputing(const std::set<int> &materialids)
    {
        TPZGeoEl *gel = Reference();
        if (!gel) {
            DebugStop();
        }
        return materialids.find(gel->MaterialId()) != materialids.end();
    }
                virtual int NConnects() const = 0;
                
                virtual int NEquations();
                
                int64_t Index() const;
                
                void SetIndex(int64_t index);
                
                virtual int64_t ConnectIndex(int i) const = 0;
                
                virtual TPZConnect &Connect(int i) const;
                
                virtual int Dimension() const = 0;
                
                virtual TPZMaterial * Material() const;

                TPZGeoEl * GetRefElPatch();
                
                virtual void LoadSolution();
                
                void SetMesh(TPZCompMesh *mesh);
                
                TPZCompMesh *Mesh() const;

                virtual void Print(std::ostream &out = std::cout) const;
                
                friend std::ostream& operator<<(std::ostream &s,TPZCompEl &el);
                
                virtual void PrintSolution(TPZVec<REAL> &point, const char *VarName,std::ostream &out);
                
                virtual void PrintCoordinate(TPZVec<REAL> &point,int CoordinateIndex,std::ostream &out);
                
                virtual void PrintTitle(const char *VarName,std::ostream &out);

                static void SetOrthogonalFunction(void (*orthogonal)(REAL x,int num,TPZFMatrix<REAL> & phi,
                                                                                                                                                                                                                                 TPZFMatrix<REAL> & dphi));
    virtual void Assemble();
    
                virtual void CalcStiff(TPZElementMatrix &ek,TPZElementMatrix &ef);
    
                
                virtual bool HasMaterial(const std::set<int> &materialids) const;
                
                virtual void CalcResidual(TPZElementMatrix &ef);
                
                static void Chebyshev(REAL x,int num,TPZFMatrix<REAL> &phi,TPZFMatrix<REAL> &dphi);
                
                virtual void Divide(int64_t index, TPZVec<int64_t> &subindex, int interpolate = 0);
                
                virtual void ProjectFlux(TPZElementMatrix &ek,TPZElementMatrix &ef);
                
    virtual void EvaluateError(std::function<void(const TPZVec<REAL> &loc,TPZVec<STATE> &val,TPZFMatrix<STATE> &deriv)> func,
                                                                                                                   TPZVec<REAL> &errors, bool store_error);
                
                virtual void ComputeError(int errorid, TPZVec<REAL> &error){
                                PZError << "Error at " << __PRETTY_FUNCTION__ << " - Method not implemented.\n";
                }
                
                virtual void CreateGraphicalElement(TPZGraphMesh & graphmesh, int dimension);
                
                virtual void Integrate(int variable, TPZVec<STATE> & value){
                                value.Fill(0.);
                                PZError << "Error at " << __PRETTY_FUNCTION__ << " - Method not implemented.\n";
                }
    
    virtual void GetMemoryIndices(TPZVec<int64_t> &indices) const
    {
        indices.resize(0);
    }
    
    virtual void SetMemoryIndices(TPZVec<int64_t> &indices)
    {
        if(indices.size() != 0)
        {
            DebugStop();
        }
    }
                
    virtual void PrepareIntPtIndices(){
        
    }
  
                virtual void ForcePrepareIntPtIndices(){
    
  }
  
                virtual void SetFreeIntPtIndices(){
    
  }


                virtual int NumberOfCompElementsInsideThisCompEl(){
                                return 1;
                }
    
    virtual void TransferMultiphysicsElementSolution()
    {
        // Nothing to be done here
    }
    
    virtual void SetMultiphysicsElementSolution()
    {
        DebugStop();
    }
                
    virtual void AddShapeRestraint(TPZOneShapeRestraint restraint)
    {
        DebugStop();
    }

    virtual std::list<TPZOneShapeRestraint> GetShapeRestraints() const
    {
        std::list<TPZOneShapeRestraint> loc;
        return loc;
    }

    virtual void ResetShapeRestraints()
    {
    }
                virtual void Solution(TPZVec<REAL> &qsi,int var,TPZVec<STATE> &sol);
    
    virtual TPZVec<STATE> IntegrateSolution(int var) const;
    
    virtual TPZVec<STATE> IntegrateSolution(const std::string &varname, const std::set<int> &matids);
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi, TPZMaterialData &data)          {
                                std::cout <<"Imposed for Hdiv solution ";
                                DebugStop();
                };
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZSolVec &sol, TPZGradSolVec &dsol,TPZFMatrix<REAL> &axes);
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZVec<REAL> &normal,
                                                                                                                                 TPZSolVec &leftsol, TPZGradSolVec &dleftsol,TPZFMatrix<REAL> &leftaxes,
                                                                                                                                 TPZSolVec &rightsol, TPZGradSolVec &drightsol,TPZFMatrix<REAL> &rightaxes);
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphix,
                                                                                                                                 const TPZFMatrix<REAL> &axes, TPZSolVec &sol, TPZGradSolVec &dsol);
    
    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const = 0;

//protected:
                virtual void BuildConnectList(std::set<int64_t> &indepconnectlist, std::set<int64_t> &depconnectlist);
public:
                virtual void BuildConnectList(TPZStack<int64_t> &connectlist) const;
//protected:
                virtual void BuildConnectList(std::set<int64_t> &connectlist);
public:
                
                virtual int HasDependency();
                
    virtual int PressureConnectIndex() const;

                virtual void ReduceInternalNodes() { }
                
                virtual void SetConnectIndex(int inode, int64_t index) = 0;
                
                virtual void CalcBlockDiagonal(TPZStack<int64_t> &connectlist, TPZBlockDiagonal<STATE> & block);
                
                REAL MaximumRadiusOfEl();
                
                REAL LesserEdgeOfEl();
                
                void Write(TPZStream &buf, int withclassid) const override;
                
                void Read(TPZStream &buf, void *context) override;
                 
private:
    
    static int gOrder;
    
protected:
    
    TPZIntPoints *fIntegrationRule;
    
public:
    
    virtual void InitializeIntegrationRule(){
        std::cout << "TPZCompEl::InitializeIntegrationRule should not be called\n";
        DebugStop();
    }
    
    
    virtual int ComputeIntegrationOrder() const;
    
    virtual void SetIntegrationRule(TPZIntPoints *intrule);
    
    virtual void SetIntegrationRule(int order) {
        std::cout << "TPZCompEl::SetIntegrationRule should not be called\n";
    }
    
    virtual const TPZIntPoints &GetIntegrationRule() const
    {
        if(fIntegrationRule)
                                                return *fIntegrationRule;
        DebugStop();
                                return *fIntegrationRule;
    }


};


class TPZGeoElSide;

class TPZCompElSide {
                
                TPZCompEl *fEl;
                
                int fSide;
    
                
public:

    TPZCompElSide() : fEl(0), fSide(-1)
    {
        
    }
                
    TPZCompElSide(const TPZCompElSide &celside) : fEl(celside.fEl), fSide(celside.fSide)
    {
        
    }
                
    TPZCompElSide(TPZCompEl *cel,int side) : fEl(cel), fSide(side)
    {
        
    }
    
    TPZCompElSide(int zero) : fEl(0), fSide(-1)
    {
    }
                
                TPZCompEl *Element() const {return fEl;}
    
    operator bool() const
    {
        return fEl != 0;
    }

                
                void SetElement(TPZCompEl* el){ fEl = el;}
                
                int Side() const {return fSide;}
                
                void SetSide(int side);
                
                int Exists() const {return fEl != 0;}
                
                TPZGeoElSide Reference() const;
                
                void HigherLevelElementList(TPZStack<TPZCompElSide> &elsidevec, int onlyinterpolated, int removeduplicates);
                
                void HigherDimensionElementList(TPZStack<TPZCompElSide> &elsidevec, int onlyinterpolated, int removeduplicates);
                void ConnectedElementList(TPZStack<TPZCompElSide> &elsidevec,int onlyinterpolated, int removeduplicates);
                
                void EqualLevelElementList(TPZStack<TPZCompElSide> &elsidevec, int onlyinterpolated, int removeduplicates);
                
                TPZCompElSide LowerLevelElementList(int onlyinterpolated);
                
                static void RemoveDuplicates(TPZStack<TPZCompElSide> &elvec);
                
                
                static void RemoveConnectDuplicates(TPZStack<TPZCompElSide> &expandvec);
                
                void ExpandConnected(TPZStack<TPZCompElSide> &expandvec,int onlyinterpolated);
                
                TPZCompElSide LowerIdElementList(TPZCompElSide &expandvec,int onlyinterpolated);

    int64_t ConnectIndex() const;
                
                bool operator != (const TPZCompElSide &other);
                bool operator == (const TPZCompElSide &other);

};

inline void TPZCompEl::CreateGraphicalElement(TPZGraphMesh &, int) {
                std::cout << "TPZCompEl::CreateGraphicalElement called\n";
                this->Print(std::cout);
}

inline void TPZCompEl::Assemble(){
    std::cout << "TPZCompEl::Assemble is called." << std::endl;
}

inline void TPZCompEl::CalcStiff(TPZElementMatrix &,TPZElementMatrix &){
                std::cout << "TPZCompEl::CalcStiff(*,*) is called." << std::endl;
}

inline void TPZCompEl::ProjectFlux(TPZElementMatrix &ek,TPZElementMatrix &ef) {
                std::cout << "TPZCompEl::ProjectFlux is called." << std::endl;
}

inline bool TPZCompElSide::operator != (const TPZCompElSide &other)
{
                return (other.Element() != Element() || other.Side() != Side());
}

inline bool TPZCompElSide::operator == (const TPZCompElSide &other)
{
                return (other.Element() == Element() && other.Side() == Side());
}

inline std::ostream &operator << (std::ostream &out,const TPZCompElSide &celside)
{
                out << "Side = " << celside.Side()
                << " element: " << celside.Element()->Index()
                << std::endl;
                return out;
}

inline int64_t TPZCompEl::Index() const {
                return fIndex;
}

inline void TPZCompEl::SetgOrder( int order )
{
                gOrder = order;
}

inline int TPZCompEl::GetgOrder( )
{
                return gOrder;
}

#endif