residualbased_incrementalupdate_static_scheme.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//
 
#if !defined(KRATOS_RESIDUALBASED_INCREMENTALUPDATE_STATIC_SCHEME_H )
#define  KRATOS_RESIDUALBASED_INCREMENTALUPDATE_STATIC_SCHEME_H
 
/* System includes */
 
/* External includes */
 
/* Project includes */
#include "solving_strategies/schemes/scheme.h"
#include "includes/variables.h"
#include "utilities/entities_utilities.h"
 
namespace Kratos
{
 
template<class TSparseSpace,
         class TDenseSpace //= DenseSpace<double>
         >
class ResidualBasedIncrementalUpdateStaticScheme
    : public Scheme<TSparseSpace,TDenseSpace>
{
 
public:
 
    KRATOS_CLASS_POINTER_DEFINITION( ResidualBasedIncrementalUpdateStaticScheme);
 
    typedef Scheme<TSparseSpace,TDenseSpace>                                       BaseType;
 
    // The current class definition
    typedef ResidualBasedIncrementalUpdateStaticScheme<TSparseSpace, TDenseSpace> ClassType;
 
    typedef typename BaseType::DofsArrayType                                  DofsArrayType;
 
    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::ElementsContainerType                              ElementsArrayType;
    typedef ModelPart::ConditionsContainerType                          ConditionsArrayType;
 
    typedef Element::EquationIdVectorType                              EquationIdVectorType;
 
 
    explicit ResidualBasedIncrementalUpdateStaticScheme(Parameters ThisParameters)
        : BaseType()
    {
        // Validate and assign defaults
        ThisParameters = this->ValidateAndAssignParameters(ThisParameters, this->GetDefaultParameters());
        this->AssignSettings(ThisParameters);
    }
 
    explicit ResidualBasedIncrementalUpdateStaticScheme()
        : BaseType()
    {}
 
    explicit ResidualBasedIncrementalUpdateStaticScheme(ResidualBasedIncrementalUpdateStaticScheme& rOther)
        :BaseType(rOther)
    {
    }
 
    ~ResidualBasedIncrementalUpdateStaticScheme() override {}
 
 
 
    typename BaseType::Pointer Create(Parameters ThisParameters) const override
    {
        return Kratos::make_shared<ClassType>(ThisParameters);
    }
 
    void Update(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        TSystemMatrixType& rA,
        TSystemVectorType& rDx,
        TSystemVectorType& rb
        ) override
    {
        KRATOS_TRY
 
        mpDofUpdater->UpdateDofs(rDofSet, rDx);
 
        KRATOS_CATCH("")
    }
 
    void Predict(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        TSystemMatrixType& rA,
        TSystemVectorType& rDx,
        TSystemVectorType& rb
        ) override
    {
        KRATOS_TRY
 
        KRATOS_CATCH("")
    }
 
    void CalculateSystemContributions(
        Element& rCurrentElement,
        LocalSystemMatrixType& rLHSContribution,
        LocalSystemVectorType& rRHSContribution,
        EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        ) override
    {
        KRATOS_TRY
 
        rCurrentElement.CalculateLocalSystem(rLHSContribution,rRHSContribution, rCurrentProcessInfo);
 
        rCurrentElement.EquationIdVector(rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("")
    }
 
    void CalculateSystemContributions(
        Condition& rCurrentCondition,
        LocalSystemMatrixType& rLHSContribution,
        LocalSystemVectorType& rRHSContribution,
        EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        ) override
    {
        KRATOS_TRY
 
        rCurrentCondition.CalculateLocalSystem(rLHSContribution, rRHSContribution, rCurrentProcessInfo);
 
        rCurrentCondition.EquationIdVector(rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("")
    }
 
    void CalculateRHSContribution(
        Element& rCurrentElement,
        LocalSystemVectorType& rRHSContribution,
        EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        ) override
    {
        KRATOS_TRY
 
        rCurrentElement.CalculateRightHandSide(rRHSContribution, rCurrentProcessInfo);
 
        rCurrentElement.EquationIdVector(rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("")
    }
 
    void CalculateRHSContribution(
        Condition& rCurrentCondition,
        LocalSystemVectorType& rRHSContribution,
        EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        ) override
    {
        KRATOS_TRY
 
        rCurrentCondition.CalculateRightHandSide(rRHSContribution, rCurrentProcessInfo);
 
        rCurrentCondition.EquationIdVector(rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("")
    }
 
    void CalculateLHSContribution(
        Element& rCurrentElement,
        LocalSystemMatrixType& rLHSContribution,
        EquationIdVectorType& rEquationId,
        const ProcessInfo& rCurrentProcessInfo
        ) override
    {
        KRATOS_TRY
 
        rCurrentElement.CalculateLeftHandSide(rLHSContribution, rCurrentProcessInfo);
 
        rCurrentElement.EquationIdVector(rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("")
    }
 
    void Clear() override
    {
        this->mpDofUpdater->Clear();
    }
 
    Parameters GetDefaultParameters() const override
    {
        Parameters default_parameters = Parameters(R"(
        {
            "name" : "static_scheme"
        })");
 
        // Getting base class default parameters
        const Parameters base_default_parameters = BaseType::GetDefaultParameters();
        default_parameters.RecursivelyAddMissingParameters(base_default_parameters);
        return default_parameters;
    }
 
    static std::string Name()
    {
        return "static_scheme";
    }
 
 
 
 
    std::string Info() const override
    {
        return "ResidualBasedIncrementalUpdateStaticScheme";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
 
 
protected:
 
 
 
 
 
 
 
 
private:
 
 
    typename TSparseSpace::DofUpdaterPointerType mpDofUpdater = TSparseSpace::CreateDofUpdater(); 
 
 
 
 
 
 
 
}; // Class ResidualBasedIncrementalUpdateStaticScheme
}  // namespace Kratos
 
#endif /* KRATOS_RESIDUALBASED_INCREMENTALUPDATE_STATIC_SCHEME_H  defined */