template<unsigned int dim, typename T>
class Box< dim, T >
This class represent an N-dimensional box. 
The box is defined by two points p2 and p1
                     +---------+ p2
                     |         |
                     |         |
                     |         |
                     |         |
                     |         |
                p1   +---------+- Template Parameters
 - 
  
    | dim | dimensionality of the Box  | 
    | T | type of space ... double float int size_t | 
  
   
Expand the box with some spacing
 
    float spacing[2] = {0.1,0.1};
 
 
    BOOST_REQUIRE_CLOSE(sp.getLow(0),1.0,0.0001);
    BOOST_REQUIRE_CLOSE(sp.getLow(1),1.0,0.0001);
 
    BOOST_REQUIRE_CLOSE(sp.getHigh(0),2.1,0.0001);
    BOOST_REQUIRE_CLOSE(sp.getHigh(1),3.1,0.0001);
 
This class represent an N-dimensional box.
 
void expand(T(&exp)[dim])
expand the box by a vector
 
  
Create an enclosing box
 
 
 
    BOOST_REQUIRE_EQUAL(box1.getLow(0),0.1f);
    BOOST_REQUIRE_EQUAL(box1.getLow(1),0.2f);
    BOOST_REQUIRE_EQUAL(box1.getLow(2),0.3f);
 
    BOOST_REQUIRE_EQUAL(box1.getHigh(0),2.0f);
    BOOST_REQUIRE_EQUAL(box1.getHigh(1),2.1f);
    BOOST_REQUIRE_EQUAL(box1.getHigh(2),2.2f);
 
void enclose(const Box< dim, T > &en)
Refine the box to enclose the given box and itself.
 
  
Create the smallest boxes between several boxes
 
    box1.contained(box3);
 
    BOOST_REQUIRE_CLOSE(box1.getHigh(0),1.0f,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getHigh(1),0.1f,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getHigh(2),1.0f,0.0001);
 
void contained(const Box< dim, T > &en, const bool reset_p1=true)
Refine the box to be contained in the given box and itself.
 
  
Enlarge the box
 
 
 
    BOOST_REQUIRE_CLOSE(box1.getLow(0),-0.4,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getLow(1),-0.4,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getLow(2),-0.4,0.0001);
 
    BOOST_REQUIRE_CLOSE(box1.getHigh(0),1.5,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getHigh(1),1.7,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getHigh(2),2.0,0.0001);
 
void enlarge(const Box< dim, T > &gh)
Enlarge the box with ghost margin.
 
  
Enlarge the box with fixed P1
 
 
 
    BOOST_REQUIRE_CLOSE(box1.getLow(0),0.1,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getLow(1),0.2,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getLow(2),0.3,0.0001);
 
    BOOST_REQUIRE_CLOSE(box1.getHigh(0),2.0,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getHigh(1),2.3,0.0001);
    BOOST_REQUIRE_CLOSE(box1.getHigh(2),2.7,0.0001);
 
void enlarge_fix_P1(Box< dim, S > &gh)
Enlarge the box with ghost margin keeping fix the point P1.
 
- See also
 - SpaceBox 
 
Definition at line 60 of file Box.hpp.
 
 | 
| __device__ __host__ bool  | Intersect (const Box< dim, T > &b, Box< dim, T > &b_out) const | 
|   | Intersect.  
  | 
|   | 
| template<typename Mem >  | 
| __device__ __host__ bool  | Intersect (const encapc< 1, Box< dim, T >, Mem > &e_b, Box< dim, T > &b_out) const | 
|   | Intersect.  
  | 
|   | 
| template<typename distance >  | 
| bool  | Intersect (Sphere< dim, T > &sphere) | 
|   | Check if the sphere intersect the box.  
  | 
|   | 
| T  | min_distance (Box< dim, T > &b) const | 
|   | 
| template<unsigned int b>  | 
| T  | getBase (const unsigned int i) const | 
|   | Get the coordinate of the bounding point.  
  | 
|   | 
| Box< dim-1, T >  | getSubBox () | 
|   | Get the the box of dimensionality dim-1 (it eliminate the last dimension)  
  | 
|   | 
| __device__ __host__ Box< dim, T > &  | operator= (const Box< dim, T > &box) | 
|   | Operator= between boxes.  
  | 
|   | 
| __device__ __host__  | Box () | 
|   | default constructor  
  | 
