explicit_solving_strategy.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Ruben Zorrilla
//
//
 
#if !defined(KRATOS_EXPLICIT_SOLVING_STRATEGY)
#define KRATOS_EXPLICIT_SOLVING_STRATEGY
 
// System includes
 
// External includes
 
// Project includes
#include "solving_strategy.h"
#include "includes/define.h"
#include "includes/model_part.h"
#include "utilities/variable_utils.h"
#include "utilities/parallel_utilities.h"
#include "solving_strategies/builder_and_solvers/explicit_builder.h"
#include "includes/kratos_parameters.h"
#include "utilities/entities_utilities.h"
 
namespace Kratos
{
 
 
 
 
 
 
template <class TSparseSpace, class TDenseSpace>
class ExplicitSolvingStrategy : public SolvingStrategy<TSparseSpace, TDenseSpace>
{
public:
 
    // The explicit builder and solver definition
    typedef ExplicitBuilder<TSparseSpace, TDenseSpace> ExplicitBuilderType;
 
    // The explicit builder and solver pointer definition
    typedef typename ExplicitBuilderType::Pointer ExplicitBuilderPointerType;
 
    // The DOF type from the explicit builder and solver class
    typedef typename ExplicitBuilderType::DofType DofType;
 
    typedef SolvingStrategy<TSparseSpace, TDenseSpace> BaseType;
 
    typedef ExplicitSolvingStrategy<TSparseSpace, TDenseSpace> ClassType;
 
    KRATOS_CLASS_POINTER_DEFINITION(ExplicitSolvingStrategy);
 
 
    explicit ExplicitSolvingStrategy()
    {
    }
 
    explicit ExplicitSolvingStrategy(
        ModelPart &rModelPart,
        Parameters ThisParameters)
        : BaseType(rModelPart, ThisParameters)
    {
        mpExplicitBuilder = Kratos::make_unique<ExplicitBuilder<TSparseSpace, TDenseSpace>>();
    }
 
    explicit ExplicitSolvingStrategy(
        ModelPart &rModelPart,
        typename ExplicitBuilderType::Pointer pExplicitBuilder,
        bool MoveMeshFlag = false,
        int RebuildLevel = 0)
        : BaseType(rModelPart, MoveMeshFlag)
        , mpExplicitBuilder(pExplicitBuilder)
    {
        SetRebuildLevel(RebuildLevel);
    }
 
    explicit ExplicitSolvingStrategy(
        ModelPart &rModelPart,
        bool MoveMeshFlag = false,
        int RebuildLevel = 0)
        : BaseType(rModelPart, MoveMeshFlag)
    {
        SetRebuildLevel(RebuildLevel);
        mpExplicitBuilder = Kratos::make_unique<ExplicitBuilder<TSparseSpace, TDenseSpace>>();
    }
 
    ExplicitSolvingStrategy(const ExplicitSolvingStrategy &Other) = delete;
 
    virtual ~ExplicitSolvingStrategy() {}
 
    typename BaseType::Pointer Create(
        ModelPart& rModelPart,
        Parameters ThisParameters
        ) const override
    {
        return Kratos::make_shared<ClassType>(rModelPart, ThisParameters);
    }
 
 
 
    void Initialize() override
    {
        // Initialize elements, conditions and constraints
        EntitiesUtilities::InitializeAllEntities(BaseType::GetModelPart());
 
        // Set the explicit DOFs rebuild level
        if (mRebuildLevel != 0) {
            mpExplicitBuilder->SetResetDofSetFlag(true);
        }
 
        // If the mesh is updated at each step, we require to accordingly update the lumped mass at each step
        if (BaseType::GetMoveMeshFlag()) {
            mpExplicitBuilder->SetResetLumpedMassVectorFlag(true);
        }
 
        // Call the explicit builder and solver initialize (Set up DOF set and lumped mass vector)
        mpExplicitBuilder->Initialize(BaseType::GetModelPart());
 
    }
 
    void Clear() override
    {
        // This clears the DOF set and lumped mass vector
        mpExplicitBuilder->Clear();
    }
 
    void InitializeSolutionStep() override
    {
        // InitializeSolutionStep elements, conditions and constraints
        EntitiesUtilities::InitializeSolutionStepAllEntities(BaseType::GetModelPart());
 
        // Call the builder and solver initialize solution step
        mpExplicitBuilder->InitializeSolutionStep(BaseType::GetModelPart());
    }
 
