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
// *****************************************************************