borja_cam_clay_plastic_flow_rule.hpp

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:        BSD License
//                  Kratos default license: kratos/license.txt
//
//  Main authors:    Bodhinanda Chandra
//
 
 
#if !defined(KRATOS_BORJA_CAM_CLAY_PLASTIC_FLOW_RULE_H_INCLUDED )
#define      KRATOS_BORJA_CAM_CLAY_PLASTIC_FLOW_RULE_H_INCLUDED
 
// System includes
#include <cmath>
 
// External includes
 
// Project includes
#include "custom_constitutive/flow_rules/particle_flow_rule.hpp"
 
 
namespace Kratos
{
 
 
 
//struct MCStressInvariants {
 
//double MeanStress;
//double J2InvSQ;
//double LodeAngle;
 
//};
 
//struct MCSmoothingConstants {
 
//double A;
//double B;
 
//};
 
 
 
 
class KRATOS_API(PARTICLE_MECHANICS_APPLICATION) BorjaCamClayPlasticFlowRule
    :public ParticleFlowRule
{
 
 
 
public:
 
    KRATOS_CLASS_POINTER_DEFINITION( BorjaCamClayPlasticFlowRule );
 
    struct MaterialParameters
    {
        double PreconsolidationPressure;
        double PlasticHardeningModulus;
        double ConsistencyParameter;
 
    public:
        void PrintInfo()
        {
            KRATOS_INFO("ParticleFlowRule.MaterialParameters") << "PreconsolidationPressure = " <<  PreconsolidationPressure  << std::endl;
            KRATOS_INFO("ParticleFlowRule.MaterialParameters") << "PlasticHardeningModulus  = " <<  PlasticHardeningModulus   << std::endl;
            KRATOS_INFO("ParticleFlowRule.MaterialParameters") << "ConsistencyParameter     = " <<  ConsistencyParameter      << std::endl;
        }
 
    private:
 
        friend class Serializer;
 
        // A private default constructor necessary for serialization
        void save(Serializer& rSerializer) const
        {
            rSerializer.save("PreconsolidationPressure",PreconsolidationPressure);
            rSerializer.save("PlasticHardeningModulus",PlasticHardeningModulus);
            rSerializer.save("ConsistencyParameter",ConsistencyParameter);
        };
 
        void load(Serializer& rSerializer)
        {
            rSerializer.load("PreconsolidationPressure",PreconsolidationPressure);
            rSerializer.load("PlasticHardeningModulus",PlasticHardeningModulus);
            rSerializer.load("ConsistencyParameter",ConsistencyParameter);
        };
 
    };
 
 
    BorjaCamClayPlasticFlowRule();
 
    BorjaCamClayPlasticFlowRule(YieldCriterionPointer pYieldCriterion);
 
    BorjaCamClayPlasticFlowRule(BorjaCamClayPlasticFlowRule const& rOther);
 
    BorjaCamClayPlasticFlowRule& operator=(BorjaCamClayPlasticFlowRule const& rOther);
 
    // CLONE
    ParticleFlowRule::Pointer Clone() const override;
 
    ~BorjaCamClayPlasticFlowRule() override;
 
    bool CalculateReturnMapping( RadialReturnVariables& rReturnMappingVariables, const Matrix& rIncrementalDeformationGradient, Matrix& rStressMatrix, Matrix& rNewElasticLeftCauchyGreen, const Properties& rProp) override;
 
    bool UpdateInternalVariables( RadialReturnVariables& rReturnMappingVariables, const Properties& rProp ) override;
 
    Matrix GetElasticLeftCauchyGreen(RadialReturnVariables& rReturnMappingVariables) override;
 
    unsigned int GetPlasticRegion() override;
 
    void ComputeElastoPlasticTangentMatrix(const RadialReturnVariables& rReturnMappingVariables, const Matrix& rNewElasticLeftCauchyGreen, const double& alfa, Matrix& rConsistMatrix, const Properties& rProp) override;
 
    void CalculatePrincipalStressTrial(const RadialReturnVariables& rReturnMappingVariables, const Matrix& rNewElasticLeftCauchyGreen, Matrix& rStressMatrix, const Properties& rProp) override;
 
 
 
 
 
 
 
 
 
 
    // /// Turn back information as a string.
    // virtual std::string Info() const;
 
    // /// Print information about this object.
    // virtual void PrintInfo(std::ostream& rOStream) const;
 
    // /// Print object's data.
    // virtual void PrintData(std::ostream& rOStream) const;
 
 
 
 
 
protected:
    BoundedVector<double,3> mElasticPrincipalStrain;
    BoundedVector<double,3> mPlasticPrincipalStrain;
 
    BoundedVector<double,3> mPrincipalStressUpdated;
 
    unsigned int mRegion;
    bool mLargeStrainBool;
 
    MaterialParameters mMaterialParameters;
 
    double mInitialVolumetricStrain;
 
    double mStateFunction;
    Vector mStateFunctionFirstDerivative ;
    Vector mStateFunctionSecondDerivative;
 
 
 
 
 
 
 
    void InitializeMaterial(YieldCriterionPointer& pYieldCriterion, HardeningLawPointer& pHardeningLaw, const Properties& rProp) override;
 
    void InitializeMaterialParameters(const Properties& rProp);
 
    void CalculatePrincipalStressVector(const BoundedVector<double,3>& rPrincipalStrain, BoundedVector<double,3>& rPrincipalStress, const Properties& rProp);
 
    void CalculateMeanStress(const double& rVolumetricStrain, const double& rDeviatoricStrain, double& rMeanStress, const Properties& rProp);
 
    void CalculateDeviatoricStress(const double& rVolumetricStrain, const BoundedVector<double,3>& rDeviatoricStrainVector, BoundedVector<double,3>& rDeviatoricStress, const Properties& rProp);
 
    void CalculatePrincipalStrainFromStrainInvariants(BoundedVector<double,3>& rPrincipalStrain, const double& rVolumetricStrain, const double& rDeviatoricStrain, const BoundedVector<double,3>& rDirectionVector);
 
    void CalculateStrainInvariantsFromPrincipalStrain(const BoundedVector<double,3>& rPrincipalStrain, double& rVolumetricStrain, double& rDeviatoricStrain, BoundedVector<double,3>& rDeviatoricStrainVector);
 
    bool CalculateConsistencyCondition(RadialReturnVariables& rReturnMappingVariables, const BoundedVector<double,3>& rPrincipalStress, BoundedVector<double,3>& rPrincipalStrain, unsigned int& region, BoundedVector<double,3>& rPrincipalStressUpdated, const Properties& rProp);
 
    void CalculateLHSMatrix(Matrix& rLHSMatrix, const BoundedVector<double,3>& rPrincipalStressVector, const BoundedVector<double,3>& rUnknownVector, const double& rK_p, const Properties& rProp);
 
    void CalculateHessianMatrix_2x2(BoundedMatrix<double,2,2>& rHessianMatrix, const Properties& rProp);
 
    void ComputeElasticMatrix_2X2(const BoundedVector<double,3>& rPrincipalStressVector, const double& rVolumetricStrain, const double& rDeviatoricStrain, BoundedMatrix<double,2,2>& rElasticMatrix, const Properties& rProp);
 
    void ComputePlasticMatrix_2X2(const BoundedVector<double,3>& rPrincipalStressVector, const double& rVolumetricStrain, const double& rDeviatoricStrain, const BoundedMatrix<double,2,2>& rElasticMatrix, BoundedMatrix<double,2,2>& rPlasticMatrix, const Properties& rProp);
 
    void ReturnStressFromPrincipalAxis(const Matrix& rEigenVectors, const BoundedVector<double,3>& rPrincipalStress, Matrix& rStressMatrix);
 
    void CalculateTransformationMatrix(const BoundedMatrix<double,3,3>& rMainDirection, BoundedMatrix<double,6,6>& rA);
 
    void UpdateStateVariables(const BoundedVector<double,3> rPrincipalStress, const Properties& rProp, const double rAlpha = 0.0, const double rConsistencyParameter = 0.0);
 
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
    // A private default constructor necessary for serialization
 
    void save(Serializer& rSerializer) const override;
 
    void load(Serializer& rSerializer) override;
 
 
 
 
 
}; // Class NonLinearAssociativePlasticFlowRule
 
 
 
 
 
 
// inline std::istream& operator >> (std::istream& rIStream,
//                  NonLinearAssociativePlasticFlowRule& rThis);
 
// /// output stream function
// inline std::ostream& operator << (std::ostream& rOStream,
//                  const NonLinearAssociativePlasticFlowRule& rThis)
// {
//   rThis.PrintInfo(rOStream);
//   rOStream << std::endl;
//   rThis.PrintData(rOStream);
 
//   return rOStream;
// }
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_BORJA_CAM_CLAY_PLASTIC_FLOW_RULE_H_INCLUDED  defined