Proto_Box.H

#pragma once
#ifndef _PROTO_BOX_H___
#define _PROTO_BOX_H___

#include "Proto_Point.H"
#include "Proto_LoHiSide.H"
#include <cstdlib> //for size_t
#include <iostream>
#include <cmath>
using Proto::Point;
namespace Proto 
{

// forward declarations
  class BoxIterator;
  #ifdef PR_HDF5
  class HDF5Handler;
  #endif

  class Box
  {
    #ifdef PR_HDF5
    friend class Proto::HDF5Handler;
    #endif
  public:
    typedef BoxIterator iterator; //Box::iterator aliases to BoxIterator




    inline Box();

    //useful for bc evaluation
    Point boundary(const Side::LoHiSide a_side) const
    {
      Point retval = low();
      if(a_side == Side::Hi)
      {
        retval =  high();
      }
      return retval;
    }

    //useful for bc evaluation
    Box faceBox(int a_idir, const Side::LoHiSide a_side) const
    {
      Box retval = adjCellSide(a_idir, 1, a_side);
      if(a_side == Side::Lo)
      {
        retval =  retval.shift(Point::Basis(a_idir, 1));
      }
      return retval;
    }
    

    inline Box(const Point& a_low, const Point& a_high);


    inline Box (const int* a_lo, const int* a_hi) { define(a_lo, a_hi); }


    inline void define(const int* a_lo, const int* a_hi);
    

    inline Box(const Point& a_pt);

    inline Box(const Box& a_box); 



    inline static Box Cube(int a_size);
    

    inline static Box Kernel(int a_radius);
   

    CUDA_DECORATION
    inline static unsigned int sindex(Point a_pt, Point a_low, Point a_high); 
   

    CUDA_DECORATION
    inline static unsigned int soffset(const Point& a_pt, const Point& a_low, const Point& a_high);
    



    inline Point low() const {return m_low;};


    inline Point high() const {return m_high;}; 


    CUDA_DECORATION
    inline std::size_t size(unsigned char a_dim) const;
    

    CUDA_DECORATION
    inline std::size_t size() const; 


    CUDA_DECORATION
    inline bool contains(const Point& a_pt) const;


    CUDA_DECORATION
    inline bool contains(const Box& a_rhs) const;
    

    inline bool onBoundary(const Point& a_p) const;
    

    CUDA_DECORATION
    inline bool empty() const {return (m_size < 1);}


    CUDA_DECORATION
    inline unsigned int index(const Point& a_pt) const;
    
    

    CUDA_DECORATION
    inline Point operator[](unsigned int a_index) const;


    CUDA_DECORATION
    inline Point operator()(unsigned int a_idx, unsigned int a_idy, unsigned a_idz) const;






    inline Box operator&(const Box& a_rightBox) const;

    

    inline void operator&=(const Box& a_rhs); 


    inline Box operator&(const Point& a_pt) const;
  

    inline void operator&=(const Point& a_pt);
    
    //inline void operator&=(const Box& a_rightBox);
  

    inline bool operator==(const Box& a_rhsBox) const;

    inline bool operator!=(const Box& a_rhsBox) const
    {
      bool equals = (*this==a_rhsBox);
      return !equals;
    }
    inline bool operator< (const Box& a_rhsBox) const
    {
      bool lt = this->low() < a_rhsBox.low();
      return lt;
    };

    inline Point operator%(const Point& a_pt) const;
    

    inline Point mod(const Point& a_pt) const;
    




    inline Box shift(int a_direction, int a_offset) const;


    inline Box shift(const Point& a_pt) const;


    inline Box grow(int a_numpoints) const;
    

    inline Box grow(const Point& a_pt) const;


    inline Box grow(int a_dir, int a_offset) const;
    

    inline Box extrude(const Point& a_dir, int a_dist = 1) const;
    

    inline Box extrude(int a_dir, int a_dist = 1, bool a_upper = true) const;


    inline Box growHi(int idir, int igrow) const;
  

    inline Box growLo(int idir, int igrow) const;


    inline Box coarsen(unsigned int a_ratio) const;
    

    inline Box coarsen(const Point& a_pt) const;



