TPZPlasticStepPV.h

Go to the documentation of this file.

#ifndef TPZPlasticStepPV_H
#define TPZPlasticStepPV_H


#include "TPZTensor.h"
#include "pzreal.h"
#include "pzfmatrix.h"
#include "TPZPlasticState.h"
#include "TPZPlasticIntegrMem.h"
#include "TPZPlasticStep.h"
#include "pzlog.h"
#include "pzstepsolver.h"
#include "TPZElasticResponse.h"
#include "TPZPorousElasticResponse.h"

#include <set>
#include <ostream>

// Metodos para deixar o prog mais "encapsulado"
REAL NormVecOfMat(TPZFNMatrix <9> mat);
REAL InnerVecOfMat(TPZFMatrix<REAL> &m1, TPZFMatrix<REAL> &m2);
TPZFMatrix<REAL> ProdT(TPZManVector<REAL,3> &v1, TPZManVector<REAL,3> &v2);
void ProdT(TPZManVector<REAL,3> &v1, TPZManVector<REAL,3> &v2, TPZFMatrix<REAL> & mat);
TPZFNMatrix <6> FromMatToVoight(TPZFNMatrix <9> mat);

/*
 
 enum EElastoPlastic
 {
 EAuto = 0,
 EForceElastic = 1,
 EForcePlastic = 2
 };
 */

template <class YC_t, class ER_t>
class TPZPlasticStepPV : public TPZPlasticBase
{
public:

  TPZPlasticStepPV(REAL alpha=0.):fYC(), fER(), fResTol(1.e-12), fMaxNewton(30), fN()
                { 
        fN.m_hardening = alpha;
    }

                TPZPlasticStepPV(const TPZPlasticStepPV & source)
                {
        fYC = source.fYC;
        fER = source.fER;
        fResTol = source.fResTol;
        fMaxNewton = source.fMaxNewton;
        fN = source.fN;
    }

                TPZPlasticStepPV & operator=(const TPZPlasticStepPV & source)
                {
        fYC = source.fYC;
        fER = source.fER;
        fResTol = source.fResTol;
        fMaxNewton = source.fMaxNewton;
        fN = source.fN;

        return *this;
    }

                virtual const char * Name() const override
                {
        return "TPZPlasticStepPV";
    }

                virtual void Print(std::ostream & out) const override
                {
        out << "\n" << this->Name();
        out << "\n YC_t:";
        fYC.Print(out);
        out << "\n ER_t:";
        fER.Print(out);
        out << "\nTPZPlasticStepPV Internal members:";
        out << "\n fResTol = " << fResTol;
        out << "\n fMaxNewton = " << fMaxNewton;
        out << "\n fN = "; // PlasticState
        fN.Print(out);
    }

    typedef YC_t fNYields;
    
    virtual void InitialDamage(const TPZTensor<REAL> & sigma, REAL & k);

    virtual void ApplyStrainComputeSigma(const TPZTensor<REAL> &epsTotal, TPZTensor<REAL> &sigma, TPZFMatrix<REAL> * tangent = NULL) override;
    
    virtual void  ApplyStressComputeStrain(const TPZTensor<REAL> &sigma, TPZTensor<REAL> &epsTotal, TPZFMatrix<REAL> * tangent_inv = NULL);
    
    virtual void ApplyStrain(const TPZTensor<REAL> &epsTotal) override;

    virtual void ApplyStrainComputeDep(const TPZTensor<REAL> &epsTotal, TPZTensor<REAL> &sigma, TPZFMatrix<REAL> &Dep) override;

    virtual void ApplyLoad(const TPZTensor<REAL> & sigma, TPZTensor<REAL> &epsTotal) override;

    virtual TPZPlasticState<REAL> GetState() const override;
    virtual void Phi(const TPZTensor<REAL> &epsTotal, TPZVec<REAL> &phi) const override;

    virtual void SetElasticResponse(TPZElasticResponse &ER) override;

    virtual TPZElasticResponse GetElasticResponse() const override
    {
        return fER;
    }

    virtual void SetState(const TPZPlasticState<REAL> &state) override;


    //void CopyFromFNMatrixToTensor(TPZFNMatrix<6> FNM,TPZTensor<STATE> &copy);
    void CopyFromTensorToFMatrix(TPZTensor<STATE> tensor, TPZFMatrix<STATE> &copy);


    //void CopyFromTensorToFNMatrix(TPZTensor<STATE> tensor,TPZFNMatrix<6> &copy);
    void CopyFromFMatrixToTensor(TPZFMatrix<STATE> FNM, TPZTensor<STATE> &copy);

    virtual void TrialStressCorrection(REAL kappa, TPZVec<STATE> &sigma, TPZVec<STATE> &sigma_tr);

    virtual int ClassId() const override;

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


    void TaylorCheck(TPZTensor<REAL> &EpsIni, TPZTensor<REAL> &deps, REAL kprev, TPZVec<REAL> &conv);


    REAL ComputeNFromTaylorCheck(REAL alpha1, REAL alpha2, TPZFMatrix<REAL> &error1Mat, TPZFMatrix<REAL> &error2Mat);

    TPZPlasticCriterion& GetYC() override{
        return fYC;
    }


public:

                void SetResidualTolerance(STATE tol)
                {
        fResTol = tol;
    }

    void ResetPlasticMem()
    {
        //fPlasticMem.Resize(0);
    }

    //virtual void Write(TPZStream &buf) const;

    //virtual void Read(TPZStream &buf);
public:

    YC_t fYC;

    ER_t fER;

protected:

    REAL fResTol;

    int fMaxNewton; // COLOCAR = 30 (sugestao do erick!)

private:
    
    void TangentOperator(TPZFMatrix<REAL> & gradient,TPZTensor<REAL>::TPZDecomposed & eps_eigen_system, TPZTensor<REAL>::TPZDecomposed & sig_eigen_system, TPZFMatrix<REAL> & Tangent);

public:

    TPZPlasticState<STATE> fN;

};

template <class YC_t, class ER_t>
int TPZPlasticStepPV<YC_t, ER_t>::ClassId() const{
    return Hash("TPZPlasticStepPV") ^ TPZPlasticBase::ClassId() << 1 ^ YC_t().ClassId() << 2 ^ ER_t().ClassId() << 3;
}

#endif //TPZPlasticStepPV_H