assign_master_slave_constraints_to_neighbours_utility.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main author:     Sebastian Ares de Parga Regalado
//
 
#pragma once
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Include kratos definitions
#include "includes/define.h"
 
// Application includes
#include "utilities/variable_utils.h"
#include "utilities/rbf_shape_functions_utility.h"
 
// Project includes
#include "spatial_containers/spatial_search.h"
#include "spatial_containers/bins_dynamic.h"
#include "utilities/builtin_timer.h"
 
namespace Kratos {
 
 
class KRATOS_API(KRATOS_CORE) AssignMasterSlaveConstraintsToNeighboursUtility
{
    public:
      
      //Node Types
      using NodeType = ModelPart::NodeType;
 
      //Dof types
      using DofType = NodeType::DofType;
 
      //Configure Types
      using NodesContainerType = ModelPart::NodesContainerType;
 
      //Bin
      using NodeBinsType = BinsDynamic<3, NodeType, NodesContainerType::ContainerType>;
 
      using ConstraintContainerType = ModelPart::MasterSlaveConstraintContainerType;
      using ResultNodesContainerType = NodesContainerType::ContainerType;
      using VectorResultNodesContainerType = std::vector<ResultNodesContainerType>;
      using RadiusArrayType = std::vector<double>;
 
      using DofPointerVectorType = std::vector< Dof<double>::Pointer >;
 
      KRATOS_CLASS_POINTER_DEFINITION(AssignMasterSlaveConstraintsToNeighboursUtility);
 
 
      AssignMasterSlaveConstraintsToNeighboursUtility(NodesContainerType& rMasterStructureNodes);
 
      virtual ~AssignMasterSlaveConstraintsToNeighboursUtility();
 
 
      void SearchNodesInRadiusForNode(
          NodeType::Pointer pSlaveNode,
          double const Radius,
          ResultNodesContainerType& rCloudOfNodes,
          ResultNodesContainerType& rLocalResults);
 
      void GetDofsAndCoordinatesForSlaveNode(
          NodeType::Pointer pSlaveNode,
          const std::vector<std::reference_wrapper<const Kratos::Variable<double>>>& rVariableList,
          std::vector<DofPointerVectorType>& rSlaveDofs,
          array_1d<double, 3>& rSlaveCoordinates
      );
 
      void GetDofsAndCoordinatesForCloudOfNodes(
          const ResultNodesContainerType& CloudOfNodesArray,
          const std::vector<std::reference_wrapper<const Kratos::Variable<double>>>& rVariableList,
          std::vector<DofPointerVectorType>& rCloudOfDofs,
          Matrix& rCloudOfNodesCoordinates
      );
 
      void AssignMasterSlaveConstraintsToNodes(
          NodesContainerType pSlaveNodes,
          double const Radius,
          ModelPart& rComputingModelPart,
          const std::vector<std::reference_wrapper<const Kratos::Variable<double>>>& rVariableList,
          double const MinNumOfNeighNodes
      );
 
 
      virtual std::string Info() const
      {
          std::stringstream buffer;
          buffer << "AssignMasterSlaveConstraintsToNeighboursUtility" ;
 
          return buffer.str();
      }
 
      virtual void PrintInfo(std::ostream& rOStream) const  {rOStream << "AssignMasterSlaveConstraintsToNeighboursUtility";}
 
      virtual void PrintData(std::ostream& rOStream) const  {}
 
 
    private:
      NodeBinsType::UniquePointer mpBins;
      int mMaxNumberOfNodes;
 
}; // Class AssignMasterSlaveConstraintsToNeighboursUtility
}  // namespace Kratos.