pzelasmat.h

Go to the documentation of this file.

#ifndef ELASMATHPP
#define ELASMATHPP

#include <iostream>

#include "TPZMaterial.h"
#include "pzdiscgal.h"


class TPZElasticityMaterial : public TPZDiscontinuousGalerkin {
                
                public :

                TPZElasticityMaterial();
                TPZElasticityMaterial(int id, REAL E, REAL nu, REAL fx, REAL fy, int planestress = 1);
    
    TPZElasticityMaterial(int id);
                
                TPZElasticityMaterial(const TPZElasticityMaterial &copy);
                
                virtual TPZMaterial * NewMaterial()  override { return new TPZElasticityMaterial(*this);}
                
                virtual ~TPZElasticityMaterial();
                
    void SetElasticity(REAL E, REAL nu)
    {
        fE_def  = E;  // Young modulus
        fnu_def = nu;   // poisson coefficient

    }
    
    void SetElasticityFunction(TPZAutoPointer<TPZFunction<STATE> > func)
    {
        fElasticity = func;
    }
    
    void SetPlaneStrain()
    {
        fPlaneStress = 0;
    }
    
    void SetPlaneStress()
    {
        fPlaneStress = 1;
    }
    
    void SetBodyForce(REAL fx, REAL fy)
    {
        ff[0] = fx;
        ff[1] = fy;
        ff[2] = 0.;
    }
                int Dimension() const  override { return 2;}
                
                virtual  int NStateVariables() const override;
                
                virtual void Print(std::ostream & out = std::cout) override;
                
                std::string Name()  override { return "TPZElasticityMaterial"; }
                
                virtual short NumberOfFluxes(){return 3;}
                
                virtual int NFluxes() override { return 3;}
                                
                virtual void Contribute(TPZMaterialData &data, REAL weight,TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef) override;

    virtual void Contribute(TPZVec<TPZMaterialData> &data, REAL weight,TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef) override;

//    virtual void Contribute(TPZVec<TPZMaterialData> &data, REAL weight, TPZFMatrix<STATE> &ef)
//    {
//        DebugStop();
//    }
    
    void ContributeVecShape(TPZMaterialData &data,REAL weight,TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef);
                
                virtual void Contribute(TPZMaterialData &data, REAL weight,TPZFMatrix<STATE> &ef) override
                {
                                TPZDiscontinuousGalerkin::Contribute(data,weight,ef);
                }
                
    
    virtual void ContributeBC(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef, TPZBndCond &bc) override;

                virtual void ContributeBC(TPZMaterialData &data,REAL weight,
                                                                                                                  TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override;
    
    void ContributeVecShapeBC(TPZMaterialData &data,REAL weight,
                              TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc);
                
                virtual void ContributeBC(TPZMaterialData &data,REAL weight,
                                                                                                                  TPZFMatrix<STATE> &ef,TPZBndCond &bc) override
                {
                                TPZDiscontinuousGalerkin::ContributeBC(data,weight,ef,bc);
                }
    
    //virtual void FillDataRequirements(TPZMaterialData &data);
     virtual void FillDataRequirements(TPZMaterialData &data) override;
    virtual void FillBoundaryConditionDataRequirement(int type, TPZMaterialData &data) override;
        
     
    
                virtual void ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override {
                                PZError << "\nFATAL ERROR - Method not implemented: " << __PRETTY_FUNCTION__ << "\n";
                }
                
                virtual void ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override {
                                PZError << "\nFATAL ERROR - Method not implemented: " << __PRETTY_FUNCTION__ << "\n";
                }
                
                virtual void ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight, TPZFMatrix<STATE> &ef) override {
                                PZError << "\nFATAL ERROR - Method not implemented: " << __PRETTY_FUNCTION__ << "\n";
                }
                
                virtual void ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &left, REAL weight, TPZFMatrix<STATE> &ef,TPZBndCond &bc) override {
                                PZError << "\nFATAL ERROR - Method not implemented: " << __PRETTY_FUNCTION__ << "\n";
                }
                
                virtual int VariableIndex(const std::string &name) override;
                
                virtual int NSolutionVariables(int var) override;
    
    STATE GetLambda(REAL E, REAL nu) const
    {
        STATE lambda = (nu*E)/((1.+nu)*(1.-2.*nu));
        return lambda;
    }
    
    STATE GetMU(REAL E, REAL nu) const
    {
        STATE mu = E/(2.*(1.+nu));
        return mu;
    }
                
public:

    virtual void Solution(TPZMaterialData &data, int var, TPZVec<STATE> &Solout) override;
    
                virtual void SolutionDisc(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, int var, TPZVec<STATE> &Solout)
                {
                                TPZDiscontinuousGalerkin::SolutionDisc(data,dataleft,dataright,var,Solout);
                }

                virtual void Flux(TPZVec<REAL> &x, TPZVec<STATE> &Sol, TPZFMatrix<STATE> &DSol, TPZFMatrix<REAL> &axes, TPZVec<STATE> &flux) override;
                
    virtual int NEvalErrors() override {return 6;}
    

    
                virtual void Errors(TPZVec<REAL> &x,TPZVec<STATE> &u,
                                                                TPZFMatrix<STATE> &dudx, TPZFMatrix<REAL> &axes, TPZVec<STATE> &flux,
                                                                TPZVec<STATE> &u_exact,TPZFMatrix<STATE> &du_exact,TPZVec<REAL> &values) override;//Cedric
                
                REAL E() {return fE_def;}
                
                REAL Nu() {return fnu_def;}
                
                void SetPreStress(REAL Sigxx, REAL Sigyy, REAL Sigxy, REAL Sigzz);
    
                public:
virtual int ClassId() const override;

                
                virtual void Read(TPZStream &buf, void *context) override;
                
                virtual void Write(TPZStream &buf, int withclassid) const override;
                
                
                
protected:
                REAL fE_def;
                
                REAL fnu_def;
                
    TPZAutoPointer<TPZFunction<STATE> > fElasticity;
    
                TPZManVector<STATE,3> ff;
                
                REAL fEover21PlusNu_def;
                
                REAL fEover1MinNu2_def;
                
                REAL fPreStressXX;
                
                REAL fPreStressYY;
                
                REAL fPreStressXY;
    
    REAL fPreStressZZ;
                
                int fPlaneStress;
    
};

#endif