parallel_distance_calculation_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//
//
 
#if !defined(KRATOS_PARALLEL_DISTANCE_CALCULATOR_H_INCLUDED )
#define  KRATOS_PARALLEL_DISTANCE_CALCULATOR_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/model_part.h"
#include "process.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
 
 
 
 
 
template <unsigned int TDim>
class KRATOS_API(KRATOS_CORE) ParallelDistanceCalculationProcess : public Process
{
public:
 
    enum class NodalDatabase {
        NodeHistorical,
        NodeNonHistorical
    };
 
    using NodeType = typename ModelPart::NodeType;
 
    using NodeScalarGetFunctionType = std::function<double&(NodeType& rNode)>;
 
    KRATOS_CLASS_POINTER_DEFINITION(ParallelDistanceCalculationProcess);
 
 
    ParallelDistanceCalculationProcess(
        ModelPart &rModelPart,
        Parameters Settings);
 
    ParallelDistanceCalculationProcess(
        Model &rModel,
        Parameters Settings);
 
    ParallelDistanceCalculationProcess(ParallelDistanceCalculationProcess<TDim> const& rOther) = delete;
 
    virtual ~ParallelDistanceCalculationProcess() {};
 
    const Parameters GetDefaultParameters() const override;
 
    int Check() override;
 
    void Execute() override;
 
    //TODO: This method must be removed as it does not match the base process API
    double FindMaximumEdgeSize();
 
 
 
 
 
 
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "ParallelDistanceCalculationProcess" << TDim << "D";
        return buffer.str();
    };
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "ParallelDistanceCalculationProcess" << TDim << "D";
    };
 
    void PrintData(std::ostream& rOStream) const override {};
 
 
 
protected:
 
 
 
        ModelPart& mrModelPart;
        const Variable<double>* mpDistanceVar;
        const Variable<double>* mpAreaVar;
        unsigned int mMaxLevels;
        double mMaxDistance;
        bool mCalculateExactDistancesToPlane;
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    const Variable<double>* mpAuxDistanceVar;
 
    NodalDatabase mDistanceDatabase;
 
    NodeScalarGetFunctionType mDistanceGetter;
    NodeScalarGetFunctionType mAuxDistanceGetter;
    NodeScalarGetFunctionType mNodalAreaGetter;
 
 
 
 
    void ResetVariables();
 
    void CalculateExactDistancesOnDividedElements();
 
    void ExtendDistancesByLayer();
 
    void AssignDistanceSign();
 
    bool IsDivided(const array_1d<double,TDim+1>& rDistance);
 
    bool IsActive(const array_1d<double,TDim+1>& rVisited);
 
    void AddDistanceToNodes(
        Geometry<NodeType>& rGeometry,
        const BoundedMatrix<double,TDim+1,TDim>& rDN_DX,
        const double& Volume);
 
 
 
 
 
 
 
}; // Class ParallelDistanceCalculationProcess
 
 
template<unsigned int TDim>
inline std::istream& operator >> (
    std::istream& rIStream,
    ParallelDistanceCalculationProcess<TDim>& rThis)
{
    return rIStream;
}
 
template<unsigned int TDim>
inline std::ostream& operator << (
    std::ostream& rOStream,
    const ParallelDistanceCalculationProcess<TDim>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}  // namespace Kratos.
 
#endif // KRATOS_PARALLEL_DISTANCE_CALCULATOR_H_INCLUDED  defined