BoundaryConditionFactory.h

Go to the documentation of this file.

//=======================================================================================
// ____          ____    __    ______     __________   __      __       __        __
// \    \       |    |  |  |  |   _   \  |___    ___| |  |    |  |     /  \      |  |
//  \    \      |    |  |  |  |  |_)   |     |  |     |  |    |  |    /    \     |  |
//   \    \     |    |  |  |  |   _   /      |  |     |  |    |  |   /  /\  \    |  |
//    \    \    |    |  |  |  |  | \  \      |  |     |   \__/   |  /  ____  \   |  |____
//     \    \   |    |  |__|  |__|  \__\     |__|      \________/  /__/    \__\  |_______|
//      \    \  |    |   ________________________________________________________________
//       \    \ |    |  |  ______________________________________________________________|
//        \    \|    |  |  |         __          __     __     __     ______      _______
//         \         |  |  |_____   |  |        |  |   |  |   |  |   |   _  \    /  _____)
//          \        |  |   _____|  |  |        |  |   |  |   |  |   |  | \  \   \_______
//           \       |  |  |        |  |_____   |   \_/   |   |  |   |  |_/  /    _____  |
//            \ _____|  |__|        |________|   \_______/    |__|   |______/    (_______/
//
//  This file is part of VirtualFluids. VirtualFluids is free software: you can
//  redistribute it and/or modify it under the terms of the GNU General Public
//  License as published by the Free Software Foundation, either version 3 of
//  the License, or (at your option) any later version.
//
//  VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
//  for more details.
//
//  SPDX-License-Identifier: GPL-3.0-or-later
//  SPDX-FileCopyrightText: Copyright © VirtualFluids Project contributors, see AUTHORS.md in root folder
//
//=======================================================================================
#ifndef BC_FACTORY
#define BC_FACTORY
 
#include <functional>
#include <map>
#include <string>
#include <variant>
 
#include <GridGenerator/grid/BoundaryConditions/Side.h>
 
#include "Calculation/Calculation.h"
#include "Parameter/Parameter.h"
 
namespace vf::gpu {
 
struct LBMSimulationParameter;
class Parameter;
 
using BoundaryConditionKernel = std::function<void(LBMSimulationParameter*, QforBoundaryConditions*)>;
using DirectionalBoundaryConditionKernel = std::function<void(LBMSimulationParameter*, QforDirectionalBoundaryCondition*)>;
using BoundaryConditionWithParameterKernel = std::function<void(Parameter*, QforBoundaryConditions*, const int level)>;
using PrecursorBoundaryConditionKernel =
    std::function<void(LBMSimulationParameter*, QforPrecursorBoundaryConditions*, real timeRatio, real velocityRatio)>;
 
using AdvectionDiffusionNoFluxBoundaryConditionKernel = std::function<void(LBMSimulationParameter *, AdvectionDiffusionNoFluxBoundaryConditions)>;
using AdvectionDiffusionFluxBoundaryConditionKernel = std::function<void(LBMSimulationParameter *, AdvectionDiffusionFluxBoundaryConditions)>;
using AdvectionDiffusionDirichletBoundaryConditionKernel = std::function<void(LBMSimulationParameter *, AdvectionDiffusionDirichletBoundaryConditions)>;
using AdvectionDiffusionNeumannBoundaryConditionKernel = std::function<void(LBMSimulationParameter *, AdvectionDiffusionNeumannBoundaryConditions)>;
using DirectionalADBoundaryConditionKernel = std::function<void(LBMSimulationParameter*, QforDirectionalADBoundaryCondition*)>;
 
class BoundaryConditionFactory
{
public:
    virtual ~BoundaryConditionFactory() = default;
    enum class VelocityBC {
        VelocityBounceBack,
        VelocityInterpolatedIncompressible,
        VelocityInterpolatedCompressible,
        VelocityWithPressureInterpolatedCompressible,
        NotSpecified
    };
 
