BoxLayoutData.H

Go to the documentation of this file.

/*   _______              __
    / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  V \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/
*/
// CHOMBO Copyright (c) 2000-2004, The Regents of the University of
// California, through Lawrence Berkeley National Laboratory (subject to
// receipt of any required approvals from U.S. Dept. of Energy).  All
// rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// (2) Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// (3) Neither the name of Lawrence Berkeley National Laboratory, U.S.
// Dept. of Energy nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// You are under no obligation whatsoever to provide any bug fixes,
// patches, or upgrades to the features, functionality or performance of
// the source code ("Enhancements") to anyone; however, if you choose to
// make your Enhancements available either publicly, or directly to
// Lawrence Berkeley National Laboratory, without imposing a separate
// written license agreement for such Enhancements, then you hereby grant
// the following license: a non-exclusive, royalty-free perpetual license
// to install, use, modify, prepare derivative works, incorporate into
// other computer software, distribute, and sublicense such Enhancements or
// derivative works thereof, in binary and source code form.
//
// TRADEMARKS. Product and company names mentioned herein may be the
// trademarks of their respective owners.  Any rights not expressly granted
// herein are reserved.
//

#ifndef _BOXLAYOUTDATA_H_
#define _BOXLAYOUTDATA_H_

#include "LayoutData.H"
#include "Interval.H"
#include "FArrayBox.H"

class MotionItem;

#include "DisjointBoxLayout.H"
#include "Copier.H"
#include "SPMD.H"
#include "memtrack.H"

template <class T> class DataFactory
{
public:

  virtual ~DataFactory(){;}

  virtual T* create(const Box& box, int ncomps, const DataIndex& a_datInd) const=0;

  virtual bool callDelete() const {return true;}
};


template <class T> class DefaultDataFactory : public DataFactory<T>
{
public:

  virtual T* create(const Box& box, int ncomps, const DataIndex& a_datInd) const;

};

class FABAliasDataFactory : public DataFactory<FArrayBox>
{
public:
  virtual ~FABAliasDataFactory()
  {}

  FABAliasDataFactory(const LayoutData<Real*>& aliases);
  void define(const LayoutData<Real*>& aliases);

  virtual FArrayBox* create(const Box& box, int ncomps, const DataIndex& a_datInd) const;

protected:
  LayoutData<Real*> aliasPtrs;
};

template<class T> class BoxLayoutData;

template <class T>
class AliasDataFactory : public DataFactory<T>
{
public:
  virtual ~AliasDataFactory()
  {}

  AliasDataFactory(BoxLayoutData<T>* a_original, const Interval& interval);
  void define(BoxLayoutData<T>* a_original, const Interval& interval);
  virtual T* create(const Box& box, int ncomps, const DataIndex& a_datInd) const;

protected:
  BoxLayoutData<T>* m_origPointer;
  Interval          m_interval;
};

template<class T> class LevelData;

template <class T>
class LDOperator
{
public:
  virtual ~LDOperator(){}    //to keep the compiler happy

  virtual int size(const T& arg, const Box& b, const Interval& comps) const
  {
    return arg.size(b, comps);
  }
  virtual void linearOut(const T& arg, void* buf, const Box& R,
                         const Interval& comps) const
  {
    arg.linearOut(buf, R, comps);
  }
  virtual void linearIn(T& arg,  void* buf, const Box& R,
                        const Interval& comps)const
  {
    arg.linearIn(buf, R, comps);
  }
  virtual void op(T& dest,
          const Box& RegionFrom,
          const Interval& Cdest,
          const Box& RegionTo,
          const T& src,
          const Interval& Csrc) const
  {
    dest.copy(RegionFrom, Cdest,RegionTo, src, Csrc);
  }
};


template<class T>
class BoxLayoutData : public LayoutData<T>
{
public:
  BoxLayoutData();

  virtual ~BoxLayoutData();
  BoxLayoutData(const BoxLayout& boxes, int comps,
                const DataFactory<T>& factory = DefaultDataFactory<T>());

  virtual void define(const BoxLayout& boxes, int comps,
                      const DataFactory<T>& factory = DefaultDataFactory<T>());

  virtual void define(const BoxLayoutData<T>& da,
                      const DataFactory<T>& factory = DefaultDataFactory<T>());


  virtual void define(const BoxLayoutData<T>& da, const Interval& comps,
                      const DataFactory<T>& factory = DefaultDataFactory<T>());

  virtual void define(const BoxLayout& boxes);

  int nComp() const { return m_comps;}

  Interval interval() const
  {
    Interval outint(0, m_comps-1);
    return(outint);
  }


  void generalCopyTo(const BoxLayout& a_destGrids,
                     LayoutData<Vector<RefCountedPtr<T> > >& a_dest,
                     const Interval& a_interval,
                     const ProblemDomain& a_domain,
                     const DataFactory<T>& factory = DefaultDataFactory<T>()) const ;

