apply_chimera_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Authors:        Aditya Ghantasala, https://github.com/adityaghantasala
//                  Navaneeth K Narayanan
//                  Rishith Ellath Meethal
//
 
 
#if !defined(KRATOS_APPLY_CHIMERA_H_INCLUDED)
#define KRATOS_APPLY_CHIMERA_H_INCLUDED
 
// System includes
#include <unordered_map>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "constraints/linear_master_slave_constraint.h"
#include "includes/model_part.h"
#include "processes/process.h"
#include "utilities/binbased_fast_point_locator.h"
 
// Application includes
#include "chimera_application_variables.h"
#include "custom_utilities/distance_calcuation_utility.h"
#include "custom_utilities/hole_cutting_utility.h"
 
namespace Kratos {
 
 
 
 
 
 
template <int TDim>
class KRATOS_API(CHIMERA_APPLICATION) ApplyChimera : public Process {
public:
 
    typedef ModelPart::IndexType IndexType;
    typedef ModelPart::NodeType NodeType;
    typedef Kratos::Variable<double> VariableType;
    typedef std::vector<IndexType> ConstraintIdsVectorType;
    typedef typename ModelPart::MasterSlaveConstraintType MasterSlaveConstraintType;
    typedef typename ModelPart::MasterSlaveConstraintContainerType MasterSlaveConstraintContainerType;
    typedef std::vector<MasterSlaveConstraintContainerType> MasterSlaveContainerVectorType;
    typedef BinBasedFastPointLocator<TDim> PointLocatorType;
    typedef typename PointLocatorType::Pointer PointLocatorPointerType;
    typedef ModelPart::NodesContainerType NodesContainerType;
 
    KRATOS_CLASS_POINTER_DEFINITION(ApplyChimera);
 
 
    explicit ApplyChimera(ModelPart& rMainModelPart, Parameters iParameters);
 
    virtual ~ApplyChimera()=default;
 
 
 
    void SetEchoLevel(int EchoLevel);
 
    void SetReformulateEveryStep(bool Reformulate);
 
    virtual void ExecuteInitializeSolutionStep() override;
 
    virtual void ExecuteFinalizeSolutionStep() override;
 
    virtual std::string Info() const override;
 
    virtual void PrintInfo(std::ostream& rOStream) const override;
 
    virtual void PrintData(std::ostream& rOStream) const override;
 
 
 
protected:
 
    ModelPart& mrMainModelPart;
    int mNumberOfLevels;
    Parameters mParameters;
    std::unordered_map<IndexType, ConstraintIdsVectorType> mNodeIdToConstraintIdsMap;
    int mEchoLevel;
    bool mReformulateEveryStep;
    std::map<std::string, PointLocatorPointerType> mPointLocatorsMap;
    bool mIsFormulated;
 
    // Modelpart names which are generated here
    const std::string mModifiedName = "ChimeraModified";
    const std::string mBoundaryName = "ChimeraBoundary";
    const std::string mHoleName = "ChimeraHole";
 
 
    virtual void DoChimeraLoop();
 
    virtual void FormulateChimera(const Parameters BackgroundParam,
                                  const Parameters PatchParameters,
                                  ChimeraHoleCuttingUtility::Domain DomainType);
 
    void CreateConstraintIds(std::vector<int>& rIdVector,
                                     const IndexType NumberOfConstraintsRequired);
    virtual void ApplyContinuityWithMpcs(ModelPart& rBoundaryModelPart,
                                         PointLocatorType& pBinLocator);
 
    template <typename TVariableType>
    void AddMasterSlaveRelation(MasterSlaveConstraintContainerType& rMasterSlaveContainer,
                                const LinearMasterSlaveConstraint& rCloneConstraint,
                                unsigned int ConstraintId,
                                NodeType& rMasterNode,
                                TVariableType& rMasterVariable,
                                NodeType& rSlaveNode,
                                TVariableType& rSlaveVariable,
                                const double Weight,
                                const double Constant = 0.0);
 
    template <typename TVariableType>
    void ApplyContinuityWithElement(Geometry<NodeType>& rGeometry,
                                    NodeType& rBoundaryNode,
                                    Vector& rShapeFuncWeights,
                                    TVariableType& rVariable,
                                    unsigned int StartIndex,
                                    std::vector<int>& rConstraintIdVector,
                                    MasterSlaveConstraintContainerType& rMsContainer);
 
    void ReserveMemoryForConstraintContainers(ModelPart& rModelPart,
                                              MasterSlaveContainerVectorType& rContainerVector);
 
    int RemoveExistingConstraintsForNode(ModelPart::NodeType& rBoundaryNode);
 
    void AddConstraintsToModelpart(ModelPart& rModelPart,
                                   MasterSlaveContainerVectorType& rContainerVector);
 
    void FormulateConstraints(ModelPart& rBoundaryModelPart,
                              PointLocatorType& rBinLocator,
                              MasterSlaveContainerVectorType& rVelocityMasterSlaveContainerVector,
                              MasterSlaveContainerVectorType& rPressureMasterSlaveContainerVector);
 
 
 
 
private:
 
 
 
 
    ModelPart& ExtractPatchBoundary(const Parameters PatchParameters,
                                    ModelPart& rBackgroundBoundaryModelpart,
                                    const ChimeraHoleCuttingUtility::Domain DomainType);
 
    PointLocatorPointerType GetPointLocator(ModelPart& rModelPart);
 
    bool SearchNode(PointLocatorType& rBinLocator,
                    NodeType& rNodeToFind,
                    Element::Pointer& prHostElement,
                    Vector& rWeights);
 
    void MakeConstraints(NodeType& rNodeToFind,
                         Element::Pointer& rHostElement,
                         Vector& rWeights,
                         MasterSlaveConstraintContainerType& rVelocityMsConstraintsVector,
                         MasterSlaveConstraintContainerType& rPressureMsConstraintsVector,
                         std::vector<int>& rConstraintIdVector,
                         const IndexType StartConstraintId);
 
 
 
}; // Class ApplyChimera
 
} // namespace Kratos.
 
#endif //  KRATOS_APPLY_CHIMERA_H_INCLUDED defined