residual_based_implicit_time_scheme.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//
 
 
#if !defined(KRATOS_RESIDUAL_BASED_IMPLICIT_TIME_SCHEME )
#define  KRATOS_RESIDUAL_BASED_IMPLICIT_TIME_SCHEME
 
/* System includes */
 
/* External includes */
 
/* Project includes */
#include "solving_strategies/schemes/scheme.h"
#include "utilities/entities_utilities.h"
 
namespace Kratos
{
 
template<class TSparseSpace,  class TDenseSpace >
class ResidualBasedImplicitTimeScheme
    : public Scheme<TSparseSpace,TDenseSpace>
{
public:
    KRATOS_CLASS_POINTER_DEFINITION( ResidualBasedImplicitTimeScheme );
 
    typedef Scheme<TSparseSpace,TDenseSpace>                      BaseType;
 
    typedef typename BaseType::DofsArrayType                 DofsArrayType;
    typedef typename Element::DofsVectorType                DofsVectorType;
 
    typedef typename BaseType::TDataType                         TDataType;
    typedef typename BaseType::TSystemMatrixType         TSystemMatrixType;
    typedef typename BaseType::TSystemVectorType         TSystemVectorType;
    typedef typename BaseType::LocalSystemVectorType LocalSystemVectorType;
    typedef typename BaseType::LocalSystemMatrixType LocalSystemMatrixType;
 
    typedef ModelPart::NodesContainerType                   NodesArrayType;
    typedef ModelPart::ElementsContainerType             ElementsArrayType;
    typedef ModelPart::ConditionsContainerType         ConditionsArrayType;
 
    typedef std::size_t                                          IndexType;
 
 
    explicit ResidualBasedImplicitTimeScheme()
        :BaseType()
    {
        // Allocate auxiliary memory
        const std::size_t num_threads = ParallelUtilities::GetNumThreads();
 
        mMatrix.M.resize(num_threads);
        mMatrix.D.resize(num_threads);
    }
 
    explicit ResidualBasedImplicitTimeScheme(Parameters ThisParameters)
        :ResidualBasedImplicitTimeScheme()
    {
        this->ValidateAndAssignParameters(ThisParameters);
        this->AssignSettings(ThisParameters);
    }
 
    explicit ResidualBasedImplicitTimeScheme(ResidualBasedImplicitTimeScheme& rOther)
        :BaseType(rOther)
        ,mMatrix(rOther.mMatrix)
    {
    }
 
    typename BaseType::Pointer Clone() override
    {
        return Kratos::make_shared<ResidualBasedImplicitTimeScheme>(*this);
    }
 
    ~ResidualBasedImplicitTimeScheme
    () override {}
 
 
 
    void CalculateSystemContributions(
        Element& rCurrentElement,
        LocalSystemMatrixType& rLHSContribution,
        LocalSystemVectorType& rRHSContribution,
        Element::EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        ) override
    {
        KRATOS_TRY;
 
        TCalculateSystemContributions(rCurrentElement, rLHSContribution, rRHSContribution, rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("ResidualBasedImplicitTimeScheme.CalculateSystemContributions");
    }
 
    void CalculateRHSContribution(
        Element& rCurrentElement,
        LocalSystemVectorType& rRHSContribution,
        Element::EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        ) override
    {
        KRATOS_TRY;
 
        TCalculateRHSContribution(rCurrentElement, rRHSContribution, rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("ResidualBasedImplicitTimeScheme.CalculateRHSContribution");
    }
 
    void CalculateSystemContributions(
        Condition& rCurrentCondition,
        LocalSystemMatrixType& rLHSContribution,
        LocalSystemVectorType& rRHSContribution,
        Element::EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        ) override
    {
        KRATOS_TRY;
 
        TCalculateSystemContributions(rCurrentCondition, rLHSContribution, rRHSContribution, rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("ResidualBasedImplicitTimeScheme.CalculateSystemContributions");
    }
 
    void CalculateRHSContribution(
        Condition& rCurrentCondition,
        LocalSystemVectorType& rRHSContribution,
        Element::EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        ) override
    {
        KRATOS_TRY;
 
        TCalculateRHSContribution(rCurrentCondition, rRHSContribution, rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("ResidualBasedImplicitTimeScheme.CalculateRHSContribution");
    }
 
    void InitializeSolutionStep(
        ModelPart& rModelPart,
        TSystemMatrixType& rA,
        TSystemVectorType& rDx,
        TSystemVectorType& rb
        ) override
    {
        KRATOS_TRY;
 
        const ProcessInfo r_current_process_info= rModelPart.GetProcessInfo();
 
        BaseType::InitializeSolutionStep(rModelPart, rA, rDx, rb);
 
        const double delta_time = r_current_process_info[DELTA_TIME];
 
        KRATOS_ERROR_IF(delta_time < 1.0e-24) << "ERROR:: Detected delta_time = 0 in the Solution Scheme DELTA_TIME. PLEASE : check if the time step is created correctly for the current time step" << std::endl;
 
        KRATOS_CATCH("ResidualBasedImplicitTimeScheme.InitializeSolutionStep");
    }
 
    int Check(const ModelPart& rModelPart) const override
    {
        KRATOS_TRY;
 
        const int err = BaseType::Check(rModelPart);
        if(err!=0) return err;
 
        return 0;
 
        KRATOS_CATCH("ResidualBasedImplicitTimeScheme.Check");
    }
 
    Parameters GetDefaultParameters() const override
    {
        Parameters default_parameters = Parameters(R"(
        {
            "name" : "residualbased_implicit_time_scheme"
        })");
 
        // Getting base class default parameters
        const Parameters base_default_parameters = BaseType::GetDefaultParameters();
        default_parameters.RecursivelyAddMissingParameters(base_default_parameters);
        return default_parameters;
    }
 
 
 
 
    std::string Info() const override
    {
        return "ResidualBasedImplicitTimeScheme";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
 
protected:
 
 
 
    struct GeneralMatrices
    {
        std::vector< Matrix > M; 
        std::vector< Matrix > D; 
    };
 
    GeneralMatrices mMatrix;
 
 
 
    virtual void AddDynamicsToLHS(
        LocalSystemMatrixType& rLHSContribution,
        LocalSystemMatrixType& D,
        LocalSystemMatrixType& M,
        const ProcessInfo& rCurrentProcessInfo
        )
    {
        KRATOS_ERROR << "YOU ARE CALLING THE BASE CLASS OF AddDynamicsToLHS" << std::endl;
    }
 
 
    virtual void AddDynamicsToRHS(
        Element& rCurrentElement,
        LocalSystemVectorType& rRHSContribution,
        LocalSystemMatrixType& D,
        LocalSystemMatrixType& M,
        const ProcessInfo& rCurrentProcessInfo
        )
    {
        KRATOS_ERROR << "YOU ARE CALLING THE BASE CLASS OF AddDynamicsToRHS" << std::endl;
    }
 
    virtual void AddDynamicsToRHS(
        Condition& rCurrentCondition,
        LocalSystemVectorType& rRHSContribution,
        LocalSystemMatrixType& D,
        LocalSystemMatrixType& M,
        const ProcessInfo& rCurrentProcessInfo
        )
    {
        KRATOS_ERROR << "YOU ARE CALLING THE BASE CLASS OF AddDynamicsToRHS" << std::endl;
    }
 
 
 
 
private:
 
 
 
 
    template <class TObjectType>
    void TCalculateSystemContributions(
        TObjectType& rObject,
        LocalSystemMatrixType& rLHSContribution,
        LocalSystemVectorType& rRHSContribution,
        Element::EquationIdVectorType& EquationId,
        const ProcessInfo& rCurrentProcessInfo
        )
    {
        KRATOS_TRY;
 
        const IndexType this_thread = OpenMPUtils::ThisThread();
 
        rObject.CalculateLocalSystem(rLHSContribution,rRHSContribution,rCurrentProcessInfo);
 
        rObject.EquationIdVector(EquationId,rCurrentProcessInfo);
 
        rObject.CalculateMassMatrix(mMatrix.M[this_thread],rCurrentProcessInfo);
 
        rObject.CalculateDampingMatrix(mMatrix.D[this_thread],rCurrentProcessInfo);
 
        AddDynamicsToLHS(rLHSContribution, mMatrix.D[this_thread], mMatrix.M[this_thread], rCurrentProcessInfo);
 
        AddDynamicsToRHS(rObject, rRHSContribution, mMatrix.D[this_thread], mMatrix.M[this_thread], rCurrentProcessInfo);
 
        KRATOS_CATCH("ResidualBasedImplicitTimeScheme.TCalculateSystemContributions");
    }
 
    template <class TObjectType>
    void TCalculateRHSContribution(
        TObjectType& rObject,
        LocalSystemVectorType& rRHSContribution,
        Element::EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        )
    {
        KRATOS_TRY;
 
        const IndexType this_thread = OpenMPUtils::ThisThread();
 
        rObject.CalculateRightHandSide(rRHSContribution,rCurrentProcessInfo);
 
        rObject.CalculateMassMatrix(mMatrix.M[this_thread], rCurrentProcessInfo);
 
        rObject.CalculateDampingMatrix(mMatrix.D[this_thread],rCurrentProcessInfo);
 
        rObject.EquationIdVector(rEquationId,rCurrentProcessInfo);
 
        AddDynamicsToRHS(rObject, rRHSContribution, mMatrix.D[this_thread], mMatrix.M[this_thread], rCurrentProcessInfo);
 
        KRATOS_CATCH("ResidualBasedImplicitTimeScheme.TCalculateRHSContribution");
    }
 
 
 
}; /* Class ResidualBasedImplicitTimeScheme */
}  /* namespace Kratos.*/
 
#endif /* KRATOS_RESIDUAL_BASED_IMPLICIT_TIME_SCHEME defined */