    enum class NoSlipBC {
        NoSlipDelayBounceBack,
        NoSlipBounceBack,
        NoSlipInterpolatedIncompressible,
        NoSlipInterpolatedCompressible,
    };
 
    enum class SlipBC {
        SlipBounceBack,
        SlipCompressible,
        SlipTurbulentViscosityCompressible,
        NotSpecified
    };
 
    enum class PressureBC {
        PressureNonEquilibriumIncompressible,
        PressureNonEquilibriumCompressible,
        OutflowNonReflective,
        OutflowNonReflectivePressureCorrection,
        NotSpecified
    };
 
    enum class StressBC {
        StressBounceBackCompressible,
        StressBounceBackWithPressureCompressible,
        StressInterpolatedCompressible,
        NotSpecified
    };
 
    // enum class OutflowBoundaryCondition {};  // TODO:
    // https://git.rz.tu-bs.de/m.schoenherr/VirtualFluids_dev/-/issues/16
 
    enum class PrecursorBC {
        PrecursorNonReflectiveCompressible,
        PrecursorDistributions,
        PrecursorVelTemperatureDistributions,
        NotSpecified
    };
 
    enum class AdvectionDiffusionNoFluxBC { 
        NoFluxDelayedBounceBack, 
        NoFluxBounceBack,
    };
 
    // Works well at high velocities.
    enum class AdvectionDiffusionFluxBC {
        FluxTurbulentViscosityCompressible,
        FluxCompressible,
        FluxBounceBack,
        NotSpecified
    };
 
    enum class AdvectionDiffusionDirichletBC {
        DirichletInterpolatedSlip,
        DirichletAntiBounceBackSlip,
        DirichletInterpolatedNoSlip,
        DirichletAntiBounceBackNoSlip,
        NotSpecified
    };
 
    enum class AdvectionDiffusionNeumannBC {
        NeumannInterpolatedSlip,
        NeumannAntiBounceBackSlip,
        NeumannInterpolatedNoSlip,
        NeumannAntiBounceBackNoSlip,
        NotSpecified
    };
 
    enum class SurfaceLayerBC {
        SurfaceHeatFlux,
        SurfaceTemperature,
        NotSpecified
    };
    enum class AdvectionDiffusionDirectionalBC {
        DirectionalOutflowNonReflecting,
        NotSpecified
    };
 
    void setVelocityBoundaryCondition(BoundaryConditionFactory::VelocityBC boundaryConditionType);
    void setNoSlipBoundaryCondition(BoundaryConditionFactory::NoSlipBC boundaryConditionType);
    void setSlipBoundaryCondition(BoundaryConditionFactory::SlipBC boundaryConditionType);
    void setPressureBoundaryCondition(BoundaryConditionFactory::PressureBC boundaryConditionType);
    void setStressBoundaryCondition(BoundaryConditionFactory::StressBC boundaryConditionType);
    void setPrecursorBoundaryCondition(BoundaryConditionFactory::PrecursorBC boundaryConditionType);
    void setGeometryBoundaryCondition(std::variant<VelocityBC, NoSlipBC, SlipBC> boundaryConditionType);
    void setAdvectionDiffusionNoFluxBoundaryCondition(AdvectionDiffusionNoFluxBC boundaryConditionType);
    void setAdvectionDiffusionFluxBoundaryCondition(AdvectionDiffusionFluxBC boundaryConditionType);
    void setAdvectionDiffusionDirichletBoundaryCondition(AdvectionDiffusionDirichletBC boundaryConditionType);
    void setAdvectionDiffusionNeumannBoundaryCondition(AdvectionDiffusionNeumannBC boundaryConditionType);
    void setSurfaceLayerBoundaryCondition(StressBC momentumBoundaryConditionType, SurfaceLayerBC surfaceLayerBoundaryConditionType);
    void setAdvectionDiffusionDirectionalBoundaryCondition(AdvectionDiffusionDirectionalBC boundaryConditionType);
    // void setOutflowBoundaryCondition(...); // TODO:
    // https://git.rz.tu-bs.de/m.schoenherr/VirtualFluids_dev/-/issues/16
 
