compute_nodal_normal_divergence_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Mohammad R. Hashemi (based on the work by Riccardo Rossi and Vicente Mataix Ferrandiz)
//
 
#if !defined(KRATOS_COMPUTE_DIVERGENCE_PROCESS_INCLUDED )
#define  KRATOS_COMPUTE_DIVERGENCE_PROCESS_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "processes/process.h"
#include "includes/model_part.h"
#include "utilities/variable_utils.h"
#include "utilities/geometry_utilities.h"
#include "utilities/parallel_utilities.h"
 
namespace Kratos
{
 
 
 
 
 
 
struct ComputeNodalDivergenceProcessSettings
{
    // Defining clearer options
    constexpr static bool SaveAsHistoricalVariable = true;
    constexpr static bool SaveAsNonHistoricalVariable = false;
};
 
template<bool THistorical>
class KRATOS_API(KRATOS_CORE) ComputeNodalNormalDivergenceProcess
    : public Process
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(ComputeNodalNormalDivergenceProcess);
 
 
    ComputeNodalNormalDivergenceProcess(
        ModelPart& rModelPart,
        const Variable<array_1d<double,3> >& rOriginVariable,
        const Variable<double>& rDivergenceVariable,
        const Variable<double>& rAreaVariable = NODAL_AREA,
        const bool NormalizeDivergence = true,
        const bool NonHistoricalOriginVariable = false
        );
 
    ~ComputeNodalNormalDivergenceProcess() override = default;
 
 
    void operator()()
    {
        Execute();
    }
 
 
 
    void Execute() override;
 
 
 
 
 
 
    std::string Info() const override
    {
        return "ComputeNodalNormalDivergenceProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "ComputeNodalNormalDivergenceProcess";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
 
 
 
private:
 
 
 
    ModelPart& mrModelPart;                                
    const Variable<array_1d<double,3>>* mpOriginVariable;  
    const Variable<double>* mpDivergenceVariable;          
    const Variable<double>* mpAreaVariable;                
    bool mNormalizeDivergence = true;
    bool mNonHistoricalOriginVariable = false;                   
 
 
 
    void ClearDivergence();
 
    double& GetDivergence(
        Element::GeometryType& rThisGeometry,
        unsigned int i
        );
 
    void SynchronizeDivergenceAndVolume();
 
    void PonderateDivergence();
 
    static array_1d<double,3> GetHistoricalNormalVectorField(
        const Node& rNode,
        const Variable<array_1d<double,3>>& rVariable
    );
 
    static array_1d<double,3> GetNonHistoricalNormalVectorField(
        const Node& rNode,
        const Variable<array_1d<double,3>>& rVariable
    );
 
    static array_1d<double,3> GetHistoricalVectorField(
        const Node& rNode,
        const Variable<array_1d<double,3>>& rVariable
    );
 
    static array_1d<double,3> GetNonHistoricalVectorField(
        const Node& rNode,
        const Variable<array_1d<double,3>>& rVariable
    );
 
 
 
 
 
 
 
 
}; // Class ComputeNodalNormalDivergenceProcess
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_COMPUTE_DIVERGENCE_PROCESS_INCLUDED  defined