depth_integration_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Miguel Maso Sotomayor
//
 
#ifndef KRATOS_DEPTH_INTEGRATION_PROCESS_H_INCLUDED
#define KRATOS_DEPTH_INTEGRATION_PROCESS_H_INCLUDED
 
 
// System includes
 
 
// External includes
 
 
// Project includes
#include "containers/model.h"
#include "processes/process.h"
#include "includes/kratos_parameters.h"
#include "utilities/binbased_fast_point_locator.h"
 
namespace Kratos
{
 
 
 
 
 
class ModelPart;
 
template<std::size_t TDim>
class KRATOS_API(SHALLOW_WATER_APPLICATION) DepthIntegrationProcess : public Process
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(DepthIntegrationProcess);
 
    using NodeType = Node;
 
    using GeometryType = Geometry<NodeType>;
 
 
    DepthIntegrationProcess() = delete;
 
    DepthIntegrationProcess(Model& rModel, Parameters ThisParameters = Parameters());
 
    ~DepthIntegrationProcess() override = default;
 
 
 
 
    void Execute() override;
 
    int Check() override;
 
    const Parameters GetDefaultParameters() const override;
 
 
 
 
 
 
    std::string Info() const override {
        std::stringstream buffer;
        buffer << "DepthIntegrationProcess";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override {}
 
 
 
 
private:
 
    ModelPart& mrVolumeModelPart;
    ModelPart& mrInterfaceModelPart;
    array_1d<double,3> mDirection;
    bool mStoreHistorical;
 
    // Option to print a debug file
    bool mPrintVelocityProfile;
 
    // Option to substitute the boundaries by the neighbor
    bool mExtrapolateBoundaries;
    NodeType::Pointer mpFirstBoundaryNode;
    NodeType::Pointer mpSecondBoundaryNode;
    NodeType::Pointer mpFirstBoundaryNeighbor;
    NodeType::Pointer mpSecondBoundaryNeighbor;
 
 
 
 
    void GetBoundingVolumeLimits(double& rMin, double& rMax);
 
    void Integrate(
        NodeType& rNode,
        const double Bottom,
        const double Top,
        BinBasedFastPointLocator<TDim>& rLocator,
        typename BinBasedFastPointLocator<TDim>::ResultContainerType& rResults,
        Vector& rShapeFunctionsValues);
 
    array_1d<double,3> InterpolateVelocity(
        const Element::Pointer ElementId,
        const Vector& rShapeFunctionValues) const;
 
    template<class TDataType, class TVarType = Variable<TDataType>>
    void SetValue(NodeType& rNode, const TVarType& rVariable, TDataType rValue)
    {
        if (mStoreHistorical)
            rNode.FastGetSolutionStepValue(rVariable) = rValue;
        else
            rNode.GetValue(rVariable) = rValue;
    }
 
    template<class TDataType, class TVarType = Variable<TDataType>>
    TDataType GetValue(const NodeType& rNode, const TVarType& rVariable)
    {
        if (mStoreHistorical)
            return rNode.FastGetSolutionStepValue(rVariable);
        else
            return rNode.GetValue(rVariable);
    }
 
    void FindBoundaryNeighbors();
 
    void CopyValues(const NodeType& rOriginNode, NodeType& rDestinationNode);
 
 
 
 
 
 
    DepthIntegrationProcess& operator=(DepthIntegrationProcess const& rOther) = delete;
 
    DepthIntegrationProcess(DepthIntegrationProcess const& rOther) = delete;
 
 
}; // Class DepthIntegrationProcess
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_DEPTH_INTEGRATION_PROCESS_H_INCLUDED defined