|   | 
|   | Box (const Point< dim, T > &p1, const Point< dim, T > &p2) | 
|   | Constructor from two points.  
  | 
|   | 
|   | Box (std::initializer_list< T > p1, std::initializer_list< T > p2) | 
|   | Constructor from initializer list.  
  | 
|   | 
|   | Box (T *low, T *high) | 
|   | Box constructor from a box.  
  | 
|   | 
| __device__ __host__  | Box (const Box< dim, T > &box) | 
|   | Box constructor from a box.  
  | 
|   | 
|   | Box (type box_data) | 
|   | Box constructor from vector::fusion.  
  | 
|   | 
|   | Box (T(&box_data)[dim]) | 
|   | Box constructor from an array reference.  
  | 
|   | 
|   | Box (const grid_key_dx< dim > &key1, const grid_key_dx< dim > &key2) | 
|   | constructor from 2 grid_key_dx  
  | 
|   | 
| template<unsigned int dimS>  | 
| __device__ __host__  | Box (boost::fusion::vector< T[dimS], T[dimS]> &box_data) | 
|   | Box constructor from vector::fusion of higher dimension.  
  | 
|   | 
| template<typename Mem >  | 
| __device__ __host__  | Box (const encapc< 1, Box< dim, T >, Mem > &b) | 
|   | Box constructor from encapsulated box.  
  | 
|   | 
| template<typename S >  | 
| __device__ __host__  | Box (const Box< dim, S > &b) | 
|   | constructor from a Box of different type  
  | 
|   | 
| Box< dim, T > &  | operator/= (const Point< dim, T > &p) | 
|   | Divide component wise each box points with a point.  
  | 
|   | 
| Box< dim, T >  | operator* (const Point< dim, T > &p) | 
|   | Multiply component wise each box points with a point.  
  | 
|   | 
| void  | set (std::initializer_list< T > p1, std::initializer_list< T > p2) | 
|   | Constructor from initializer list.  
  | 
|   | 
| __device__ __host__ void  | setLow (int i, T val) | 
|   | set the low interval of the box  
  | 
|   | 
| __device__ __host__ void  | setHigh (int i, T val) | 
|   | set the high interval of the box  
  | 
|   | 
| __device__ __host__ T  | getLow (int i) const | 
|   | get the i-coordinate of the low bound interval of the box  
  | 
|   | 
| __device__ __host__ T  | getHigh (int i) const | 
|   | get the high interval of the box  
  | 
|   | 
| void  | setP1 (const grid_key_dx< dim > &p1) | 
|   | Set the point P1 of the box.  
  | 
|   | 
| void  | setP2 (const grid_key_dx< dim > &p2) | 
|   | Set the point P2 of the box.  
  | 
|   | 
| void  | setP1 (const Point< dim, T > &p1) | 
|   | Set the point P1 of the box.  
  | 
|   | 
| void  | setP2 (const Point< dim, T > &p2) | 
|   | Set the point P2 of the box.  
  | 
|   | 
| Box< dim, T > &  | getBox () | 
|   | Get the box enclosing this Box.  
  | 
|   | 
| const Box< dim, T > &  | getBox () const | 
|   | Get the box enclosing this Box.  
  | 
|   | 
| type &  | getVector () | 
|   | Get the internal boost::fusion::vector that store the data.  
  | 
|   | 
| grid_key_dx< dim >  | getKP1 () const | 
|   | Get the point p1 as grid_key_dx.  
  | 
|   | 
| grid_key_dx< dim >  | getKP2 () const | 
|   | Get the point p12 as grid_key_dx.  
  | 
|   | 
| grid_key_dx< dim, int >  | getKP1int () const | 
|   | Get the point p1 as grid_key_dx.  
  | 
|   | 
| grid_key_dx< dim, int >  | getKP2int () const | 
|   | Get the point p12 as grid_key_dx.  
  | 
|   | 
| Point< dim, T >  | getP1 () const | 
|   | Get the point p1.  
  | 
|   | 
| Point< dim, T >  | getP2 () const | 
|   | Get the point p2.  
  | 
|   | 
| Box< dim, T > &  | operator-= (const Point< dim, T > &p) | 
|   | Translate the box.  
  | 
|   | 
| Box< dim, T > &  | operator+= (const Point< dim, T > &p) | 
|   | Translate the box.  
  | 
|   | 
| Box< dim, T >  | operator+ (const Point< dim, T > &p) | 
|   | Translate the box.  
  | 
