solving_strategy.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//                   Ruben Zorrilla
//
 
#if !defined(KRATOS_SOLVING_STRATEGY)
#define KRATOS_SOLVING_STRATEGY
 
// System includes
 
 
// External includes
 
 
// Project includes
#include "includes/define.h"
#include "includes/model_part.h"
#include "solving_strategies/schemes/scheme.h"
#include "solving_strategies/builder_and_solvers/builder_and_solver.h"
#include "includes/kratos_parameters.h"
#include "utilities/parallel_utilities.h"
#include "utilities/variable_utils.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
 
 
 
template<class TSparseSpace, class TDenseSpace>
class SolvingStrategy
{
public:
 
    typedef typename TSparseSpace::DataType                                        TDataType;
 
    typedef typename TSparseSpace::MatrixType                              TSystemMatrixType;
 
    typedef typename TSparseSpace::VectorType                              TSystemVectorType;
 
    typedef typename TSparseSpace::MatrixPointerType                TSystemMatrixPointerType;
 
    typedef typename TSparseSpace::VectorPointerType                TSystemVectorPointerType;
 
    typedef typename TDenseSpace::MatrixType                           LocalSystemMatrixType;
 
    typedef typename TDenseSpace::VectorType                           LocalSystemVectorType;
 
    typedef SolvingStrategy<TSparseSpace, TDenseSpace>                             ClassType;
 
    typedef typename ModelPart::DofType                                             TDofType;
 
    typedef typename ModelPart::DofsArrayType                                  DofsArrayType;
 
    typedef ModelPart::NodesContainerType                                     NodesArrayType;
 
    typedef ModelPart::ElementsContainerType                               ElementsArrayType;
 
    typedef ModelPart::ConditionsContainerType                           ConditionsArrayType;
 
    KRATOS_CLASS_POINTER_DEFINITION(SolvingStrategy);
 
 
    explicit SolvingStrategy() { }
 
    explicit SolvingStrategy(
        ModelPart& rModelPart,
        Parameters ThisParameters)
        : mpModelPart(&rModelPart)
    {
        // Validate and assign defaults
        ThisParameters = this->ValidateAndAssignParameters(ThisParameters, this->GetDefaultParameters());
        this->AssignSettings(ThisParameters);
    }
 
    explicit SolvingStrategy(
        ModelPart& rModelPart,
        bool MoveMeshFlag = false)
        : mpModelPart(&rModelPart)
    {
        SetMoveMeshFlag(MoveMeshFlag);
    }
 
    virtual ~SolvingStrategy(){}
 
 
 
 
    virtual typename ClassType::Pointer Create(
        ModelPart& rModelPart,
        Parameters ThisParameters) const
    {
        return Kratos::make_shared<ClassType>(rModelPart, ThisParameters);
    }
 
    virtual void Predict()
    {
    }
 
    virtual void Initialize()
    {
    }
 
    virtual double Solve()
    {
        Initialize();
        InitializeSolutionStep();
        Predict();
        SolveSolutionStep();
        FinalizeSolutionStep();
 
        return 0.0;
 
    }
 
    virtual void Clear()
    {
    }
 
    virtual bool IsConverged()
    {
        return true;
    }
 
    virtual void CalculateOutputData()
    {
    }
 
    virtual void InitializeSolutionStep()
    {
    }
 
    virtual void FinalizeSolutionStep()
    {
    }
 
    virtual bool SolveSolutionStep()
    {
        return true;
    }
 
    virtual void SetEchoLevel(const int Level)
    {
        mEchoLevel = Level;
    }
 
    int GetEchoLevel()
    {
        return mEchoLevel;
    }
 
    void SetMoveMeshFlag(bool Flag)
    {
        mMoveMeshFlag = Flag;
    }
 
    // TODO: DEPRECATE THIS IN FAVOR OF GetMoveMeshFlag()
    bool MoveMeshFlag()
    {
        return mMoveMeshFlag;
    }
 
    bool GetMoveMeshFlag()
    {
        return mMoveMeshFlag;
    }
 
    virtual void SetRebuildLevel(int Level)
    {
        KRATOS_ERROR << "Accessing the strategy base class \'SetRebuildLevel\'. Please implement it in your derived class." << std::endl;
    }
 