    [[nodiscard]] virtual BoundaryConditionKernel getVelocityBoundaryConditionPost(bool isGeometryBC = false) const;
    [[nodiscard]] BoundaryConditionKernel getNoSlipBoundaryConditionPost(bool isGeometryBC = false) const;
    [[nodiscard]] BoundaryConditionKernel getSlipBoundaryConditionPost(bool isGeometryBC = false) const;
    [[nodiscard]] BoundaryConditionKernel getGeometryBoundaryConditionPost() const;
    [[nodiscard]] virtual std::variant<BoundaryConditionKernel, DirectionalBoundaryConditionKernel> getPressureBoundaryConditionPre() const;
    [[nodiscard]] BoundaryConditionKernel getStressBoundaryConditionPost() const;
    [[nodiscard]] PrecursorBoundaryConditionKernel getPrecursorBoundaryConditionPost() const;
    [[nodiscard]] AdvectionDiffusionNoFluxBoundaryConditionKernel getAdvectionDiffusionNoFluxBoundaryConditionPost() const;
    [[nodiscard]] AdvectionDiffusionFluxBoundaryConditionKernel getAdvectionDiffusionFluxBoundaryConditionPost() const;
    [[nodiscard]] AdvectionDiffusionDirichletBoundaryConditionKernel getAdvectionDiffusionDirichletBoundaryConditionPost() const;
    [[nodiscard]] AdvectionDiffusionNeumannBoundaryConditionKernel getAdvectionDiffusionNeumannBoundaryConditionPost() const;
    [[nodiscard]] DirectionalADBoundaryConditionKernel getAdvectionDiffusionDirectionalBoundaryConditionPost() const;
    [[nodiscard]] BoundaryConditionKernel getSurfaceLayerBoundaryConditionPost() const;
    [[nodiscard]] virtual bool hasDirectionalPressureBoundaryCondition() const;
 
private:
    VelocityBC velocityBoundaryCondition = VelocityBC::NotSpecified;
    NoSlipBC noSlipBoundaryCondition = NoSlipBC::NoSlipDelayBounceBack;
    SlipBC slipBoundaryCondition = SlipBC::NotSpecified;
    PressureBC pressureBoundaryCondition = PressureBC::NotSpecified;
    std::variant<VelocityBC, NoSlipBC, SlipBC> geometryBoundaryCondition = NoSlipBC::NoSlipDelayBounceBack;
    StressBC stressBoundaryCondition = StressBC::NotSpecified;
    PrecursorBC precursorBoundaryCondition = PrecursorBC::NotSpecified;
    AdvectionDiffusionNoFluxBC advectionDiffusionNoFluxBoundaryCondition = AdvectionDiffusionNoFluxBC::NoFluxDelayedBounceBack;
    AdvectionDiffusionFluxBC advectionDiffusionFluxBoundaryCondition = AdvectionDiffusionFluxBC::NotSpecified;
    AdvectionDiffusionDirichletBC advectionDiffusionDirichletBoundaryCondition = AdvectionDiffusionDirichletBC::NotSpecified;
    AdvectionDiffusionNeumannBC advectionDiffusionNeumannBoundaryCondition = AdvectionDiffusionNeumannBC::NotSpecified;
    AdvectionDiffusionDirectionalBC advectionDiffusionDirectionalBoundaryCondition = AdvectionDiffusionDirectionalBC::NotSpecified;
    std::pair<StressBC, SurfaceLayerBC> surfaceLayerBoundaryCondition = {StressBC::NotSpecified, SurfaceLayerBC::NotSpecified};
 
    // OutflowBoundaryConditon outflowBC // TODO: https://git.rz.tu-bs.de/m.schoenherr/VirtualFluids_dev/-/issues/16
};
 
}
 
#endif