Proto_DisjointBoxLayout.H

#ifndef _PROTO_DisjointBoxLayout_H_
#define _PROTO_DisjointBoxLayout_H_

#include "Proto_Point.H"
#include "Proto_Box.H"
#include "implem/Proto_Stack.H"
#include "Proto_ProblemDomain.H"
#include "Proto_DBLInternals.H"
#include "Proto_DataIndex.H"
#include "Proto_Morton.H"
#include "Proto_SPMD.H"
#include <cstdlib> //for size_t
#include <iostream>
#include <stack>
#include <memory>
#include <array>
#include <unordered_map>

//using namespace std;
//using std::shared_ptr;
//using std::array;
//using std::vector;
//using std::stack;
//using namespace Proto;

namespace Proto 
{ 
    // Forward Declarations
    class DataIterator; 


    class DisjointBoxLayout
    { 
        friend class DataIndex;
        
        private:
        ProblemDomain             m_problemDomain;
        Point                     m_boxSize;  
        DataIndex                 m_end;     
        shared_ptr<DBLInternals>  m_internals;
        /* 
           The use of  shared_ptr<DBLInternals> makes the proliferation of copies not be a 
           performance barrier, as well as making the data pointed at by m_internals reusable 
           under coarsening or refinement.If making m_problemDomain and m_boxSize objects 
           becomes a performance issue, can wrap them in a shared pointer as well.
         */
        
        public:
        
        inline DisjointBoxLayout();


        inline DisjointBoxLayout(const ProblemDomain   & a_problemDomain, 
                const Point           & a_boxSize);


        inline DisjointBoxLayout(const ProblemDomain   & a_problemDomain,
                const vector<Point>   & a_coarsenedPatches,
                const Point           & a_boxSize);


        inline DisjointBoxLayout(const DisjointBoxLayout& a_input)
        {
            m_internals = a_input.m_internals;
            m_problemDomain = a_input.m_problemDomain;
            m_boxSize = a_input.m_boxSize;
        };
        

        inline void define(const ProblemDomain   & a_problemDomain, 
                           const Point           & a_boxSize);
        

        inline void
            define(const ProblemDomain   & a_problemDomain,
                    const vector<Point>   & a_coarsenedPatches,
                    const Point           & a_boxSize);


        inline DisjointBoxLayout& operator=(const DisjointBoxLayout& a_input)
        {
            m_internals = a_input.m_internals;
            m_problemDomain = a_input.m_problemDomain;
            m_boxSize = a_input.m_boxSize;
            return *this;
        };
        
        inline bool operator==(const DisjointBoxLayout& a_input) const
        {
            return ((a_input.m_internals == m_internals)&&
                    (a_input.m_problemDomain == m_problemDomain)&&
                    (a_input.m_boxSize == m_boxSize));
        };


        inline const shared_ptr<DBLInternals> dblInternals() const{return m_internals;};


        inline Box operator[](const DataIndex& a_index) const;
        //inline Point operator[](const DataIndex& a_index) const;


        inline Box box(const DataIndex& a_index) const;
        

        inline Point point(const DataIndex& a_index) const;

        inline int procID(const DataIndex& a_index) const; //consistent syntax
        inline int procid(const DataIndex& a_index) const;


        inline unsigned int offset(int a_proc) const;
        inline unsigned int offset() const { return offset(Proto::procID()); }


        inline DataIndex index(Point& a_coarsenedPt) const;


        inline unsigned int size() const;


        inline unsigned int localSize() const;
        inline unsigned int mySize() const;


        inline DataIndex index(unsigned int a_indexInt) const;


        inline DataIndex localIndex(unsigned int a_myIndexInt) const;
        inline DataIndex myIndex(unsigned int a_myIndexInt) const;


        inline int localIntIndex(const DataIndex& a_di) const;
        inline int myIntIndex(const DataIndex& a_di) const;


        inline Point boxSize() const{return m_boxSize;};

        inline ProblemDomain domain() const {return m_problemDomain;};
        inline ProblemDomain problemDomain() const{return m_problemDomain;};


        inline DataIndex find(const Point& a_pt) const;
        inline const DataIndex& end() const
        {
            return m_end;
        };
        
        inline DataIterator begin() const;
        

        inline bool coarsenable(const Point& a_refrat) const;
        

        inline DisjointBoxLayout coarsen(const Point& a_refrat) const;


        inline DisjointBoxLayout refine(const Point& a_refrat) const;

        template <MemType MEMTYPE>
        static StackAlloc<MEMTYPE>& getStackAllocator()
        {
            static StackAlloc<MEMTYPE> s_allocator;
            return s_allocator;
        }

#ifdef PROTO_CUDA
        //Returns the single stream
        static protoStream_t getCurrentStream()
        {
            static protoStream_t currStream;
            static bool init=false;
            if(!init)
            {
                protoStreamCreate(&currStream);
                init=true;
            }
            return currStream;
        }
#endif
};
inline std::ostream& operator<< (std::ostream& os, const DisjointBoxLayout& a_dbl)
{
    os << "DisjointBoxLayout: \n" ;
    os << a_dbl.problemDomain() << "\n";
    auto internals = a_dbl.dblInternals();
    os << "coarsened Domain = " << internals->coarsenedDomain << "\n" ;
    os << "Points and ranks: \n";
    for (int k = 0; k < internals->allBoxes.size();k++)
    {
        os << internals->allBoxes[k].first 
            << " , " << internals->allBoxes[k].second << "\n";
    }
    os << "StartProc vector: \n";
    for (int k = 0; k < internals->startProc.size() ; k++)
    {
        os << "Starting patch number for processor " << k 
            << " = " << internals->startProc[k] << "\n";
    }
    return os;
}
#include "implem/Proto_DisjointBoxLayoutImplem.H"
} //end namespace Proto

#endif