pzmultiphysicscompel.h

Go to the documentation of this file.

#ifndef PZMULTIPHYSICCOMPELH
#define PZMULTIPHYSICCOMPELH 

#include <iostream>

#include "pzmultiphysicselement.h"
#include "pzmaterialdata.h"

#include "pzelctemp.h"
#include "pzreducedspace.h"

template<class T>
class TPZTransform;

template <class TGeometry>
class TPZMultiphysicsCompEl : public TPZMultiphysicsElement {
                
protected:
                
                TPZManVector<TPZCompElSide ,5>                  fElementVec;
                
                TPZVec<int64_t> fConnectIndexes;
    
    typename TGeometry::IntruleType fIntRule;
    
    
                
public:
                TPZMultiphysicsCompEl(TPZCompMesh &mesh, TPZGeoEl *gel, int64_t &index);
                TPZMultiphysicsCompEl();
  
    TPZMultiphysicsCompEl(TPZCompMesh &mesh, const TPZMultiphysicsCompEl<TGeometry> &copy);
                TPZMultiphysicsCompEl(TPZCompMesh &mesh,
              const TPZMultiphysicsCompEl<TGeometry> &copy,
              std::map<int64_t,int64_t> & gl2lcConMap,
              std::map<int64_t,int64_t> & gl2lcElMap);
  
                virtual ~TPZMultiphysicsCompEl();
                
                virtual TPZManVector<TPZCompElSide,5>   &ElementVec() override { return fElementVec; }
                
                virtual void AffineTransform(TPZVec<TPZTransform<> > &trVec) const override;

    virtual void EvaluateError(std::function<void(const TPZVec<REAL> &loc,TPZVec<STATE> &val,TPZFMatrix<STATE> &deriv)> func,
                               TPZVec<REAL> &errors, bool store_error ) override;
    
    virtual void EvaluateError(TPZFunction<STATE> &func,
                               TPZVec<STATE> &errors, bool store_error) override;
    

                void GetReferenceIndexVec(TPZManVector<TPZCompMesh *> cmeshVec, std::set<int64_t> &refIndexVec);

                virtual TPZCompEl *Clone(TPZCompMesh &mesh) const override;
                
                virtual TPZCompEl *ClonePatchEl(TPZCompMesh &mesh,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcConMap,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap) const override;
                
                virtual int NConnects() const override;
                
    virtual int64_t NMeshes() override
    {
        return fElementVec.size();
    }
    
                virtual int64_t ConnectIndex(int i) const override;
    
    virtual int64_t ConnectIndex(int elem, int connect) const ;
                
                virtual int Dimension() const override;

    virtual void PolynomialOrder(TPZVec<int> &order) const override;

                virtual void Integrate(int variable, TPZVec<STATE> & value) override;
                
    virtual void ComputeRequiredData(TPZVec<REAL> &point, TPZVec<TPZTransform<> > &trvec, TPZVec<TPZMaterialData> &datavec);

    virtual void ComputeRequiredData(TPZMaterialData &data, TPZVec<REAL> &point) override
    {
        TPZMultiphysicsElement::ComputeRequiredData(data, point);
    }

                virtual void Solution(TPZVec<REAL> &qsi,int var,TPZVec<STATE> &sol) override;
                
