residualbased_incrementalupdate_static_scheme_slip.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//
 
 
#ifndef KRATOS_RESIDUALBASED_INCREMENTALUPDATE_STATIC_SCHEME_SLIP_H
#define KRATOS_RESIDUALBASED_INCREMENTALUPDATE_STATIC_SCHEME_SLIP_H
 
/* System includes */
 
 
/* External includes */
 
 
/* Project includes */
#include "includes/define.h"
#include "includes/model_part.h"
#include "includes/deprecated_variables.h"
//#include "includes/variables.h"
#include "solving_strategies/schemes/scheme.h"
#include "solving_strategies/schemes/residualbased_incrementalupdate_static_scheme.h"
#include "utilities/coordinate_transformation_utilities.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
 
 
 
 
 
 
template<class TSparseSpace,
         class TDenseSpace //= DenseSpace<double>
         >
class ResidualBasedIncrementalUpdateStaticSchemeSlip : public ResidualBasedIncrementalUpdateStaticScheme<TSparseSpace,TDenseSpace>
{
 
public:
 
    KRATOS_CLASS_POINTER_DEFINITION( ResidualBasedIncrementalUpdateStaticSchemeSlip);
 
    typedef Scheme<TSparseSpace,TDenseSpace> BaseSchemeType;
 
    typedef ResidualBasedIncrementalUpdateStaticScheme<TSparseSpace,TDenseSpace> BaseType;
 
    typedef ResidualBasedIncrementalUpdateStaticSchemeSlip<TSparseSpace, TDenseSpace> ClassType;
 
    typedef typename BaseType::TDataType TDataType;
 
    typedef typename BaseType::DofsArrayType DofsArrayType;
 
    typedef typename BaseType::TSystemMatrixType TSystemMatrixType;
 
    typedef typename BaseType::TSystemVectorType TSystemVectorType;
 
    typedef typename BaseType::LocalSystemVectorType LocalSystemVectorType;
    typedef typename BaseType::LocalSystemMatrixType LocalSystemMatrixType;
    typedef CoordinateTransformationUtils<LocalSystemMatrixType,LocalSystemVectorType,double> RotationToolType;
    typedef typename CoordinateTransformationUtils<LocalSystemMatrixType,LocalSystemVectorType,double>::Pointer RotationToolPointerType;
 
 
    explicit ResidualBasedIncrementalUpdateStaticSchemeSlip() : BaseType()
    {
    }
 
    explicit ResidualBasedIncrementalUpdateStaticSchemeSlip(Parameters ThisParameters)
        : BaseType()
    {
        // Validate default parameters
        Parameters default_parameters = Parameters(R"(
        {
            "name"        : "ResidualBasedIncrementalUpdateStaticSchemeSlip",
            "domain_size" : 3,
            "block_size"  : 3
        })" );
        ThisParameters.ValidateAndAssignDefaults(default_parameters);
 
        const int domain_size = ThisParameters["domain_size"].GetInt();
        const int block_size = ThisParameters["block_size"].GetInt();
        mpRotationTool = Kratos::make_shared<RotationToolType>(domain_size, block_size, SLIP);
    }
 
 
    explicit ResidualBasedIncrementalUpdateStaticSchemeSlip(unsigned int DomainSize,
                                                   unsigned int BlockSize):
        BaseType(),
        mpRotationTool(Kratos::make_shared<RotationToolType>(DomainSize,BlockSize,SLIP))
    {}
 
 
    explicit ResidualBasedIncrementalUpdateStaticSchemeSlip(RotationToolPointerType pRotationTool):
        BaseType(),
        mpRotationTool(pRotationTool)
    {}
 
    ~ResidualBasedIncrementalUpdateStaticSchemeSlip() override{}
 
 
 
 
    typename BaseSchemeType::Pointer Create(Parameters ThisParameters) const override
    {
        return Kratos::make_shared<ClassType>(ThisParameters);
    }
 
