pzelast3d.h

Go to the documentation of this file.

#ifndef PZELAST3D
#define PZELAST3D

#include <iostream>
#include "TPZMaterial.h"
#include "pzfmatrix.h"
#include "pzvec.h"
#include <vector>


class TPZElasticity3D : public TPZMaterial {
    
    private:
    
    enum PLASTICPOSTPROC{ENonePlasticProc = -1, EVonMises = 0, EMohrCoulomb = 1};
    
    STATE VonMisesPlasticFunction( TPZFMatrix<STATE> & StressTensor) const;
    
    STATE MohrCoulombPlasticFunction( TPZFMatrix<STATE> & StressTensor) const;
    
    void Invariants( TPZFMatrix<STATE> & A, STATE & I1, STATE & I2, STATE & I3) const;
    
    void StressDecomposition( TPZFMatrix<STATE> & StressTensor, TPZFMatrix<STATE> & Deviator, STATE & p) const;
                
                public :
                
                enum SOLUTIONVARS {ENone = -1, EDisplacement = 0, EDisplacementX, EDisplacementY, EDisplacementZ,
                                EPrincipalStress, EPrincipalStrain, EPrincipalDirection1, EPrincipalDirection2, EPrincipalDirection3,
                                EVonMisesStress, EStress, EStrain, EStrain1, EStress1, ENormalStress, ENormalStrain, EStressX, EStressY, EStressZ,
        EI1, EI2, EI3, EPlasticFunction};
    

                
                TPZElasticity3D(int nummat, STATE E, STATE poisson, TPZVec<STATE> &force,
                    STATE preStressXX = 0., STATE preStressYY = 0., STATE preStressZZ = 0.);
    
                TPZElasticity3D(int nummat);
    
                TPZElasticity3D();
    
                TPZElasticity3D(const TPZElasticity3D &cp);
                
                virtual ~TPZElasticity3D();
                
                int Dimension() const  override { return 3;}
                
                int NStateVariables() const override { return 3;}
                
    virtual int IntegrationRuleOrder(int elPMaxOrder) const override
    {
        return 2*(elPMaxOrder);
    }

                virtual void Print(std::ostream & out) override;
                
                void SetPostProcessingDirection(TPZVec<REAL> &Direction){
                                if (Direction.NElements() != 3){
                                                PZError << __PRETTY_FUNCTION__ << " - ERROR!\n";
                                }
                                this->fPostProcessDirection.Resize(3);
                                for(int i = 0; i < 3; i++) this->fPostProcessDirection[i] = Direction[i];
                }
                
                void SetVonMises(REAL fy){
      this->fFy = fy;
        this->fFrictionAngle = 0.;
        this->fCohesion = 0.;
        this->fPlasticPostProc = EVonMises;
    }
                
    void SetMohrCoulomb(REAL fc, REAL ft){
        this->fFy = 0.;
        this->fFrictionAngle = asin( (fc-ft)/(fc+ft) );
        this->fCohesion = fc*ft/(fc-ft) * tan(fFrictionAngle);
        this->fPlasticPostProc = EMohrCoulomb;
    }
    
                virtual std::string Name() override { return "TPZElasticity3D"; }
                
                virtual void Contribute(TPZMaterialData &data,
                                                                                                                REAL weight,
                                                                                                                TPZFMatrix<STATE> &ek,
                                                                                                                TPZFMatrix<STATE> &ef) override;
    
                virtual void Contribute(TPZMaterialData &data,
                                                                                                                REAL weight,
                                                                                                                TPZFMatrix<STATE> &ef) override
                {
                                TPZMaterial::Contribute(data,weight,ef);
                }
    
    virtual void ContributeVecShape(TPZMaterialData &data,REAL weight,TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef);
                
                virtual void ContributeBC(TPZMaterialData &data,
                                                                                                                  REAL weight,
                                                                                                                  TPZFMatrix<STATE> &ek,
                                                                                                                  TPZFMatrix<STATE> &ef,
                                                                                                                  TPZBndCond &bc) override;
    
    virtual 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
                {
                                TPZMaterial::ContributeBC(data,weight,ef,bc);
                }
                
                virtual int VariableIndex(const std::string &name) override;
                
