TPZYCMohrCoulombPV.h

Go to the documentation of this file.

/*
 *  TPZMohrCoulomb.h
 *  FEMPZ
 *
 *  Created by Nathan Shauer on 5/4/13.
 *  Copyright 2010 __MyCompanyName__. All rights reserved.
 *
 */

#ifndef TPZYCMOHRCOULOMBPV_H
#define TPZYCMOHRCOULOMBPV_H

#include "pzlog.h"
#include "TPZTensor.h"
#include "pzvec_extras.h"
#include "TPZPlasticState.h"
#include "TPZElasticResponse.h"
#include "TPZPlasticCriterion.h"

#ifdef LOG4CXX
static LoggerPtr loggerMohrCoulombPV(Logger::getLogger("pz.plasticity.mohrcoulombpv"));
#endif

class TPZYCMohrCoulombPV : public TPZPlasticCriterion {  
public:

    enum {
        NYield = 3
    };

private:
    
    REAL fPhi;
    REAL fPsi;
    REAL fc;
    TPZElasticResponse fER;

protected:
    REAL fEpsPlasticBar;

public:

    // we can only expect a consistent tangent matrix if the decision tree remains the same

    struct TComputeSequence {

        TComputeSequence() : fWhichPlane(ENoPlane), fGamma(0) {

        }

        TComputeSequence(const TComputeSequence &copy) : fWhichPlane(copy.fWhichPlane), fGamma(copy.fGamma) {

        }

        TComputeSequence &operator=(const TComputeSequence &copy) {
            fWhichPlane = copy.fWhichPlane;
            fGamma = copy.fGamma;
            return *this;
        }

        enum MPlane {
            ENoPlane, EElastic, EMainPlane, ERightEdge, ELeftEdge, EApex
        };

        MPlane fWhichPlane;

        TPZManVector<REAL> fGamma;
    };

public:

    TPZYCMohrCoulombPV();

    TPZYCMohrCoulombPV(REAL Phi, REAL Psi, REAL c, TPZElasticResponse &ER);

    TPZYCMohrCoulombPV(const TPZYCMohrCoulombPV &cp);

    void SetUp(REAL Phi, REAL Psi, REAL c, TPZElasticResponse &ER) {
        fPhi = Phi;
        fPsi = Psi;
        fc = c;
        fER = ER;
    }

    TPZYCMohrCoulombPV & operator=(const TPZYCMohrCoulombPV &cp);

    virtual int ClassId() const override;

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

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

    void SetEpsBar(REAL &epsbar) {
        fEpsPlasticBar = epsbar;
    }

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

    void SetElasticResponse(const TPZElasticResponse &ER) {
        fER = ER;
    }

    virtual TPZElasticResponse GetElasticResponse() const {
        return fER;
    }

    REAL InitialDamage(const TPZVec<REAL> &stress_p) const;
    
    template <class T>
    void PlasticityFunction(const T epsp, T &c, T &H) const;

    template<class T>
    TPZVec<T> SigmaElastPV(const TPZVec<T> &deform) const;

    template<class T>
    T PhiPlane(const TPZVec<T> &sigma) const;

    template<class T>
    bool ReturnMapPlane(const TPZVec<T> &sigma_trial, TPZVec<T> &sigma_projected,
            TComputeSequence &memory, REAL &epsbarnew) const;

    void ComputePlaneTangent(TPZMatrix<REAL> &tang, REAL &epsbarp) const;

    template<class T>
    bool ReturnMapLeftEdge(const TPZVec<T> &sigma_trial, TPZVec<T> &sigma_projected,
            TComputeSequence &memory, REAL &epsbarnew) const;

    void ComputeLeftEdgeTangent(TPZMatrix<REAL> &tang, REAL &epsbarp) const;

    template<class T>
    bool ReturnMapRightEdge(const TPZVec<T> &sigma_trial, TPZVec<T> &sigma_projected,
            TComputeSequence &memory, REAL &epsbarnew) const;

    void ComputeRightEdgeTangent(TPZMatrix<REAL> &tang, REAL &epsbarp) const;

    template<class T>
    bool ReturnMapApex(const TPZVec<T> &sigma_trial, TPZVec<T> &sigma_projected,
            TComputeSequence &memory, REAL &epsbarnew) const;
    
    void ComputeApexGradient(TPZMatrix<REAL> & gradient, REAL & eps_bar_p) const;
    
    void ProjectSigma(const TPZVec<STATE> & sigma_trial, STATE k_prev, TPZVec<STATE> & sigma, STATE &k_proj, int & m_type, TPZFMatrix<REAL> * gradient = NULL);

    // Deprecated
    void ProjectSigmaDep(const TPZVec<STATE> &sigmatrial, STATE kprev, TPZVec<STATE> &sigmaproj, STATE &kpro, TPZFMatrix<STATE> &tang){
        std::cerr << "Deprecated gradient calculation is incorporated on ProjectSigma method." << std::endl;
        DebugStop();
    }

    void Phi(TPZVec<STATE> sig_vec, STATE alpha, TPZVec<STATE> &phi)const;

    STATE Phi() {
        return fPhi;
    }
    
    void SetPhi(STATE phi)
    {
        fPhi = phi;
    }
    
    STATE Psi() {
        return fPsi;
    }

    STATE Cohesion() {
        return fc;
    }
    
    void SetCohesion(STATE cohesion)
    {
        fc = cohesion;
    }

    
    STATE E() {
        return fER.E();
    }

    STATE Poisson() {
        return fER.Poisson();
    }


    virtual void YieldFunction(const TPZVec<STATE>& sigma, STATE kprev, TPZVec<STATE>& yield) const override{
        Phi(sigma, kprev, yield);
    }
    
    virtual int GetNYield() const override{
        return as_integer(NYield);
    }
};


#endif //TPZYCMOHRCOULOMBPV_H