    void Update(ModelPart& r_model_part,
                DofsArrayType& rDofSet,
                TSystemMatrixType& A,
                TSystemVectorType& Dx,
                TSystemVectorType& b) override
    {
        KRATOS_TRY;
 
        mpRotationTool->RotateVelocities(r_model_part);
 
        BaseType::Update(r_model_part,rDofSet,A,Dx,b);
 
        mpRotationTool->RecoverVelocities(r_model_part);
 
        KRATOS_CATCH("");
    }
 
 
    void CalculateSystemContributions(Element& rCurrentElement,
                                      LocalSystemMatrixType& LHS_Contribution,
                                      LocalSystemVectorType& RHS_Contribution,
                                      Element::EquationIdVectorType& EquationId,
                                      const ProcessInfo& CurrentProcessInfo) override
    {
        KRATOS_TRY;
 
        BaseType::CalculateSystemContributions(rCurrentElement,LHS_Contribution,RHS_Contribution,EquationId,CurrentProcessInfo);
 
        mpRotationTool->Rotate(LHS_Contribution,RHS_Contribution,rCurrentElement.GetGeometry());
        mpRotationTool->ApplySlipCondition(LHS_Contribution,RHS_Contribution,rCurrentElement.GetGeometry());
 
        KRATOS_CATCH("");
    }
 
    void CalculateRHSContribution(Element& rCurrentElement,
                                  LocalSystemVectorType& RHS_Contribution,
                                  Element::EquationIdVectorType& EquationId,
                                  const ProcessInfo& CurrentProcessInfo) override
    {
        KRATOS_TRY;
 
        BaseType::CalculateRHSContribution(rCurrentElement,RHS_Contribution,EquationId,CurrentProcessInfo);
 
        mpRotationTool->Rotate(RHS_Contribution,rCurrentElement.GetGeometry());
        mpRotationTool->ApplySlipCondition(RHS_Contribution,rCurrentElement.GetGeometry());
 
        KRATOS_CATCH("");
    }
 
    void CalculateLHSContribution(Element& rCurrentElement,
                                  LocalSystemMatrixType& LHS_Contribution,
                                  Element::EquationIdVectorType& EquationId,
                                  const ProcessInfo& CurrentProcessInfo) override
    {
        KRATOS_TRY;
 
        BaseType::CalculateLHSContribution(rCurrentElement,LHS_Contribution,EquationId,CurrentProcessInfo);
 
        LocalSystemVectorType Temp = ZeroVector(LHS_Contribution.size1());
        mpRotationTool->Rotate(LHS_Contribution,Temp,rCurrentElement.GetGeometry());
        mpRotationTool->ApplySlipCondition(LHS_Contribution,Temp,rCurrentElement.GetGeometry());
 
        KRATOS_CATCH("");
    }
 
 
    void CalculateSystemContributions(Condition& rCurrentCondition,
                                      LocalSystemMatrixType& LHS_Contribution,
                                      LocalSystemVectorType& RHS_Contribution,
                                      Element::EquationIdVectorType& EquationId,
                                      const ProcessInfo& CurrentProcessInfo) override
    {
        KRATOS_TRY;
 
        BaseType::CalculateSystemContributions(rCurrentCondition,LHS_Contribution,RHS_Contribution,EquationId,CurrentProcessInfo);
 
        mpRotationTool->Rotate(LHS_Contribution,RHS_Contribution,rCurrentCondition.GetGeometry());
        mpRotationTool->ApplySlipCondition(LHS_Contribution,RHS_Contribution,rCurrentCondition.GetGeometry());
 
        KRATOS_CATCH("");
    }
 
    void CalculateRHSContribution(Condition& rCurrentCondition,
                                  LocalSystemVectorType& RHS_Contribution,
                                  Element::EquationIdVectorType& EquationId,
                                  const ProcessInfo& CurrentProcessInfo) override
    {
        KRATOS_TRY;
 
        BaseType::CalculateRHSContribution(rCurrentCondition,RHS_Contribution,EquationId,CurrentProcessInfo);
 
        mpRotationTool->Rotate(RHS_Contribution,rCurrentCondition.GetGeometry());
        mpRotationTool->ApplySlipCondition(RHS_Contribution,rCurrentCondition.GetGeometry());
 
        KRATOS_CATCH("");
    }
 
    static std::string Name()
    {
        return "static_slip_scheme";
    }
 
 
 
 
    std::string Info() const override
    {
        return "ResidualBasedIncrementalUpdateStaticSchemeSlip";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
 
    RotationToolPointerType mpRotationTool;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
}; // class
 
 
 
 
}  // namespace Kratos
 
#endif // KRATOS_RESIDUALBASED_INCREMENTALUPDATE_STATIC_SCHEME_SLIP_H