    inline bool coarsenable(const int& a_ratio) const;


    inline bool coarsenable(const Point& a_ratio) const;


    inline Box taperCoarsen(const Point& a_ref) const;


    inline Box refine(const Point& a_pt) const;
    

    inline Box refine(unsigned int a_ratio) const;


    inline Box edge(const Point& a_dir, int a_dist = 1) const;
    

    inline Box flatten(const int a_dir, bool a_upper = false) const;
    

    inline Box adjacent(const Point& a_dir, int a_dist = -1) const;



    inline Box adjCellLo(int a_idir, int a_length) const;


    inline Box adjCellHi(int a_idir, int a_length) const;

    inline Box adjCellSide(int a_idir, int a_length, Side::LoHiSide a_sd) const
    {
      Box retval = adjCellHi(a_idir, a_length);
      if(a_sd == Side::Lo)
      {
        retval = adjCellLo(a_idir, a_length);
      }
      return retval;
    }
      
  

    

    inline BoxIterator begin() const; 
    

    inline BoxIterator end() const; 
    

    inline BoxIterator rbegin() const; 
    

    inline BoxIterator rend() const; 
    

    inline void print() const; 

    inline size_t linearSize() const
    {
      size_t retval = 0;
      retval += m_low.linearSize();
      retval += m_high.linearSize();
      retval += sizeof(int);
      return retval;
    }

    inline void linearOut(char* a_buf) const
    {
      size_t charsiz = 0;
      char* charbuf = a_buf;

      m_low.linearOut(charbuf);
      charbuf += m_low.linearSize();
      charsiz += m_low.linearSize();

      m_high.linearOut(charbuf);
      charbuf += m_high.linearSize();
      charsiz += m_high.linearSize();

      int* intbuf = (int* ) charbuf;
      *intbuf = m_size;
      charsiz += sizeof(int);
      charbuf += sizeof(int);
    }

    inline void linearIn(const char* a_buf) 
    {
      size_t charsiz = 0;
      const char* charbuf = a_buf;

      m_low.linearIn(charbuf);
      charbuf += m_low.linearSize();
      charsiz += m_low.linearSize();

      m_high.linearIn(charbuf);
      charbuf += m_high.linearSize();
      charsiz += m_high.linearSize();

      int* intbuf = (int* ) charbuf;
      m_size = *intbuf;
      charsiz += sizeof(int);
      charbuf += sizeof(int);
    }
  private:  
    inline void recomputeSize(); 
    Point m_low; 
    Point m_high;  
    int m_size; 
  }; //end class Box

  inline std::ostream& operator<<(std::ostream& a_os, const Box& a_box)
  {
    a_os << "[" << a_box.low() << ", " << a_box.high() << "]";
    return a_os;
  }


  class BoxIterator
  {
  public:
    BoxIterator(){};
    
    BoxIterator(const Box& a_box, int a_pos = 0)
      : m_box(a_box), m_pos(a_pos) {}
    
    BoxIterator(const Box& a_box, const Point& a_pos)
      : m_box(a_box)
    {
      m_pos = m_box.index(a_pos);
    }
    inline void begin(){m_pos = 0;};

    inline bool end()
    {return ((m_pos < 0) || (m_pos >= m_box.size()));};
   
    inline bool ok() { return !end(); }
    

    inline bool operator==(const BoxIterator& a_iter) const
    {
      return ((m_pos == a_iter.m_pos) && (m_box == a_iter.m_box));
    };

    inline bool operator!=(const BoxIterator& a_iter) const
    {
      return !((*this) == a_iter);
    };
    

    inline Point operator*() const
    {
      return m_box[m_pos];
    };


    inline int operator()() const
    {
      return m_pos;
    };

    inline BoxIterator& operator++()
    {
      m_pos++;
      return *this;
    };
    
    inline BoxIterator& operator--()
    {
      m_pos--;
      return *this;
    };

    inline bool done()
    {
      return ((m_pos < 0) || (m_pos >= m_box.size()));
    }


  private:
    Box m_box;
    int m_pos;
  }; //end class BoxIterator

#include "implem/Proto_BoxImplem.H"
} //end namespace Proto
#endif