                virtual int NSolutionVariables(int var) override;
protected:
                virtual void Solution(TPZVec<STATE> &Sol,TPZFMatrix<STATE> &DSol,TPZFMatrix<REAL> &axes,int var,TPZVec<STATE> &Solout) override;
public:
                virtual void Solution(TPZMaterialData &data, int var, TPZVec<STATE> &Solout) override
                {
                                TPZMaterial::Solution(data,var,Solout);
                }
                
                virtual int NFluxes()  override {
                                PZError << "\nTPZElasticity3D::NFluxes() - Method not implemented\n";
                                return 0;
                }
                
                virtual void Flux(TPZVec<REAL> &x, TPZVec<STATE> &Sol, TPZFMatrix<STATE> &DSol, TPZFMatrix<REAL> &axes, TPZVec<STATE> &flux) override {
                                PZError << "\nTPZElasticity3D::Flux - Method not implemented\n";
                }
                
                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;
                virtual int NEvalErrors() override {return 3;}
                
                void FillDataRequirements(TPZMaterialData &data) override;
                
    virtual void FillBoundaryConditionDataRequirement(int type,TPZMaterialData &data) override
    {
        // default is no specific data requirements
        if(type == 50)
        {
            data.fNeedsSol = true;
        }
        data.fNeedsNormal = true;
    }

                void SetMaterialDataHook(REAL Ela, REAL poisson)
                {
                                fE = Ela;
                                fPoisson = poisson;
        SetC();
                }
                
                void SetMaterialDataLame(REAL lambda, REAL mu)
                {
                                fE = mu*((REAL(3))*lambda+((REAL(2))*mu))/(lambda + mu);
                                fPoisson = lambda/((REAL(2))*(lambda + mu));
        SetC();
                }
                
                void SetC()
                {
                                C1 = fE / (2.+ 2.*fPoisson);
                                C2 = fE * fPoisson / (-1. + fPoisson + 2.*fPoisson*fPoisson);
                                C3 = fE * (fPoisson - 1.) / (-1. + fPoisson +2. * fPoisson * fPoisson);
                }
                
                void SetForce(TPZVec <STATE> force)
                {
                                for(int i = 0; i < 3; i++) this->fForce[i] = force[i];
                }
    
    STATE GetE()
    {
        return fE;
    }
    
    STATE GetPoisson()
    {
        return fPoisson;
    }
    
    STATE GetLambda()
    {
        STATE lambda = (fPoisson*fE)/((1.+fPoisson)*(1.-2.*fPoisson));
        return lambda;
    }
    
    STATE GetMU()
    {
        STATE mu = fE/(2.*(1.+fPoisson));
        return mu;
    }
    
    STATE GetPrestress(int index)
    {
        return this->fPreStress[index];
    }
                
                protected :
                
                STATE fE;
                
                STATE fPoisson;
                
                REAL C1; 
                REAL C2; 
                REAL C3; 
                TPZManVector<STATE,3> fForce;
                
                TPZManVector<REAL,3> fPostProcessDirection;
                
                REAL fFy;
    
    REAL fFrictionAngle, fCohesion;
    
    PLASTICPOSTPROC fPlasticPostProc;
    
    TPZManVector<REAL> fPreStress;//just prestress XX, YY and ZZ
                
public:
                virtual void ComputeStressVector(TPZFMatrix<STATE> &Stress, TPZFMatrix<STATE> &DSol) const;
                void ComputeStrainVector(TPZFMatrix<STATE> &Strain, TPZFMatrix<STATE> &DSol) const;
                virtual void ComputeStressTensor(TPZFMatrix<STATE> &Stress, TPZMaterialData &data) const;
    void ComputeStressTensor(TPZFMatrix<STATE> &Stress, TPZFMatrix<STATE> &DSol) const;
                void ComputeStrainTensor(TPZFMatrix<STATE> &Strain, TPZFMatrix<STATE> &DSol) const;
                void ApplyDirection(TPZFMatrix<STATE> &StrVec, TPZVec<STATE> &Out) const;
                void PrincipalDirection(TPZFMatrix<STATE> &DSol, TPZVec< STATE > &Solout, int direction) const;
                
public:
                virtual void Write(TPZStream &buf, int withclassid) const override;
                
                virtual void Read(TPZStream &buf, void *context) override;
                public:
virtual int ClassId() const override;

                virtual TPZMaterial * NewMaterial()  override { return new TPZElasticity3D(*this);}
                
                static STATE gTolerance;
                
};

#endif