distance_modification_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Ruben Zorrilla
//
//
 
#ifndef KRATOS_DISTANCE_MODIFICATION_PROCESS_H
#define KRATOS_DISTANCE_MODIFICATION_PROCESS_H
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "processes/process.h"
#include "includes/kratos_parameters.h"
 
// Application includes
 
 
namespace Kratos
{
 
 
 
 
 
 
class KRATOS_API(FLUID_DYNAMICS_APPLICATION) DistanceModificationProcess : public Process
{
public:
 
    typedef Variable<double> ComponentType;
    
    static constexpr std::array<std::array<std::size_t,2>, 3> NodeIDs2D {{ {{1,2}}, {{2,0}}, {{0,1}} }};
    static constexpr std::array<std::array<std::size_t,2>, 6> NodeIDs3D {{ {{0,1}}, {{1,2}}, {{2,0}}, {{0,3}}, {{1,3}}, {{2,3}} }};    
 
    KRATOS_CLASS_POINTER_DEFINITION(DistanceModificationProcess);
 
 
    DistanceModificationProcess(
        ModelPart& rModelPart,
        const double FactorCoeff, //TODO: Remove it (here for legacy reasons)
        const double DistanceThreshold,
        const bool CheckAtEachStep,
        const bool NegElemDeactivation,
        const bool RecoverOriginalDistance);
 
    DistanceModificationProcess(
        ModelPart& rModelPart,
        Parameters& rParameters);
 
    DistanceModificationProcess(
        Model& rModel,
        Parameters& rParameters);
 
    ~DistanceModificationProcess() override {}
 
 
    void Execute() override;
 
    void ExecuteInitialize() override;
 
    void ExecuteBeforeSolutionLoop() override;
 
    void ExecuteInitializeSolutionStep() override;
 
    void ExecuteFinalizeSolutionStep() override;
 
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "DistanceModificationProcess" ;
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override {rOStream << "DistanceModificationProcess";}
 
    void PrintData(std::ostream& rOStream) const override {}
 
 
 
 
private:
 
 
    ModelPart&                                       mrModelPart;
    double                                    mDistanceThreshold;
    bool                                             mIsModified;
    bool                                     mContinuousDistance;
    bool                                        mCheckAtEachStep;
    bool                                    mNegElemDeactivation;
    bool                               mAvoidAlmostEmptyElements;
    bool                                mRecoverOriginalDistance;
    std::vector<std::size_t>               mModifiedDistancesIDs;
    std::vector<double>                 mModifiedDistancesValues;
    std::vector<Vector>        mModifiedElementalDistancesValues;
    std::vector<const Variable<double>*>    mDoubleVariablesList;
    std::vector<const ComponentType*>    mComponentVariablesList;
 
 
 
    void CheckDefaultsAndProcessSettings(Parameters &rParameters);
 
    void InitializeEmbeddedIsActive();
 
    void ModifyDistance();
 
    void ModifyDiscontinuousDistance();
 
    void RecoverDeactivationPreviousState();
 
    void RecoverOriginalDistance();
 
    void RecoverOriginalDiscontinuousDistance();
 
    void DeactivateFullNegativeElements();
 
    template<class TDistancesVectorType>
    void SetElementToSplitFlag(
        Element &rElem,
        const TDistancesVectorType& rDistancesVector)
    {
        std::size_t n_pos = 0;
        std::size_t n_neg = 0;
        for (double i_dist : rDistancesVector) {
            if (i_dist < 0.0) {
                n_neg++;
            } else {
                n_pos++;
            }
        }
        if (n_neg != 0 && n_pos != 0) {
            rElem.Set(TO_SPLIT, true);
        } else {
            rElem.Set(TO_SPLIT, false);
        }
    }
 
    void SetContinuousDistanceToSplitFlag();
 
    void SetDiscontinuousDistanceToSplitFlag();
 
    void CheckAndStoreVariablesList(const std::vector<std::string>& rVariableStringArray);
 
    const std::array<std::size_t,2> GetNodeIDs(
        const std::size_t NumEdges, 
        const std::size_t EdgeID);
 
 
 
 
 
 
    DistanceModificationProcess() = delete;
 
    DistanceModificationProcess& operator=(DistanceModificationProcess const& rOther) = delete;
 
    DistanceModificationProcess(DistanceModificationProcess const& rOther) = delete;
 
 
}; // Class DistanceModificationProcess
 
 
 
 
 
};  // namespace Kratos.
 
#endif // KRATOS_DISTANCE_MODIFICATION_PROCESS_H