  /* User writes a function with the signature:

     <PRE>
     void myfunction(const Box& box, int comps, T& t){ your code here;}
     </PRE>

     They can then hand this off to LayoutData::apply.  This class
     then cycles through all the T objects and invokes this function.  Function
     must not be inline. (I'm still trying to figure out a nice way to send
     in non-static member functions).
     */
  virtual void apply(void (*a_Function)(const Box& box, int comps, T& t));

  virtual bool isDefined() const;


protected:
  int             m_comps;
  bool            m_isdefined;

  friend class LevelData<T>;

  void setVector(const BoxLayoutData<T>& da,
                 const Interval& srcComps,
                 const Interval& destComps);

  void allocateGhostVector(const DataFactory<T>& factory,
                           const IntVect& ghost = IntVect::Zero);

  void makeItSo(const Interval&     a_srcComps,
                const BoxLayoutData<T>& a_src,
                BoxLayoutData<T>&   a_dest,
                const Interval&     a_destComps,
                const Copier&       a_copier,
                const LDOperator<T>& a_op = LDOperator<T>()) const;

  //========================================================================
  //
  // data structures used by makeItSo when we have some
  // data that needs to be moved (ie. there are entries
  // in the 'FROM' or 'TO' CopyIterators)
  //
  void completePendingSends() const;

  void allocateBuffers(const BoxLayoutData<T>& a_src,
                       const Interval& a_srcComps,
                       const BoxLayoutData<T>& a_dest,
                       const Interval& a_destComps,
                       const Copier&   a_copier,
                       const LDOperator<T>& a_op) const;

  void writeSendDataFromMeIntoBuffers(const BoxLayoutData<T>& a_src,
                                      const Interval& a_srcComps,
                                      const LDOperator<T>& a_op) const;

  void postSendsFromMe() const ;

  void postReceivesToMe() const ;

  void unpackReceivesToMe(BoxLayoutData<T>& a_dest,
                          const Interval&   a_destComps,
                          const LDOperator<T>& a_op) const ;

  void unpackReceivesToMe_append(LayoutData<Vector<RefCountedPtr<T> > >& a_dest,
                                 const Interval&   a_destComps,
                                 int ncomp,
                                 const DataFactory<T>& factory,
                                 const LDOperator<T>& a_op) const;

  mutable void*  m_sendbuffer; // pointer member OK here,
                               // since LevelData<T> has no copy
  mutable size_t m_sendcapacity;
  mutable void*  m_recbuffer;  // pointer member OK here,
                               // since LevelData<T> has no copy
  mutable size_t m_reccapacity;

#ifdef CH_MPI

#ifndef DOXYGEN

  struct bufEntry
  {
    void* bufPtr; // pointer into contiguous m_buffer
    size_t size;
    const MotionItem* item;
    unsigned int procID;
    bool operator < (const bufEntry& rhs) const
      {
        if(procID == rhs.procID)
          {
            const Box& left = item->toRegion;
            const Box& right= rhs.item->toRegion;
            if(left.smallEnd() == right.smallEnd())
              {
                return left.bigEnd().lexLT(right.bigEnd());
              }
            else
              {
                return item->toRegion < rhs.item->toRegion;
              }
          }
        //else
        return procID < rhs.procID;
      }
  };

#endif
  mutable std::vector<bufEntry> m_fromMe;
  mutable std::vector<bufEntry> m_toMe;

  mutable MPI_Request  *m_sendRequests, *m_receiveRequests;
  mutable MPI_Status   *m_sendStatus,   *m_receiveStatus;
  mutable int numSends, numReceives;
#endif

};


Real norm(const BoxLayoutData<FArrayBox>& A,
          const Interval& interval,
          const int& p = 2);

//======================================================================
template < >
BaseFab<int>* DefaultDataFactory<BaseFab<int> >::create(const Box& box,
                                                        int ncomps,
                                                        const DataIndex& a_datInd) const;

template < >
FArrayBox* DefaultDataFactory<FArrayBox>::create(const Box& box,
                                                 int ncomps,
                                                 const DataIndex& a_datInd) const;

template <class T>
T* DefaultDataFactory<T>::create(const Box& box,
                                 int ncomps,
                                 const DataIndex& a_datInd) const
{
  return new T(box, ncomps);
}

template<class T>
inline bool BoxLayoutData<T>::isDefined() const
{
  return m_isdefined;
}

template <class T>
inline void BoxLayoutData<T>::setVector(const BoxLayoutData<T>& da,
                                        const Interval& srcComps,
                                        const Interval& destComps)
{
  if(&da != this)
    {
      for(DataIterator it(this->dataIterator()); it.ok(); ++it)
        {
          this->m_vector[this->m_boxLayout.index(it())]->copy( this->box(it()), destComps,
                                                   this->box(it()), da[it()], srcComps);
        }
    }
}

