compressible_navier_stokes_explicit_solving_strategy_bfecc.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Eduard Gómez
//
//
 
#if !defined(KRATOS_COMPRESSIBLE_NAVIER_STOKES_EXPLICIT_SOLVING_STRATEGY_BFECC)
#define KRATOS_COMPRESSIBLE_NAVIER_STOKES_EXPLICIT_SOLVING_STRATEGY_BFECC
 
/* System includes */
#if __cplusplus >= 201703L
#include <optional>
#endif
 
/* External includes */
 
/* Project includes */
#include "includes/define.h"
#include "includes/model_part.h"
#include "factories/factory.h"
#include "solving_strategies/strategies/explicit_solving_strategy_bfecc.h"
 
/* Appication includes */
#include "fluid_dynamics_application_variables.h"
#include "compressible_navier_stokes_explicit_solving_strategy.h"
 
namespace Kratos
{
 
 
 
 
template <class TSparseSpace, class TDenseSpace>
class CompressibleNavierStokesExplicitSolvingStrategyBFECC
: public CompressibleNavierStokesExplicitSolvingStrategy<ExplicitSolvingStrategyBFECC<TSparseSpace, TDenseSpace>>
{
public:
 
    // The base solving strategy class definition
    typedef SolvingStrategy<TSparseSpace, TDenseSpace> SolvingStrategyType;
 
    // The base class definition
    typedef CompressibleNavierStokesExplicitSolvingStrategy<ExplicitSolvingStrategyBFECC<TSparseSpace, TDenseSpace>> BaseType;
 
    typedef CompressibleNavierStokesExplicitSolvingStrategyBFECC<TSparseSpace, TDenseSpace> ClassType;
 
    // The explicit builder and solver definition
    typedef typename BaseType::ExplicitBuilderType ExplicitBuilderType;
 
    typedef typename BaseType::DofType DofType;
 
    typedef typename TDenseSpace::VectorType LocalSystemVectorType;
    typedef typename TDenseSpace::MatrixType LocalSystemMatrixType;
 
    // Replace with proper std::optional when upgrading to c++17
#if __cplusplus >= 201703L
    // using std::optional;
#else
    template<typename T>
    struct optional {
        optional()           noexcept : mHasValue(false) { }
        optional(const T& V) noexcept : mHasValue(true), mValue(V) { }
 
        void reset() noexcept { mHasValue = false; }
 
        T& operator*() noexcept { return mValue; }
        T operator*() const noexcept { return mValue; }
        
        bool has_value() const noexcept { return mHasValue;}
    private:
        bool mHasValue;
        T mValue;
    };
#endif
 
    KRATOS_CLASS_POINTER_DEFINITION(CompressibleNavierStokesExplicitSolvingStrategyBFECC);
 
 
    explicit CompressibleNavierStokesExplicitSolvingStrategyBFECC()
        : BaseType()
    {
    }
 
    explicit CompressibleNavierStokesExplicitSolvingStrategyBFECC(
        ModelPart &rModelPart,
        Parameters ThisParameters)
        : BaseType(rModelPart)
    {
        // Validate and assign defaults
        ThisParameters = this->ValidateAndAssignParameters(ThisParameters, this->GetDefaultParameters());
        this->AssignSettings(ThisParameters);
    }
 
    explicit CompressibleNavierStokesExplicitSolvingStrategyBFECC(
        ModelPart &rModelPart,
        typename ExplicitBuilderType::Pointer pExplicitBuilder,
        bool MoveMeshFlag = false,
        int RebuildLevel = 0)
        : BaseType(rModelPart, pExplicitBuilder, MoveMeshFlag, RebuildLevel)
    {
    }
 
    explicit CompressibleNavierStokesExplicitSolvingStrategyBFECC(
        ModelPart &rModelPart,
        bool MoveMeshFlag = false,
        int RebuildLevel = 0)
        : BaseType(rModelPart, MoveMeshFlag, RebuildLevel)
    {
    }
 
    typename SolvingStrategyType::Pointer Create(
        ModelPart& rModelPart,
        Parameters ThisParameters
        ) const override
    {
        return Kratos::make_shared<ClassType>(rModelPart, ThisParameters);
    }
 
    CompressibleNavierStokesExplicitSolvingStrategyBFECC(const CompressibleNavierStokesExplicitSolvingStrategyBFECC &Other) = delete;
 
    ~CompressibleNavierStokesExplicitSolvingStrategyBFECC() override = default;
 
    static std::string Name()
    {
        std::stringstream s;
        s << "compressible_navier_stokes_explicit_solving_strategy_bfecc";
        return s.str();
    }
 
 
 
 
    Parameters GetDefaultParameters() const override
    {
        KRATOS_TRY
 
        Parameters default_parameters {};
        default_parameters.AddString("explicit_solving_strategy", Name());
 
        // Getting base class default parameters
        const Parameters base_default_parameters = BaseType::GetDefaultParameters();
        default_parameters.RecursivelyAddMissingParameters(base_default_parameters);
        return default_parameters;
 
        KRATOS_CATCH("")
    }
 
 
 
    std::string Info() const override
    {
        std::stringstream ss;
        ss << "CompressibleNavierStokesExplicitSolvingStrategyBFECC";
        return ss.str();
    }
 
 
protected:
 
 
 
 
 
    void InitializeBFECCForwardSubstep() override
    {
        BaseType::InitializeBFECCForwardSubstep();
        StashDiffusiveConstants();
        this->InitializeEverySubstep();
    };
 
    void InitializeBFECCBackwardSubstep() override
    {
        BaseType::InitializeBFECCBackwardSubstep();
        this->InitializeEverySubstep();
    };
 
    void InitializeBFECCFinalSubstep() override
    {
        BaseType::InitializeBFECCFinalSubstep();
        PopDiffusiveConstants();
        this->InitializeEverySubstep();
    };
 
    void FinalizeBFECCForwardSubstep() override
    {
        BaseType::FinalizeBFECCForwardSubstep();
        this->FinalizeEverySubstep();
    };
 
    void FinalizeBFECCBackwardSubstep() override
    {
        BaseType::FinalizeBFECCBackwardSubstep();
        this->FinalizeEverySubstep();
    };
 
    void FinalizeBFECCFinalSubstep() override
    {
        BaseType::FinalizeBFECCFinalSubstep();
        PopDiffusiveConstants();
        this->FinalizeEverySubstep();
    };
 
 
 
 
 
 
 
private:
 
 
 
#if __cplusplus >= 201703L
    struct Stash {
        std::optional<double> conductivity = {};
        std::optional<double> dynamic_viscosity = {};
    } mDiffusionStash;
#else
    struct Stash {
        optional<double> conductivity = {};
        optional<double> dynamic_viscosity = {};
    } mDiffusionStash;
#endif
 
 
 
 
    void StashDiffusiveConstants()
    {
        KRATOS_TRY
 
        auto& model_part = BaseType::GetModelPart();
        
        KRATOS_ERROR_IF(model_part.NumberOfElements() == 0) << "Model part is devoid of elements!"; // This error must be removed when MPI is implemented
 
        auto& properties = model_part.ElementsBegin()->GetProperties();
 
        if(properties.Has(CONDUCTIVITY))
        {
            auto& r_conductivity = properties.GetValue(CONDUCTIVITY);
            mDiffusionStash.conductivity = r_conductivity;
            r_conductivity = 0;
        }
 
        if(properties.Has(DYNAMIC_VISCOSITY))
        {
            auto& r_dynamic_viscosity = properties.GetValue(DYNAMIC_VISCOSITY);
            mDiffusionStash.dynamic_viscosity = r_dynamic_viscosity;
            r_dynamic_viscosity = 0;
        }
 
        KRATOS_CATCH("")
    }
 
    void PopDiffusiveConstants()
    {
        KRATOS_TRY
 
        auto& model_part = BaseType::GetModelPart();
        
        KRATOS_ERROR_IF(model_part.NumberOfElements() == 0) << "Model part is devoid of elements!"; // This error must be removed when MPI is implemented
 
        auto& properties = model_part.ElementsBegin()->GetProperties();
 
        if(mDiffusionStash.conductivity.has_value())
        {
            properties.SetValue(CONDUCTIVITY, *mDiffusionStash.conductivity);
        }
 
        if(mDiffusionStash.dynamic_viscosity.has_value())
        {
            properties.SetValue(DYNAMIC_VISCOSITY, *mDiffusionStash.dynamic_viscosity);
        }
 
        mDiffusionStash.conductivity.reset();
        mDiffusionStash.dynamic_viscosity.reset();
 
        KRATOS_CATCH("")
    }
 
 
 
 
 
 
 
};
 
 
 
 
} /* namespace Kratos.*/
 
#endif /* KRATOS_COMPRESSIBLE_NAVIER_STOKES_EXPLICIT_SOLVING_STRATEGY_BFECC  defined */