point_configure.h

Go to the documentation of this file.

//   Project Name:        Kratos
//   Last Modified by:    $Author: Nelson Lafontaine  $
//   Date:                $Date: 2012-05-24 $
//   Revision:            $Revision: 1.0 $
//
 
 
#if !defined(KRATOS_POINT_CONFIGURE)
#define  KRATOS_POINT_CONFIGURE
 
 
 
// System includes
#include <string>
#include <iostream>
#include <cmath>
#include "utilities/spatial_containers_configure.h"
 
// Kratos includes
#include "includes/variables.h"
#include "spatial_containers/spatial_search.h"
//#include "GeometryFunctions.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
template <std::size_t TDimension>
class PointConfigure{
public:
 
enum {Dimension = TDimension,
      DIMENSION = TDimension,
      MAX_LEVEL = 16,
      MIN_LEVEL = 2
};
 
typedef SpatialSearch                                                       SearchType;
 
typedef SearchType::PointType                                               PointType;
typedef PointerVectorSet<Point, IndexedObject>::ContainerType   ContainerType;
typedef PointerVectorSet<Point, IndexedObject>                  PointsContainerType;
 
typedef ContainerType::value_type                                           PointerType;
typedef ContainerType::iterator                                             IteratorType;
 
typedef PointerVectorSet<Point, IndexedObject>::ContainerType   ResultContainerType;
 
 
typedef ResultContainerType::iterator                           ResultIteratorType;
typedef std::vector<double>::iterator                           DistanceIteratorType;
 
KRATOS_CLASS_POINTER_DEFINITION(PointConfigure);
 
 
PointConfigure(){};
virtual ~PointConfigure(){}
 
 
 
 
 
//******************************************************************************************************************
//******************************************************************************************************************
 
static inline void CalculateBoundingBox(const PointerType& r_p_point, PointType& r_low_point, PointType& r_high_point){
    r_high_point = r_low_point = *r_p_point;
}
 
//******************************************************************************************************************
//******************************************************************************************************************
 
static inline void CalculateBoundingBox(const PointerType& r_p_point, PointType& r_low_point, PointType& r_high_point, const double& radius){
    r_high_point = r_low_point  = *r_p_point;
 
    for (std::size_t i = 0; i < 3; ++i){
        r_low_point[i]  -= radius;
        r_high_point[i] += radius;
    }
}
 
//******************************************************************************************************************
//******************************************************************************************************************
 
static inline void CalculateCenter(const PointerType& r_p_point, PointType& rCenter){
    rCenter = *r_p_point;
}
 
//******************************************************************************************************************
//******************************************************************************************************************
 
static inline bool Intersection(const PointerType& r_p_point_1, const PointerType& r_p_point_2){
    return false;
}
 
//******************************************************************************************************************
//******************************************************************************************************************
 
static inline bool Intersection(const PointerType& r_p_point_1, const PointerType& r_p_point_2, const double& radius){
    array_1d<double, 3> node_2_to_1 = *r_p_point_1 - *r_p_point_2;
    double distance;
    Distance(r_p_point_1, r_p_point_2, distance);
 
    bool intersect = (distance - radius) <= 0;
 
    return intersect;
}
 
//******************************************************************************************************************
//******************************************************************************************************************
 
static inline bool  IntersectionBox(const PointerType& r_p_point,  const PointType& r_low_point, const PointType& r_high_point)
{
    array_1d<double, 3> center = *r_p_point;
 
    bool intersect = (r_low_point[0] <= center[0] &&  r_low_point[1] <= center[1] &&  r_low_point[2] <= center[2] &&
                     r_high_point[0] >= center[0] && r_high_point[1] >= center[1] && r_high_point[2] >= center[2]);
 
    return  intersect;
 
}
 
//******************************************************************************************************************
//******************************************************************************************************************
 
static inline bool  IntersectionBox(const PointerType& r_p_point,  const PointType& r_low_point, const PointType& r_high_point, const double& radius)
{
    array_1d<double, 3> center = *r_p_point;
 
    bool intersect = (r_low_point[0] - radius <= center[0] &&  r_low_point[1] - radius <= center[1] &&  r_low_point[2] - radius <= center[2] &&
                     r_high_point[0] + radius >= center[0] && r_high_point[1] + radius >= center[1] && r_high_point[2] + radius >= center[2]);
 
    return  intersect;
}
 
//******************************************************************************************************************
//******************************************************************************************************************
 
static inline void Distance(const PointerType& r_p_point_1, const PointerType& r_p_point_2, double& distance)
{
    array_1d<double, 3> center_1 = *r_p_point_1;
    array_1d<double, 3> center_2 = *r_p_point_2;
 
    distance = sqrt((center_1[0] - center_2[0]) * (center_1[0] - center_2[0]) +
                    (center_1[1] - center_2[1]) * (center_1[1] - center_2[1]) +
                    (center_1[2] - center_2[2]) * (center_1[2] - center_2[2]));
}
 
//******************************************************************************************************************
//******************************************************************************************************************
 
 
 
 
 
 
virtual std::string Info() const {return " Spatial Containers Configure for Particles"; }
 
virtual void PrintInfo(std::ostream& rOStream) const {}
 
virtual void PrintData(std::ostream& rOStream) const {}
 
 
 
 
protected:
 
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
PointConfigure& operator=(PointConfigure const& rOther);
 
PointConfigure(PointConfigure const& rOther);
 
 
}; // Class ParticleConfigure
 
 
 
 
    template <std::size_t TDimension>
    inline std::istream& operator >> (std::istream& rIStream, PointConfigure<TDimension> & rThis){
        return rIStream;
        }
 
    template <std::size_t TDimension>
    inline std::ostream& operator << (std::ostream& rOStream, const PointConfigure<TDimension>& rThis){
        rThis.PrintInfo(rOStream);
        rOStream << std::endl;
        rThis.PrintData(rOStream);
 
        return rOStream;
        }
 
 
}   // namespace Kratos.
#endif  /* KRATOS_POINT_CONFIGURE */