AMReX_BoxList.H

Go to the documentation of this file.

 
#ifndef BL_BOXLIST_H
#define BL_BOXLIST_H
#include <AMReX_Config.H>
 
#include <AMReX_IntVect.H>
#include <AMReX_IndexType.H>
#include <AMReX_Box.H>
#include <AMReX_Array.H>
#include <AMReX_Vector.H>
 
#include <iosfwd>
 
namespace amrex
{
    class BoxArray;
    class BoxList;
 
    BoxList complementIn (const Box& b, const BoxList& bl);
 
    BoxList boxDiff (const Box& b1in, const Box& b2);
 
    void boxDiff (BoxList& bl_diff, const Box& b1in, const Box& b2);
 
    BoxList refine (const BoxList&  bl, int ratio);
 
    BoxList coarsen (const BoxList& bl, int ratio);
 
    BoxList intersect (const BoxList& bl, const Box& b);
 
    BoxList accrete (const BoxList& bl, int sz);
 
    BoxList removeOverlap (const BoxList& bl);
 
 
    std::ostream& operator<< (std::ostream&  os, const BoxList& blist);
 
 
class BoxList
{
public:
 
    friend class BoxDomain;
 
    using       iterator = Vector<Box>::iterator;
    using const_iterator = Vector<Box>::const_iterator;
 
    BoxList ();
 
    explicit BoxList (const Box& bx);
 
    explicit BoxList (IndexType _btype);
 
    explicit BoxList (const BoxArray& ba);
 
    explicit BoxList (Vector<Box>&& bxs);
 
    BoxList (const Box& bx, const IntVect& tilesize);
 
    BoxList (const Box& bx, int nboxes);
 
    BoxList (const Box& bx, int nboxes, Direction dir);
 
    ~BoxList () = default;
    BoxList (const BoxList& rhs) = default;
    BoxList (BoxList&& rhs) = default;
    BoxList& operator= (const BoxList& rhs) = default;
    BoxList& operator= (BoxList&& rhs) = default;
 
    void reserve (std::size_t n) { m_lbox.reserve(n); }
 
    void push_back (const Box& bn) {
        if (m_lbox.empty()) { btype = bn.ixType(); }
        BL_ASSERT(ixType() == bn.ixType());
        m_lbox.push_back(bn);
    }
 
    [[nodiscard]] Box& front () noexcept { BL_ASSERT(!m_lbox.empty()); return m_lbox.front(); }
 
    [[nodiscard]] const Box& front () const noexcept { BL_ASSERT(!m_lbox.empty()); return m_lbox.front(); }
 
    void join (const BoxList& blist);
    void join (const Vector<Box>& barr);
    void catenate (BoxList& blist);
 
    void clear ();
    [[nodiscard]] Long size () const noexcept { return m_lbox.size(); }
 
    [[nodiscard]] std::size_t capacity () const noexcept { return m_lbox.capacity(); }
 
    [[nodiscard]] iterator begin () noexcept { return m_lbox.begin(); }
    [[nodiscard]] const_iterator begin () const noexcept { return m_lbox.cbegin(); }
    [[nodiscard]] const_iterator cbegin () const noexcept { return m_lbox.cbegin(); }
 
    [[nodiscard]] iterator end () noexcept { return m_lbox.end(); }
    [[nodiscard]] const_iterator end () const noexcept { return m_lbox.cend(); }
    [[nodiscard]] const_iterator cend () const noexcept { return m_lbox.cend(); }
    [[nodiscard]] bool ok () const noexcept;
    bool operator== (const BoxList& rhs) const;
    bool operator!= (const BoxList& rhs) const;
    [[nodiscard]] bool isEmpty () const noexcept { return m_lbox.empty(); }
    [[nodiscard]] bool isNotEmpty () const noexcept { return !m_lbox.empty(); }
    [[nodiscard]] bool isDisjoint () const;
    [[nodiscard]] bool contains (const BoxList& bl) const;
    BoxList& intersect (const Box& b);
    BoxList& intersect (const BoxList& bl);
    BoxList& removeEmpty();
 
    BoxList& complementIn (const Box& b, const BoxList& bl);
    BoxList& complementIn (const Box& b, BoxList&& bl);
    BoxList& complementIn (const Box& b, const BoxArray& ba);
    BoxList& parallelComplementIn (const Box& b, const BoxList& bl);
    BoxList& parallelComplementIn (const Box& b, BoxList&& bl);
    BoxList& parallelComplementIn (const Box& b, const BoxArray& ba);
 
    BoxList& refine (int ratio);
    BoxList& refine (const IntVect& ratio);
    BoxList& coarsen (int ratio);
    BoxList& coarsen (const IntVect& ratio);
    BoxList& accrete  (int sz);
    BoxList& accrete  (const IntVect& sz);
    BoxList& shift (int dir,
                    int nzones);
    BoxList& shiftHalf (int dir,
                        int num_halfs);
    BoxList& shiftHalf (const IntVect& iv);
    int simplify (bool best = false);
    int ordered_simplify ();
    BoxList& maxSize (int chunk);
    BoxList& maxSize (const IntVect& chunk);
    [[nodiscard]] Box minimalBox () const;
    [[nodiscard]] IndexType ixType () const noexcept { return btype; }
    void set (IndexType ixtyp) noexcept { BL_ASSERT(m_lbox.empty()); btype = ixtyp; }
    BoxList& surroundingNodes () noexcept;
    BoxList& surroundingNodes (int dir) noexcept;
    BoxList& enclosedCells () noexcept;
    BoxList& enclosedCells  (int dir) noexcept;
    BoxList& convert (IndexType typ) noexcept;
 
    [[nodiscard]] Vector<Box>& data () noexcept { return m_lbox; }
    [[nodiscard]] const Vector<Box>& data () const noexcept { return m_lbox; }
 
    void swap (BoxList& rhs) noexcept {
        std::swap(m_lbox, rhs.m_lbox);
        std::swap(btype, rhs.btype);
    }
 
    void Bcast ();
 
private:
    int simplify_doit (int depth);
 
    Vector<Box> m_lbox;
    IndexType btype;
 
};
 
}
 
#endif /*BL_BOXLIST_H*/