    void FinalizeSolutionStep() override
    {
        // FinalizeSolutionStep elements, conditions and constraints
        EntitiesUtilities::FinalizeSolutionStepAllEntities(BaseType::GetModelPart());
 
        // Call the builder and solver finalize solution step (the reactions are computed in here)
        mpExplicitBuilder->FinalizeSolutionStep(BaseType::GetModelPart());
    }
 
    bool SolveSolutionStep() override
    {
        // Call the initialize non-linear iteration
        EntitiesUtilities::InitializeNonLinearIterationAllEntities(BaseType::GetModelPart());
 
        // Apply constraints
        if(BaseType::GetModelPart().MasterSlaveConstraints().size() != 0) {
            mpExplicitBuilder->ApplyConstraints(BaseType::GetModelPart());
        }
 
        // Solve the problem assuming that a lumped mass matrix is used
        SolveWithLumpedMassMatrix();
 
        // If required, update the mesh with the obtained solution
        if (BaseType::GetMoveMeshFlag()) {
            BaseType::MoveMesh();
        }
 
        // Call the finalize non-linear iteration
        EntitiesUtilities::FinalizeNonLinearIterationAllEntities(BaseType::GetModelPart());
 
        return true;
    }
 
    void SetRebuildLevel(int Level) override
    {
        mRebuildLevel = Level;
    }
 
    int GetRebuildLevel() const override
    {
        return mRebuildLevel;
    }
 
    ExplicitBuilderPointerType pGetExplicitBuilder()
    {
        return mpExplicitBuilder;
    };
 
    ExplicitBuilderType& GetExplicitBuilder()
    {
        KRATOS_ERROR_IF(mpExplicitBuilder == nullptr) << "Asking for builder and solver when it is empty" << std::endl;
        return *mpExplicitBuilder;
    };
 
    const ExplicitBuilderType& GetExplicitBuilder() const
    {
        KRATOS_ERROR_IF(mpExplicitBuilder == nullptr) << "Asking for builder and solver when it is empty" << std::endl;
        return *mpExplicitBuilder;
    };
 
    double GetResidualNorm() override
    {
        // Get the required data from the explicit builder and solver
        auto& r_explicit_bs = GetExplicitBuilder();
        auto& r_dof_set = r_explicit_bs.GetDofSet();
 
        // Calculate the explicit residual
        r_explicit_bs.BuildRHS(BaseType::GetModelPart());
 
        // Calculate the residual norm
        double res_norm = 0.0;
        res_norm = block_for_each<SumReduction<double>>(
            r_dof_set,
            [](DofType &rDof){return rDof.GetSolutionStepReactionValue();}
        );
 
        return res_norm;
    }
 
    Parameters GetDefaultParameters() const override
    {
        Parameters default_parameters = Parameters(R"(
        {
            "explicit_solving_strategy" : "explicit_solving_strategy",
            "rebuild_level"             : 0,
            "explicit_builder_settings" : {
                "name": "explicit_builder"
            }
        })");
 
        // 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 "explicit_solving_strategy";
    }
 
 
    std::string Info() const override
    {
        return "ExplicitSolvingStrategy";
    }
 
protected:
 
    // Settings for the rebuilding of the DOF set
    int mRebuildLevel;
 
 
 
 
    virtual void SolveWithLumpedMassMatrix()
    {
        KRATOS_ERROR << "Calling the base ExplicitSolvingStrategy SolveWithLumpedMassMatrix(). Implement the specific explicit scheme solution update in a derived class" << std::endl;
    }
 
    virtual inline double GetDeltaTime()
    {
        return BaseType::GetModelPart().GetProcessInfo().GetValue(DELTA_TIME);
    }
 
    void AssignSettings(const Parameters ThisParameters) override
    {
        // Add base strategy settings
        BaseType::AssignSettings(ThisParameters);
 
        const bool rebuild_level = ThisParameters["rebuild_level"].GetInt();
        SetRebuildLevel(rebuild_level);
    }
 
 
 
 
private:
 
 
 
    ExplicitBuilderPointerType mpExplicitBuilder = nullptr;
 
 
 
 
 
 
}; /* Class NewExplicitSolvingStrategy */
 
 
 
 
} /* namespace Kratos.*/
 
#endif /* KRATOS_EXPLICIT_SOLVING_STRATEGY  defined */