TPZMixedElasticityMaterial.h

Go to the documentation of this file.

#ifndef MIXEDELASMATHPP
#define MIXEDELASMATHPP

#include <iostream>

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

class TPZMixedElasticityMaterial : public TPZDiscontinuousGalerkin {

    struct TElasticityAtPoint
    {
        REAL fE;
        
        REAL fnu;
        
        REAL flambda;
        
        REAL fmu;

        TElasticityAtPoint(REAL E, REAL nu) : fE(E), fnu(nu)
        {
            flambda = (E * nu) / ((1 + nu)*(1 - 2 * nu));
            fmu = E / (2 * (1 + nu));
        }
    };



public:

    enum MVoigt {
        Exx, Eyy, Exy, Eyx
    };

    TPZMixedElasticityMaterial();
    TPZMixedElasticityMaterial(int id, REAL E, REAL nu, REAL fx, REAL fy, int planestress = 1, int fDimension = 1);


    TPZMixedElasticityMaterial(int id);

    TPZMixedElasticityMaterial(const TPZMixedElasticityMaterial &copy);


    virtual int VariableIndex(const std::string &name) override;


    virtual int NSolutionVariables(int var) override;

    int SIndex() {
        return 0;
    }

    int UIndex() {
        return 1;
    }

    int PIndex() {
        return 2;
    }

    virtual int NEvalErrors() override;
    
    void ComputeDivergenceOnDeformed(TPZVec<TPZMaterialData> &datavec, TPZFMatrix<STATE> &DivergenceofPhi);

    void ComputeDeformationVector(TPZVec<STATE> &PhiStress, TPZVec<STATE> &APhiStress, TElasticityAtPoint &elastb);

    void ComputeStressVector(TPZVec<STATE> &Deformation, TPZVec<STATE> &Stress,  TElasticityAtPoint &elast);

    void ElasticityModulusTensor(TPZFMatrix<STATE> &MatrixElast, TElasticityAtPoint &elast);

    virtual TPZMaterial * NewMaterial()  override {
        return new TPZMixedElasticityMaterial(*this);
    }

    virtual ~TPZMixedElasticityMaterial();

    void SetElasticParameters(REAL Eyoung, REAL nu) {
        this->SetElasticity(Eyoung, nu);
    }

    void SetElasticity(REAL E, REAL nu) {
        fE_const = E; // Young modulus
        fnu_const = nu; // poisson coefficient
        flambda_const = (E * nu) / ((1 + nu)*(1 - 2 * nu));
        fmu_const = E / (2 * (1 + nu));

    }

    void SetElasticityFunction(TPZAutoPointer<TPZFunction<STATE> > func)
    {
        fElasticity = func;
    }
    
    void SetLameParameters(REAL Lambda, REAL mu) {
        fE_const = (mu * (3.0 * Lambda + 2.0 * mu)) / (Lambda + mu);
        fnu_const = (Lambda) / (2 * (Lambda + mu));

        flambda_const = Lambda;
        fmu_const = mu;
    }


    void SetAxisSymmetric() {
        fAxisSymmetric = 1;
    }

    void SetPlaneStrain() {
        fPlaneStress = 0;
    }


    void SetPlaneStress() {
        fPlaneStress = 1;
    }

    void SetBodyForce(REAL fx, REAL fy) {
        fForce[0] = fx;
        fForce[1] = fy;
        fForce[2] = 0.;
    }

    int Dimension() const  override {
        return 2;
    }

    virtual int NStateVariables() const override;

    virtual void Print(std::ostream & out = std::cout) override;

    virtual std::string Name()  override {
        return "TPZMixedElasticityMaterial";
    }

    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();
    //    }

    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;

    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 FillDataRequirements(TPZVec<TPZMaterialData > &datavec) 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";
    }

    STATE Inner(TPZFMatrix<STATE> &S, TPZFMatrix<STATE> &T);

    static void ToVoigt(TPZFMatrix<STATE> &S, TPZVec<STATE> &Svoigt);

    static void FromVoigt(TPZVec<STATE> &Svoigt, TPZFMatrix<STATE> &S);

    template<class TVar>
    TVar InnerVec(const TPZVec<TVar> &S, const TPZVec<TVar> &T);

    STATE Tr(TPZFMatrix<REAL> &GradU);

    STATE Transpose(TPZFMatrix<REAL> &GradU);

    void FillGradPhi(TPZMaterialData &dataV, TPZVec< TPZFMatrix<STATE> > &GradPhi);

    void FillVecShapeIndex(TPZMaterialData &data);

public:

    virtual void Solution(TPZMaterialData &data, int var, TPZVec<STATE> &Solout) override;

    virtual void Solution(TPZVec<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;

    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

    virtual void Errors(TPZVec<TPZMaterialData> &data, TPZVec<STATE> &u_exact, TPZFMatrix<STATE> &du_exact, TPZVec<REAL> &errors) override;

    virtual int ClassId() const override;

    virtual void Read(TPZStream &buf, void *context) override;

    virtual void Write(TPZStream &buf, int withclassid) const override;



protected:
    TPZManVector<REAL, 3> fForce = TPZManVector<REAL, 3>(2, 0.);

    int fPlaneStress = 1;

    int fDimension = 2;

    TPZAutoPointer<TPZFunction<STATE> > fElasticity;
    
    REAL fE_const;
    
    REAL fnu_const;
    
    REAL flambda_const;
    
    REAL fmu_const;
    

    // Matrix A
    TPZFMatrix<STATE> fMatrixA;

    bool fAxisSymmetric = false;

};

#endif