template<class T>
inline void BoxLayoutData<T>::define(const BoxLayoutData<T>& da, const Interval& comps,
                                     const DataFactory<T>& factory)
{
  if(this == &da){
    MayDay::Error("BoxLayoutData<T>::define(const LayoutData<T>& da,.....) called with 'this'");
  }
 CH_assert(comps.size()>0);
 CH_assert(comps.end()<=m_comps);
 CH_assert(comps.begin()>=0);
  this->m_boxLayout = da.boxLayout();

  this->m_comps = comps.size();

  Interval dest(0, m_comps-1);
  allocateGhostVector(factory);
  setVector(da, comps, dest);
#ifdef CH_MPI
  this->m_fromMe.resize(0);
  this->m_toMe.resize(0);
#endif

}

template<class T>
inline void BoxLayoutData<T>::define(const BoxLayout& boxes, int comps,
                                     const DataFactory<T>& factory)
{
 CH_assert(boxes.isClosed());
  this->m_boxLayout = boxes;
  m_comps = comps;
  m_isdefined = true;
  allocateGhostVector(factory);
#ifdef CH_MPI
  m_fromMe.resize(0);
  m_toMe.resize(0);
#endif
}

template<class T>
inline void BoxLayoutData<T>::define(const BoxLayout& boxes)
{
  MayDay::Error("BoxLayoutData<T>::define(const BoxLayout& boxes)...needs comps");
}

template <class T>
inline   BoxLayoutData<T>::BoxLayoutData():m_comps(0) , m_sendbuffer(NULL),
    m_sendcapacity(0),  m_recbuffer(NULL),m_reccapacity(0)
{
  m_isdefined = false;
#ifdef CH_MPI
  this->numSends = 0;
  this->numReceives = 0;
#endif
}
template<class T>
inline BoxLayoutData<T>::BoxLayoutData(const BoxLayout& boxes, int comps,
                                       const DataFactory<T>& factory)
  :m_comps(comps), m_sendbuffer(NULL),
    m_sendcapacity(0),  m_recbuffer(NULL),m_reccapacity(0)
{
 CH_assert(boxes.isClosed());
  this->m_boxLayout = boxes;
  m_isdefined = true;
  allocateGhostVector(factory);
#ifdef CH_MPI
  m_fromMe.resize(0);
  m_toMe.resize(0);
  this->numSends = 0;
  this->numReceives = 0;
#endif
}

template<class T>
BoxLayoutData<T>::~BoxLayoutData()
{
  completePendingSends();
  free(m_sendbuffer);
  free(m_recbuffer);
}

template<class T>
inline void BoxLayoutData<T>::define(const BoxLayoutData<T>& da,
                                     const DataFactory<T>& factory)
{
  if(this != &da){
    m_isdefined = da.m_isdefined;
    this->m_boxLayout = da.boxLayout();
    m_comps    = da.nComp();
    Interval srcAnddest(0, m_comps-1);
    allocateGhostVector(factory);
    setVector(da, srcAnddest, srcAnddest);
  }
#ifdef CH_MPI
  m_fromMe.resize(0);
  m_toMe.resize(0);
#endif
}

template<class T>
inline void BoxLayoutData<T>::allocateGhostVector(const DataFactory<T>& factory, const IntVect& ghost)
{
  if(this->m_callDelete == true){
  for(unsigned int i=0; i<this->m_vector.size(); ++i)
    {
      delete this->m_vector[i];
      this->m_vector[i] = NULL;
    }
  }

  this->m_callDelete = factory.callDelete();

  this->m_vector.resize(this->m_boxLayout.size(), NULL);

  for(DataIterator it(this->dataIterator()); it.ok(); ++it)
    {
      unsigned int index = this->m_boxLayout.index(it());
      Box abox = this->box(it());
      abox.grow(ghost);
      this->m_vector[index] = factory.create(abox, m_comps, it());
      if(this->m_vector[index] == NULL)
        {
          MayDay::Error("OutOfMemory in boxlayoutdata::allocate");
        }
    }
}

template<class T>
inline void BoxLayoutData<T>::apply(void (*a_func)(const Box& box, int comps, T& t))
{
  for(DataIterator it(this->dataIterator()); it.ok(); ++it)
    {
      unsigned int index = this->m_boxLayout.index(it());
      a_func(this->box(it()), m_comps, *(this->m_vector[index]));
    }
}

//======================================================================
template <class T>
AliasDataFactory<T>::AliasDataFactory(BoxLayoutData<T>* a_original, const Interval& interval)
{
  define(a_original, interval);
}

template <class T>
void AliasDataFactory<T>::define(BoxLayoutData<T>* a_original, const Interval& interval)
{
  m_origPointer = a_original;
  m_interval    = interval;
}

template <class T>
T* AliasDataFactory<T>::create(const Box& a_box, int ncomps, const DataIndex& a_dataInd) const
{
  //CH_assert(this->box(a_dataInd) == a_box);
 CH_assert(ncomps = m_interval.size());
  T* rtn = new T(m_interval, m_origPointer->operator[](a_dataInd));
  return rtn;
}

#include "BoxLayoutDataI.H"

#endif //BOXLAYOUTDATA

---