pzelementgroup.h

Go to the documentation of this file.

#ifndef TPZElementGroupH
#define TPZElementGroupH

#include "pzcompel.h"
#include "pzmatred.h"
#include "pzmanvector.h"
#include "pzelmat.h"
#include "TPZOneShapeRestraint.h"

class TPZElementGroup : public TPZCompEl
{

protected:
    TPZStack<TPZCompEl *,5> fElGroup;
    TPZManVector<int64_t,27> fConnectIndexes;
    std::map<int64_t,TPZOneShapeRestraint> fRestraints;

public:
    
    TPZElementGroup();
    
    TPZElementGroup(TPZCompMesh &mesh, int64_t &index) : TPZRegisterClassId(&TPZElementGroup::ClassId),
    TPZCompEl(mesh,0,index), fElGroup(), fConnectIndexes()
    {
        
    }
    
    TPZElementGroup(TPZCompMesh &mesh, const TPZElementGroup &copy);
    
    virtual ~TPZElementGroup();
    
    virtual void AddElement(TPZCompEl *cel);

                virtual void Print(std::ostream &out = std::cout) const override
    {
        out << __PRETTY_FUNCTION__ << std::endl;
        TPZCompEl::Print(out);
        out << "comp and geom indexes :";
        int nel = fElGroup.size();
        for (int el=0; el<nel; el++) {
            int64_t cindex = fElGroup[el]->Index();
            TPZGeoEl *gel = fElGroup[el]->Reference();
            int64_t gindex = -1;
            if(gel) gindex = gel->Index();
            out << " " << cindex << "|" << gindex;
//            fElGroup[el]->Print(out);
        }
        out << std::endl;
        out << "End of " << __PRETTY_FUNCTION__ << std::endl;
    }

    void Unwrap();
    
                virtual int Dimension() const override
    {
        int dimension = -1;
        int nel = fElGroup.size();
        for (int el = 0; el<nel; el++) {
            int eldim = fElGroup[el]->Dimension();
            dimension = dimension < eldim ? eldim : dimension;
        }
        return dimension;
    }
                
    bool NeedsComputing(const std::set<int> &matids) override;
    

    TPZStack<TPZCompEl *, 5> GetElGroup(){
        return fElGroup;
    }
    
                virtual int NConnects() const override
    {
        return fConnectIndexes.size();
    }
    
    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const override
    {
        int nel = fElGroup.size();
        for (int el=0; el<nel; el++) {
            fElGroup[el]->BuildCornerConnectList(connectindexes);
        }
    }

                
                virtual int64_t ConnectIndex(int i) const override 
    {
        return fConnectIndexes[i];
    }

                virtual TPZCompEl *Clone(TPZCompMesh &mesh) const override
    {
        return new TPZElementGroup(mesh,*this);
    }
    
    virtual void SetConnectIndex(int inode, int64_t index) override;


                virtual void LoadSolution() override
    {
        int nel = fElGroup.size();
        for (int el=0; el<nel; el++) {
            fElGroup[el]->LoadSolution();
        }
    }
    
    virtual void LoadElementReference() override
    {
        int nel = fElGroup.size();
        for (int el=0; el<nel; el++) {
            fElGroup[el]->LoadElementReference();
        }

    }
    TPZVec<STATE> IntegrateSolution(const std::string &varname, const std::set<int> &matids) override
    {
        TPZManVector<STATE,3> result;
        int nel = fElGroup.size();
        for (int el=0; el<nel; el++) {
            TPZManVector<STATE,3> locres;
            locres = fElGroup[el]->IntegrateSolution(varname, matids);
            if (!result.size()) {
                result = locres;
            } else if(result.size() && result.size() == locres.size())
            {
                int nvar = result.size();
                for (int iv = 0; iv<nvar; iv++) {
                    result[iv] += locres[iv];
                }
            }
            else if(result.size() && locres.size() && result.size() != locres.size())
            {
                DebugStop();
            }
        }
        return result;
    }
    
    virtual TPZVec<STATE> IntegrateSolution(int var) const override
    {
        TPZManVector<STATE,3> result;
        int nel = fElGroup.size();
        for (int el=0; el<nel; el++) {
            TPZManVector<STATE,3> locres;
            locres = fElGroup[el]->IntegrateSolution(var);
            if (!result.size()) {
                result = locres;
            } else if(result.size() && result.size() == locres.size())
            {
                int nvar = result.size();
                for (int iv = 0; iv<nvar; iv++) {
                    result[iv] += locres[iv];
                }
            }
            else if(result.size() && locres.size() && result.size() != locres.size())
            {
                DebugStop();
            }
        }
        return result;
    }


    virtual void TransferMultiphysicsElementSolution() override
    {
        int nel = fElGroup.size();
        for (int el=0; el<nel; el++) {
            fElGroup[el]->TransferMultiphysicsElementSolution();
        }
    }


                virtual TPZCompEl *ClonePatchEl(TPZCompMesh &mesh,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcConMap,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap) const override;

public:
    
                virtual void CreateGraphicalElement(TPZGraphMesh & graphmesh, int dimension) override
    {
        int nel = fElGroup.size();
        for (int el=0; el<nel; el++) {
            fElGroup[el]->CreateGraphicalElement(graphmesh,dimension);
        }
    }
                
                virtual void Integrate(int variable, TPZVec<STATE> & value) override{
        int nel = fElGroup.size();
        for (int el=0; el<nel; el++) {
            fElGroup[el]->Integrate(variable,value);
        }
                }
    

                virtual void CalcStiff(TPZElementMatrix &ek,TPZElementMatrix &ef) 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 bool HasMaterial(const std::set<int> &materialids) const override;
    
                virtual void CalcResidual(TPZElementMatrix &ef) override;

    int ComputeIntegrationOrder() const override {
        std::cout << "This method should not be called. " << __PRETTY_FUNCTION__ << std::endl;
        DebugStop();
                                return 0;
    }
    
    public:
virtual int ClassId() const override;

protected:
    
    void InitializeElementMatrix(TPZElementMatrix &ek, TPZElementMatrix &ef) const;

    void InitializeElementMatrix(TPZElementMatrix &ef) const;

};

#endif