Proto_LevelBoxData.H

#pragma once
#ifndef _PROTO_LEVELBOXDATA_H_
#define _PROTO_LEVELBOXDATA_H_

#include "Proto_MemType.H"
#include "Proto_Point.H"
#include "Proto_Box.H"
#include "Proto_Copier.H"
#include "Proto_DisjointBoxLayout.H"
#include "Proto_LevelIterators.H"
#include "Proto_WriteBoxData.H"
#include "Proto_MayDay.H"
#include "Proto_SPMD.H"
#include <cstdlib> //for size_t
#include <iostream>
#include <cstring> // for Writing data to .vtk files.
#define LBD LevelBoxData<T, C, MEM, CTR>

//using namespace std;
//using std::shared_ptr;

namespace Proto 
{
    // Forward Declarations
    template<typename T, unsigned int C, MemType MEM, unsigned int CTR>
    class LevelBoxData;

// =======================================================================
// LEVEL BOX DATA COPIER OP
    

    template
    <typename T, unsigned int C=1, MemType MEM = MemType::HOST ,unsigned int CTR=0 >
    class LevelCopierOp
    {
        public:
        LevelBoxData<T,C,MEM,CTR>*  m_src;
        LevelBoxData<T,C,MEM,CTR>*  m_dst;

        inline LevelCopierOp(){};
        
        inline LevelCopierOp(LBD& a_src, LBD& a_dst);
        
        inline int linearSize(const Box& a_bx,
                const DataIndex& a_index) const;
        
        inline void linearOut(void* a_buf, 
                const Box& a_bx,
                const DataIndex& a_index) const;
        
        inline void linearIn(void* a_buf, 
                const Box& a_bx,
                const DataIndex& a_index) const;
        
        inline void localCopy(
            const Box& a_domain, const DataIndex& a_domainIndex,
            const Box& a_range,  const DataIndex& a_rangeIndex) const;
    };
// =======================================================================
// LEVEL BOX DATA COPIERS
    

    template<typename T, unsigned int C=1, MemType MEM=MemType::HOST, unsigned int CTR=0>
    class LevelCopier : public Copier<LevelCopierOp<T, C, MEM, CTR>>
    {
        public:
        
        inline LevelCopier(){};
        
        inline void buildMotionPlans(LevelCopierOp<T, C, MEM, CTR>& a_op);
    };
    

    template<typename T, unsigned int C=1, MemType MEM=MemType::HOST, unsigned int CTR=0>
    class LevelExchangeCopier : public Copier<LevelCopierOp<T, C, MEM, CTR>>
    {
        public:

        inline LevelExchangeCopier(){};
        
        inline void buildMotionPlans(LevelCopierOp<T, C, MEM, CTR>& a_op);
    };

// =======================================================================
// LEVEL BOX DATA
    

    template
    <typename T, unsigned int C=1, MemType MEM=MemType::HOST, unsigned int CTR=DIM >
    class LevelBoxData
    {
        public:


        inline LevelBoxData();


        inline LevelBoxData(const DisjointBoxLayout& a_dbl, const Point& a_ghost);


        inline void define(const DisjointBoxLayout& a_dbl, const Point& a_ghost);


        inline unsigned int size() const;


        inline void setToZero();


        template<typename Func, typename... Srcs>
        inline void initialize(Func& a_func, Srcs... a_srcs);


        inline void exchange();


        inline void copyTo(LevelBoxData& a_dest) const;
        

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


        inline unsigned int patchSize() const;


        inline void linearIn(void* a_buffer, 
                const Box& a_box,
                const DataIndex& a_index);


        inline void linearOut(void* a_buffer, 
                const Box& a_box,
                const DataIndex& a_index) const;


        inline size_t linearSize(const Box& a_box,
                const DataIndex& a_index) const;

        inline void linearIn(void* a_buffer, 
                const DataIndex& a_index);

        inline void linearOut(void* a_buffer, 
                const DataIndex& a_index) const;

        inline size_t linearSize( const DataIndex& a_index) const;


        inline void linearIn(void* a_buffer);

        inline void linearOut(void* a_buffer) const;

        inline size_t linearSize() const;

        inline DisjointBoxLayout layout() const { return m_dbl; }
        inline DisjointBoxLayout getDBL() const { return m_dbl; }

        inline Point ghost() const { return m_ghost; }
        inline Point getGhostVector() const {return m_ghost;}
        
        //=======================================
        // DATA ITERATOR INTERFACE

        inline BoxData<T,C,MEM>& operator[](const DataIndex& a_index);
        inline const BoxData<T,C,MEM>& operator[](const DataIndex& a_index) const;
        
        inline DataIterator begin() const;

        int s_verbosity = 0;
        
        private: 

        std::vector<shared_ptr<BoxData<T,C> > > m_data;
        Point                                   m_ghost;
        DisjointBoxLayout                       m_dbl;
        bool                                    m_isDefined;
        LevelExchangeCopier<T, C, MEM, CTR>     m_exchangeCopier;
        
        // disallow copy constructors and assignment operators
        // to avoid very hard-to-find performance problems
        LevelBoxData<T, C, MEM, CTR>& operator= (const LevelBoxData<T, C, MEM, CTR>& a_rhs);
        LevelBoxData<T, C, MEM, CTR>(const LevelBoxData<T, C, MEM, CTR>& a_rhs);
    }; // end class LevelBoxData

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