    virtual TPZVec<STATE> IntegrateSolution(int var) const override;

    
                virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZSolVec &sol, TPZGradSolVec &dsol,TPZFMatrix<REAL> &axes) override;
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZVec<REAL> &normal,
                                                                                                                                 TPZSolVec &leftsol, TPZGradSolVec &dleftsol,TPZFMatrix<REAL> &leftaxes,
                                                                                                                                 TPZSolVec &rightsol, TPZGradSolVec &drightsol,TPZFMatrix<REAL> &rightaxes) override;
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphix,
                                                                                                                                 const TPZFMatrix<REAL> &axes, TPZSolVec &sol, TPZGradSolVec &dsol) override;
                
                virtual void SetConnectIndex(int inode, int64_t index) override;
                
                
                virtual void SetCreateFunctions(TPZCompMesh *mesh) override;
    
    virtual void AddElement(TPZCompEl *cel, int64_t meshindex) override
    {
                                if (fElementVec.size() <= meshindex) 
                                {
                                                fElementVec.resize(meshindex+1);
            fActiveApproxSpace.Resize(meshindex+1, 1);
                                }
        if (cel)
        {
            TPZGeoEl *gel = cel->Reference();
            TPZCompElSide celside(cel,gel->NSides()-1);
            fElementVec[meshindex] = celside;
        }
        else
        {
            fElementVec[meshindex] = TPZCompElSide();
        }
    }
    
    virtual void AddElement(const TPZCompElSide &celside, int64_t meshindex) override
    {
        if (fElementVec.size() <= meshindex)
        {
            fElementVec.resize(meshindex+1);
            fActiveApproxSpace.Resize(meshindex+1, 1);
        }
        fElementVec[meshindex] = celside;
    }
    
    virtual TPZCompEl *Element(int64_t elindex) override
    {
        return fElementVec[elindex].Element();
    }
                
                virtual TPZCompEl *ReferredElement(int64_t mesh) override
                {
                                
#ifdef PZDEBUG
                                if (fElementVec.size() <= mesh) {
                                                PZError << "Error at " << __PRETTY_FUNCTION__ << " index does not exist!\n";
                                                DebugStop();
                                };
#endif
                                
                                return fElementVec[mesh].Element();
                }
                
                
                virtual void SetConnectIndexes(TPZVec<int64_t> &indexes) override
                {
                                fConnectIndexes = indexes;
                }
                
                virtual void Print(std::ostream &out = std::cout) const override;
                
                virtual void CalcStiff(TPZElementMatrix &ek, TPZElementMatrix &ef) override;
                
    virtual void CalcResidual(TPZElementMatrix &ef) override;
    
                void InitializeElementMatrix(TPZElementMatrix &ek, TPZElementMatrix &ef);
                
    void InitializeElementMatrix(TPZElementMatrix &ef);
    
                void InitMaterialData(TPZVec<TPZMaterialData > &dataVec, TPZVec<int64_t> *indices = 0) override;
                
                virtual void CreateGraphicalElement(TPZGraphMesh &grmesh, int dimension) override;
                
                //virtual void CreateGraphicalElement(TPZGraphMesh &grmesh, std::set<int> dimension, std::set<int> MaterialID);
  
    virtual void SetIntegrationRule(int int_order) override;
    
    virtual void InitializeIntegrationRule() override;
    
    virtual const TPZIntPoints &GetIntegrationRule() const override;
    
    virtual TPZIntPoints &GetIntegrationRule() override;
                
                virtual int NumberOfCompElementsInsideThisCompEl() override {
                                return fElementVec.NElements();
                }               
    public:
virtual int ClassId() const override;

};


TPZCompEl *CreateMultiphysicsPointEl(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsLinearEl(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsQuadEl(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsTriangleEl(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsCubeEl(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsPrismEl(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsPyramEl(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsTetraEl(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

//--------------------- WITH MEMORY ----------------------

TPZCompEl *CreateMultiphysicsPointElWithMem(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsLinearElWithMem(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsQuadElWithMem(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsTriangleElWithMem(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsCubeElWithMem(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsPrismElWithMem(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsPyramElWithMem(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

TPZCompEl *CreateMultiphysicsTetraElWithMem(TPZGeoEl *gel,TPZCompMesh &mesh,int64_t &index);

#include "pzcmesh.h"

template<class TGeometry>
void TPZMultiphysicsCompEl<TGeometry>::SetCreateFunctions(TPZCompMesh* mesh) {
    mesh->SetAllCreateFunctionsMultiphysicElem();
}

#endif