    virtual int GetRebuildLevel() const
    {
        KRATOS_ERROR << "Accessing the strategy base class \'GetRebuildLevel\'. Please implement it in your derived class." << std::endl;
    }
 
    virtual void MoveMesh()
    {
        KRATOS_TRY
 
        KRATOS_ERROR_IF_NOT(GetModelPart().HasNodalSolutionStepVariable(DISPLACEMENT_X)) << "It is impossible to move the mesh since the DISPLACEMENT var is not in the Model Part. Either use SetMoveMeshFlag(False) or add DISPLACEMENT to the list of variables" << std::endl;
 
        block_for_each(GetModelPart().Nodes(), [](Node& rNode){
            noalias(rNode.Coordinates()) = rNode.GetInitialPosition().Coordinates();
            noalias(rNode.Coordinates()) += rNode.FastGetSolutionStepValue(DISPLACEMENT);
        });
 
        KRATOS_INFO_IF("SolvingStrategy", this->GetEchoLevel() != 0) << " MESH MOVED " << std::endl;
 
        KRATOS_CATCH("")
    }
 
    ModelPart& GetModelPart()
    {
        return *mpModelPart;
    };
 
    const ModelPart& GetModelPart() const
    {
        return *mpModelPart;
    };
 
    virtual double GetResidualNorm()
    {
        return 0.0;
    }
 
    virtual int Check()
    {
        KRATOS_TRY
 
        // Check if displacement var is needed
        if (mMoveMeshFlag) {
            VariableUtils().CheckVariableExists<>(DISPLACEMENT, GetModelPart().Nodes());
        }
 
        GetModelPart().Check();
 
        return 0;
 
        KRATOS_CATCH("")
    }
 
    virtual Parameters GetDefaultParameters() const
    {
        const Parameters default_parameters = Parameters(R"(
        {
            "name"                         : "solving_strategy",
            "move_mesh_flag"               : false,
            "echo_level"                   : 1
        })");
        return default_parameters;
    }
 
    virtual TSystemMatrixType& GetSystemMatrix()
    {
        KRATOS_TRY
 
        KRATOS_ERROR << "\'GetSystemMatrix\' not implemented in base \'SolvingStrategy\'" << std::endl;
 
        KRATOS_CATCH("");
    }
 
    virtual TSystemVectorType& GetSystemVector()
    {
        KRATOS_TRY
 
        KRATOS_ERROR << "\'GetSystemVector\' not implemented in base \'SolvingStrategy\'" << std::endl;
 
        KRATOS_CATCH("");
    }
 
    virtual TSystemVectorType& GetSolutionVector()
    {
        KRATOS_TRY
 
        KRATOS_ERROR << "\'GetSolutionVector\' not implemented in base \'SolvingStrategy\'" << std::endl;
 
        KRATOS_CATCH("");
    }
 
    static std::string Name()
    {
        return "solving_strategy";
    }
 
 
    virtual std::string Info() const
    {
        return "SolvingStrategy";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << Info();
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
        rOStream << Info();
    }
 
 
protected:
 
    // Level of echo for the solving strategy
    int mEchoLevel;
 
 
 
 
 
 
    virtual Parameters ValidateAndAssignParameters(
        Parameters ThisParameters,
        const Parameters DefaultParameters) const
    {
        ThisParameters.ValidateAndAssignDefaults(DefaultParameters);
        return ThisParameters;
    }
 
    virtual void AssignSettings(const Parameters ThisParameters)
    {
        // By default mesh is not moved
        mMoveMeshFlag = ThisParameters["move_mesh_flag"].GetBool();
 
        // Be default the minimal information is shown
        mEchoLevel = ThisParameters["echo_level"].GetInt();
    }
 
 
 
 
 
 
private:
 
 
 
 
    ModelPart* mpModelPart = nullptr;
 
    bool mMoveMeshFlag;
 
 
 
 
 
 
 
 
 
 
    SolvingStrategy(const SolvingStrategy& Other);
 
 
}; /* Class SolvingStrategy */
 
 
 
 
 
} /* namespace Kratos.*/
 
#endif /* KRATOS_SOLVING_STRATEGY  defined */