SpaceBox.hpp

 
#ifndef SPACEBOX_HPP_
#define SPACEBOX_HPP_
 
#include "Shape/Point.hpp"
#include "Shape/Box.hpp"
#include <boost/fusion/include/vector.hpp>
#include "memory_ly/Encap.hpp"
#include "Ghost.hpp"
#include <stdlib.h>     /* srand, rand */
 
template<unsigned int dim, typename T>
class SpaceBox : public Box<dim,T>
{
    public:
 
    inline SpaceBox<dim,T> & operator=(const Box<dim,T> & b)
    {
        // for each dimension set high and low
 
        for (size_t d = 0 ; d < dim ; d++)
        {this->setLow(d,b.getLow(d));}
 
        for (size_t d = 0 ; d < dim ; d++)
        {this->setHigh(d,b.getHigh(d));}
 
        return *this;
    }
 
    template <typename S>inline SpaceBox(const Box<dim,S> & b)
    {
        for (size_t d = 0 ; d < dim ; d++)
        {this->setLow(d,b.getLow(d));}
 
        for (size_t d = 0 ; d < dim ; d++)
        {this->setHigh(d,b.getHigh(d));}
    }
 
    SpaceBox(const SpaceBox<dim,T> & b)
    :Box<dim,T>(b)
    {
    }
 
    explicit SpaceBox(const Box<dim,T> & b)
    :Box<dim,T>(b)
    {
    }
 
    template<unsigned int dim_s,typename Mem> SpaceBox(const encapc<dim_s,Box<dim,T>,Mem> & box)
    {
        // for each dimension set high and low
 
        for (size_t d = 0 ; d < dim ; d++)
        {this->setLow(d,box.template get<Box<dim,T>::p1>()[d]);}
 
        for (size_t d = 0 ; d < dim ; d++)
        {this->setHigh(d,box.template get<Box<dim,T>::p2>()[d]);}
    }
 
    template<unsigned int dim_s,typename Mem> SpaceBox(const encapc<dim_s,SpaceBox<dim,T>,Mem> & box)
    {
        // for each dimension set high and low
 
        for (size_t d = 0 ; d < dim ; d++)
        {this->setLow(d,box.template get<Box<dim,T>::p1>()[d]);}
 
        for (size_t d = 0 ; d < dim ; d++)
        {this->setHigh(d,box.template get<Box<dim,T>::p2>()[d]);}
    }
 
    SpaceBox(std::initializer_list<T> p1, std::initializer_list<T> p2)
    {
        // for each dimension set high and low
 
        size_t i = 0;
        for(T x : p1)
        {this->setLow(i,x);i++;}
 
        i = 0;
        for(T x : p2)
        {this->setHigh(i,x);i++;}
    }
 
    void rescale(T (& sp)[dim])
    {
        for (size_t d = 0 ; d < dim ; d++)
        {this->setHigh(d,this->getLow(d) + (this->getHigh(d) -this->getLow(d)) * sp[d]);}
    }
 
    template<typename S> void rescale(S (& sp)[dim])
    {
        for (size_t d = 0 ; d < dim ; d++)
        {this->setHigh(d,this->getLow(d) + (this->getHigh(d) -this->getLow(d)) * sp[d]);}
    }
 
    void mul(T (& sp)[dim])
    {
        for (size_t d = 0 ; d < dim ; d++)
        {this->setLow(d,this->getLow(d) * sp[d]);}
 
        for (size_t d = 0 ; d < dim ; d++)
        {this->setHigh(d,this->getHigh(d) * sp[d]);}
    }
 
    template<typename S> void mul(S (& sp)[dim])
    {
        for (size_t d = 0 ; d < dim ; d++)
        {this->setLow(d,this->getLow(d) * sp[d]);}
 
        for (size_t d = 0 ; d < dim ; d++)
        {this->setHigh(d,this->getHigh(d) * sp[d]);}
    }
 
    Point<dim,T> rnd()
    {
        Point<dim,T> p;
 
        for (size_t i = 0 ; i < dim ; i++)
            p.get(i) = ((T)rand())/(T)RAND_MAX * (this->getHigh(i) - this->getLow(i)) + this->getLow(i);
 
        return p;
    }
 
    SpaceBox<dim,T>()   {}
};
 
 
 
template<unsigned int dim, typename St>
struct is_typedef_and_data_same<true,SpaceBox<dim,St>>
{
    enum
    {
        value = 1
    };
};
 
 
#endif