apply_compressible_navier_stokes_boundary_conditions_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main author:     Eduard Gómez
//
 
#if !defined(KRATOS_APPLY_COMPRESSIBLE_NAVIER_STOKES_BOUNDARY_CONDITIONS_PROCESS_INCLUDED )
#define  KRATOS_APPLY_COMPRESSIBLE_NAVIER_STOKES_BOUNDARY_CONDITIONS_PROCESS_INCLUDED
 
 
// System includes
#include <string>
#include <iostream>
 
 
// External includes
 
 
// Project includes
#include "includes/define.h"
#include "includes/kratos_parameters.h"
#include "includes/model_part.h"
#include "processes/process.h"
#include "containers/model.h"
#include "utilities/interval_utility.h"
namespace Kratos
{
 
 
 
 
 
 
  class KRATOS_API(FLUID_DYNAMICS_APPLICATION) ApplyCompressibleNavierStokesBoundaryConditionsProcess: public Process
  {
  public:
        //
        typedef ModelPart::NodeType NodeType;
        typedef Variable<array_1d<double, 3>> VectorVariable;
        
        class BoundaryConditionUtility
        {
        public:
            BoundaryConditionUtility(
                const std::string& rVariableName,
                const double Value,
                const IntervalUtility& rIntervalUtility);
            void ActivateIfInsideTimeInterval(const double Time);
 
            void Enforce(NodeType& rNode) const;
 
            const Variable<double> & GetVariable() const;
 
        private:
            const Variable<double> * mpVariable;    // Variable to fix
            const double mValue;                    // Value to enforce
            IntervalUtility mInterval;              // Interval to enforce in
            
            static void FixDof(const BoundaryConditionUtility& rUtility, NodeType& rNode);
 
            decltype(FixDof) * mEnforceInternal = nullptr;
        };
 
        KRATOS_CLASS_POINTER_DEFINITION(ApplyCompressibleNavierStokesBoundaryConditionsProcess);
 
 
        ApplyCompressibleNavierStokesBoundaryConditionsProcess(Model& rModel, Parameters Parameters);
 
 
 
 
        
        void ExecuteInitialize() override;
 
        void ExecuteInitializeSolutionStep() override;
 
        void ExecuteFinalizeSolutionStep() override;
 
        const Parameters GetDefaultParameters() const override;
 
 
 
 
 
 
        std::string Info() const override;
 
        void PrintInfo(std::ostream& rOStream) const override;
 
 
 
 
        private:
 
 
 
        ModelPart * mpModelPart;
        VectorVariable const * mpFlowDirectionVariable;
        bool mRefreshNormalsEveryTimeStep;
        std::vector<BoundaryConditionUtility> mSubsonicBCs = {};
        std::vector<BoundaryConditionUtility> mSupersonicBCs = {};
 
 
 
        
        void ReadBoundaryCondition(std::vector<BoundaryConditionUtility> & rBCList, Parameters Parameters);
 
 
 
 
 
 
        ApplyCompressibleNavierStokesBoundaryConditionsProcess& operator=(ApplyCompressibleNavierStokesBoundaryConditionsProcess const& rOther);
 
        ApplyCompressibleNavierStokesBoundaryConditionsProcess(ApplyCompressibleNavierStokesBoundaryConditionsProcess const& rOther);
 
 
 
        }; // Class ApplyCompressibleNavierStokesBoundaryConditionsProcess
 
 
 
 
 
 
    inline std::ostream& operator << (
        std::ostream& rOStream,
        const ApplyCompressibleNavierStokesBoundaryConditionsProcess& rThis);
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_APPLY_COMPRESSIBLE_NAVIER_STOKES_BOUNDARY_CONDITIONS_PROCESS_INCLUDED  defined