explicit_runge_kutta_4_eulerian_convdiff_strategy.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Tosi
//
//
 
#if !defined(KRATOS_EXPLICIT_RUNGE_KUTTA_4_EULERIAN_CONVDIFF_STRATEGY)
#define KRATOS_EXPLICIT_RUNGE_KUTTA_4_EULERIAN_CONVDIFF_STRATEGY
 
/* System includes */
 
/* External includes */
 
/* Project includes */
#include "solving_strategies/strategies/explicit_solving_strategy_runge_kutta.h"
#include "includes/convection_diffusion_settings.h"
 
namespace Kratos
{
 
 
 
 
 
 
template <class TSparseSpace, class TDenseSpace>
class ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion : public ExplicitSolvingStrategyRungeKutta4<TSparseSpace, TDenseSpace>
{
public:
 
    // The base class definition
    typedef ExplicitSolvingStrategyRungeKutta4<TSparseSpace, TDenseSpace> BaseType;
 
    // The explicit builder and solver definition
    typedef typename BaseType::ExplicitBuilderType ExplicitBuilderType;
 
    typedef typename TDenseSpace::VectorType LocalSystemVectorType;
 
    KRATOS_CLASS_POINTER_DEFINITION(ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion);
 
 
    explicit ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion(
        ModelPart &rModelPart,
        Parameters ThisParameters)
        : BaseType(rModelPart, ThisParameters)
    {
    }
 
    explicit ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion(
        ModelPart &rModelPart,
        typename ExplicitBuilderType::Pointer pExplicitBuilder,
        bool MoveMeshFlag = false,
        int RebuildLevel = 0)
        : BaseType(rModelPart, pExplicitBuilder, MoveMeshFlag, RebuildLevel)
    {
    }
 
    explicit ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion(
        ModelPart &rModelPart,
        bool MoveMeshFlag = false,
        int RebuildLevel = 0)
        : BaseType(rModelPart, MoveMeshFlag, RebuildLevel)
    {
    }
 
    ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion(const ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion &Other) = delete;
 
    virtual ~ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion() = default;
 
 
 
 
    void Initialize() override
    {
        KRATOS_TRY;
 
 
        auto& r_model_part = BaseType::GetModelPart();
        auto& r_process_info = r_model_part.GetProcessInfo();
        ConvectionDiffusionSettings::Pointer p_settings = r_process_info[CONVECTION_DIFFUSION_SETTINGS];
        auto& r_settings = *p_settings;
 
        // Call the base method
        BaseType::Initialize();
        // If required, initialize the OSS projection variables
        if (r_process_info[OSS_SWITCH]) {
            for (auto& r_node : r_model_part.GetCommunicator().LocalMesh().Nodes()) {
                r_node.SetValue(r_settings.GetProjectionVariable(), 0.0);
            }
        }
 
        KRATOS_CATCH("");
    }
 
 
    std::string Info() const override
    {
        return "ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion";
    }
 
    void PrintInfo(std::ostream &rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream &rOStream) const override
    {
        rOStream << Info();
    }
 
 
protected:
 
 
 
 
 
 
    virtual void InitializeRungeKuttaIntermediateSubStep() override
    {
        KRATOS_TRY;
 
        BaseType::InitializeRungeKuttaIntermediateSubStep();
 
        auto& r_model_part = BaseType::GetModelPart();
        auto& r_process_info = r_model_part.GetProcessInfo();
 
        // execute OSS step, if needed
        if (r_process_info[OSS_SWITCH] == 1) {
            CalculateOSSNodalProjections();
        }
 
        KRATOS_CATCH("");
    };
 
    virtual void InitializeRungeKuttaLastSubStep() override
    {
        KRATOS_TRY;
 
        BaseType::InitializeRungeKuttaLastSubStep();
        auto& r_model_part = BaseType::GetModelPart();
        auto& r_process_info = r_model_part.GetProcessInfo();
 
        // execute OSS step, if needed
        if (r_process_info[OSS_SWITCH] == 1) {
            CalculateOSSNodalProjections();
        }
 
        KRATOS_CATCH("");
    };
 
    virtual bool SolveSolutionStep() override
    {
        KRATOS_TRY;
 
        BaseType::SolveSolutionStep();
        auto& r_model_part = BaseType::GetModelPart();
        auto& r_process_info = r_model_part.GetProcessInfo();
        if (r_process_info.GetValue(RUNGE_KUTTA_STEP) == 4) {
            // execute OSS step, if needed
            if (r_process_info[OSS_SWITCH] == 1) {
                CalculateOSSNodalProjections();
            }
        }
 
        return true;
 
        KRATOS_CATCH("");
    };
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
    virtual void CalculateOSSNodalProjections()
    {
        KRATOS_TRY;
 
        // Get the required data from the explicit builder and solver
        const auto p_explicit_bs = BaseType::pGetExplicitBuilder();
        const auto& r_lumped_mass_vector = p_explicit_bs->GetLumpedMassMatrixVector();
 
        // Get model part data
        auto& r_model_part = BaseType::GetModelPart();
        auto& r_process_info = r_model_part.GetProcessInfo();
 
        ConvectionDiffusionSettings::Pointer p_settings = r_process_info[CONVECTION_DIFFUSION_SETTINGS];
        auto& r_settings = *p_settings;
 
        // Initialize the projection value
        block_for_each(r_model_part.Nodes(), [&](Node& rNode){
            rNode.GetValue(r_settings.GetProjectionVariable()) = 0.0;
        });
 
        // Calculate the unknown projection
        double unknown_proj;
        block_for_each(r_model_part.Elements(), [&](ModelPart::ElementType& rElement){
            rElement.Calculate(r_settings.GetProjectionVariable(), unknown_proj, r_process_info);
        });
        IndexPartition<int>(r_model_part.NumberOfNodes()).for_each(
            [&](int i_node){
                auto it_node = r_model_part.NodesBegin() + i_node;
                const double mass = r_lumped_mass_vector(i_node);
                it_node->FastGetSolutionStepValue(r_settings.GetProjectionVariable()) = it_node->GetValue(r_settings.GetProjectionVariable()) / mass;
            }
        );
 
        KRATOS_CATCH("");
    };
 
 
 
 
 
 
 
}; /* Class ExplicitSolvingStrategyRungeKutta4ConvectionDiffusion */
 
 
 
 
} /* namespace Kratos.*/
 
#endif /* KRATOS_EXPLICIT_RUNGE_KUTTA_4_EULERIAN_CONVDIFF_STRATEGY  defined */