|   | 
| void  | expand (T(&exp)[dim]) | 
|   | expand the box by a vector  
  | 
|   | 
| void  | enlarge (const Box< dim, T > &gh) | 
|   | Enlarge the box with ghost margin.  
  | 
|   | 
| template<typename S >  | 
| void  | enlarge_fix_P1 (Box< dim, S > &gh) | 
|   | Enlarge the box with ghost margin keeping fix the point P1.  
  | 
|   | 
| void  | invalidate () | 
|   | Invalidate the box.  
  | 
|   | 
| void  | magnify (T mg) | 
|   | Magnify the box.  
  | 
|   | 
| void  | magnify_fix_P1 (T mg) | 
|   | Magnify the box by a factor keeping fix the point P1.  
  | 
|   | 
| void  | shrinkP2 (T sh) | 
|   | Shrink moving p2 of sh quantity (on each direction)  
  | 
|   | 
| void  | enclose (const Box< dim, T > &en) | 
|   | Refine the box to enclose the given box and itself.  
  | 
|   | 
| void  | contained (const Box< dim, T > &en, const bool reset_p1=true) | 
|   | Refine the box to be contained in the given box and itself.  
  | 
|   | 
| void  | zero () | 
|   | Set p1 and p2 to 0.  
  | 
|   | 
| bool  | isContained (const Box< dim, T > &b) const | 
|   | Check if the box is contained.  
  | 
|   | 
| __host__ __device__ bool  | isInside (const Point< dim, T > &p) const | 
|   | Check if the point is inside the box.  
  | 
|   | 
| __device__ __host__ bool  | isInsideNP (const Point< dim, T > &p) const | 
|   | Check if the point is inside the region excluding the positive part.  
  | 
|   | 
| template<typename bc_type >  | 
| __device__ __host__ bool  | isInsideNP_with_border (const Point< dim, T > &p, const Box< dim, T > &border, const bc_type(&bc)[dim]) const | 
|   | Check if the point is inside the region excluding the positive part.  
  | 
|   | 
| bool  | isInsideNB (const Point< dim, T > &p) const | 
|   | Check if the point is inside the region excluding the borders.  
  | 
|   | 
| bool  | isInside (const T(&p)[dim]) const | 
|   | Check if the point is inside the region (Border included)  
  | 
|   | 
| template<typename KeyType >  | 
| __device__ __host__ bool  | isInsideKey (const KeyType &k) const | 
|   | Check if the point is inside the region (Border included)  
  | 
|   | 
| bool  | isValid () const | 
|   | Check if the Box is a valid box P2 >= P1.  
  | 
|   | 
| bool  | isValidN () const | 
|   | Check if the Box is a valid box P2 > P1.  
  | 
|   | 
| void  | floorP1 () | 
|   | Apply the ceil operation to the point P1.  
  | 
|   | 
| void  | floorP2 () | 
|   | Apply the ceil operation to the point P2.  
  | 
|   | 
| void  | ceilP1 () | 
|   | Apply the ceil operation to the point P1.  
  | 
|   | 
| void  | ceilP2 () | 
|   | Apply the ceil operation to the point P2.  
  | 
|   | 
| void  | shrinkP2 (const Point< dim, T > &p) | 
|   | Shrink the point P2 by one vector.  
  | 
|   | 
| void  | swap (Box< dim, T > &b) | 
|   | exchange the data of two boxes  
  | 
|   | 
| template<typename Mem >  | 
| bool  | isInside (const encapc< 1, Point< dim, T >, Mem > &p) | 
|   | Check if the point is inside the region.  
  | 
|   | 
| T  | getRcut () const | 
|   | Get the worst extension.  
  | 
|   | 
| T  | getVolume () const | 
|   | Get the volume of the box.  
  | 
|   | 
| T  | getVolumeKey () const | 
|   | Get the volume spanned by the Box P1 and P2 interpreted as grid key.  
  | 
|   | 
| Point< dim, T >  | middle () const | 
|   | Return the middle point of the box.  
  | 
|   | 
| std::string  | toString () const | 
|   | Produce a string from the object.  
  | 
|   | 
| bool  | operator== (const Box< dim, T > &b) const | 
|   | Compare two boxes.  
  | 
|   | 
| bool  | operator!= (const Box< dim, T > &b) const | 
|   | Compare two boxes.  
  | 
|   |