SpaceBox.hpp

#ifndef SPACEBOX_HPP_
#define SPACEBOX_HPP_

#include "Shape/Point.hpp"
#include "Shape/Box.hpp"
#include <boost/fusion/include/vector.hpp>
#include "Grid/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)
    {
    }

    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())/RAND_MAX * (this->getHigh(i) - this->getLow(i)) + this->getLow(i);

        return p;
    }

    SpaceBox<dim,T>()   {}
};

#include "Grid/Encap.hpp"


#endif