gsHBoxContainer.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsHSplines/gsHBox.h>
#include <gsIO/gsXml.h>
 
namespace gismo
{
 
template<short_t d, class T>
class gsHBoxContainer
{
public:
    // std::list does not provide .at(k) but it provides iterators
    typedef typename gsHBox<d,T>::RefBox            RefBox;
    typedef typename gsHBox<d,T>::Container         Container;
    typedef typename gsHBox<d,T>::SortedContainer   SortedContainer;
    typedef typename gsHBox<d,T>::HContainer        HContainer;
    typedef typename gsHBox<d,T>::Iterator          Iterator;
    typedef typename gsHBox<d,T>::cIterator         cIterator;
    typedef typename gsHBox<d,T>::rIterator         rIterator;
    typedef typename gsHBox<d,T>::HIterator         HIterator;
    typedef typename gsHBox<d,T>::cHIterator        cHIterator;
    typedef typename gsHBox<d,T>::rHIterator        rHIterator;
 
    typedef memory::shared_ptr< gsHBoxContainer > Ptr;
 
    typedef memory::unique_ptr< gsHBoxContainer > uPtr;
 
public:
    gsHBoxContainer();
 
    gsHBoxContainer(const gsHBox<d,T> & box  );
    gsHBoxContainer(const Container   & boxes);
    gsHBoxContainer(const HContainer  & boxes);
 
    size_t size(index_t level)  const { return m_boxes[level].size(); }
    size_t nLevels()            const { return m_boxes.size(); }
    size_t totalSize()          const;
 
    bool check() { return _check(this->boxes()); };
 
    void clear();
 
    void add(const gsHBox<d,T>          & box  );
    void add(const Container            & boxes);
    void add(const HContainer           & boxes);
    void add(const gsHBoxContainer<d,T> & boxes);
 
    std::ostream& print( std::ostream& os ) const;
 
    gsHBoxContainer<d,T> patch(const index_t patchID) const;
 
    void makeUnique();
 
    Container &  getActivesOnLevel(index_t lvl);
    const Container & getActivesOnLevel(index_t lvl) const;
    Container getParents() const;
 
    Container getChildren() const;
 
    void        markHadmissible(index_t m);
 
    void        markTadmissible(index_t m);
 
    void        markAdmissible(index_t m);
 
    HContainer & boxes() { return m_boxes; }
    const HContainer & boxes() const { return m_boxes; }
 
    index_t maxLevel() {return m_boxes.size()-1; }
 
    RefBox toBoxes(const index_t patchID=-1)    const;
 
    RefBox toRefBoxes(const index_t patchID=-1) const;
 
    RefBox toCrsBoxes(const index_t patchID=-1) const;
 
    gsMatrix<T> toCoords(const index_t patchID=-1) const;
 
    Container toUnitBoxes() const {return gsHBoxUtils<d,T>::toUnitBoxes(this->m_boxes);}
 
    HContainer toUnitHBoxes() const {return gsHBoxUtils<d,T>::toUnitHBoxes(this->m_boxes);}
 
    Container toContainer() const {return gsHBoxUtils<d,T>::toContainer(m_boxes);}
 
    void makeUnitBoxes();
 
    HIterator begin() {return m_boxes.begin();}
    HIterator end() {return m_boxes.end();}
 
    cHIterator cbegin() const {return m_boxes.begin();}
    cHIterator cend() const {return m_boxes.end();}
 
    rHIterator rbegin() {return m_boxes.rbegin();}
    rHIterator rend() {return m_boxes.rend();}
 
 
    // /**
    //  * @brief      Returns the basis of the underlying basis
    //  *
    //  * NOTE: Assumes that the basis of all boxes is the same
    //  *
    //  * @return     { description_of_the_return_value }
    //  */
    // const gsHTensorBasis<d,T> & basis() { return this->begin()->front().basis(); }
 
    gsHNeighborhood NHtype() const { return m_NHtype;}
 
protected:
    // /// Helper to take the box union
    // Container _boxUnion(const Container & container1, const Container & container2) const;
 
    // /**
    //  * @brief      Takes the union of two \ref gsHBoxContainer
    //  *
    //  * @param[in]  container1  The container 1
    //  * @param[in]  container2  The container 2
    //  *
    //  * @return     The gsHBoxContainer with the union.
    //  */
    // gsHBoxContainer<d,T> _boxUnion(const gsHBoxContainer<d,T> & container1, const gsHBoxContainer<d,T> & container2) const;
 
    // /**
    //  * @brief      Takes the union of two hierarchical containers
    //  *
    //  * @param[in]  container1  The container 1
    //  * @param[in]  container2  The container 2
    //  *
    //  * @return     The hierarchical container with the union.
    //  */
    // HContainer           _boxUnion(const HContainer & container1, const HContainer & container2) const;
 
    void _makeLevel(index_t lvl);
 
    bool _check(const HContainer & boxes);
 
    HContainer  _markHrecursive(HContainer & marked, index_t lvl, index_t m) const;
    void        _markHrecursive(index_t lvl, index_t m);
    HContainer  _markTrecursive(HContainer & marked, index_t lvl, index_t m) const;
 
    HContainer  _markRecursive(HContainer & marked, index_t lvl, index_t m) const;
    void        _markRecursive(index_t lvl, index_t m);
 
    void        _markTadmissible(HContainer & marked, index_t m) const;
 
    void        _markHadmissible(HContainer & marked, index_t m) const;
 
    void        _markAdmissible(HContainer & marked, index_t m) const;
 
 
protected:
    HContainer m_boxes;
    gsHNeighborhood m_NHtype;
 
// public:
//     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
}; // class gsHBoxContainer
 
template<short_t d, class T>
std::ostream& operator<<( std::ostream& os, const gsHBoxContainer<d,T>& b )
{
    return b.print( os );
}
 
} // namespace gismo
 
// *****************************************************************
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsHBoxContainer.hpp)
#else
#ifdef gsHBoxContainer_EXPORT
#include GISMO_HPP_HEADER(gsHBoxContainer.hpp)
#undef  EXTERN_CLASS_TEMPLATE
#define EXTERN_CLASS_TEMPLATE CLASS_TEMPLATE_INST
#endif
namespace gismo
{
EXTERN_CLASS_TEMPLATE gsHBoxContainer<1,real_t>;
EXTERN_CLASS_TEMPLATE gsHBoxContainer<2,real_t>;
EXTERN_CLASS_TEMPLATE gsHBoxContainer<3,real_t>;
EXTERN_CLASS_TEMPLATE gsHBoxContainer<4,real_t>;
 
EXTERN_CLASS_TEMPLATE internal::gsXml< gsHBoxContainer<1,real_t> >;
EXTERN_CLASS_TEMPLATE internal::gsXml< gsHBoxContainer<2,real_t> >;
EXTERN_CLASS_TEMPLATE internal::gsXml< gsHBoxContainer<3,real_t> >;
EXTERN_CLASS_TEMPLATE internal::gsXml< gsHBoxContainer<4,real_t> >;
}
#endif
// *****************************************************************