gsHBox.h

Go to the documentation of this file.

#pragma once

#include <gsIO/gsXml.h>
#include <gsCore/gsLinearAlgebra.h> // due to EIGEN_MAKE_ALIGNED_OPERATOR_NEW
#include <gsHSplines/gsHDomainIterator.h>
#include <gsHSplines/gsHTensorBasis.h>
#include <gsHSplines/gsHBoxUtils.h>

namespace gismo
{

// forward declaration to move includes into the .hpp-file
template<short_t d, class Z>
struct gsAABB;

template<int d, class T>
class gsHBox
{
public:
#   define Eigen gsEigen
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
#   undef Eigen

public:
    typedef gsVector<index_t,d> point;
    typedef typename gsEigen::aligned_allocator<gsHBox<d,T>> aalloc;

    typedef typename std::vector<index_t>                                   RefBox;
    typedef typename std::list<gsHBox<d,T>,typename gsHBox<d,T>::aalloc>    Container;
    typedef typename std::vector<gsHBox<d,T>,typename gsHBox<d,T>::aalloc>  SortedContainer;
    typedef typename std::vector<Container>                                 HContainer; // container[level]
    typedef typename Container::iterator            Iterator;
    typedef typename Container::reverse_iterator    rIterator;
    typedef typename Container::const_iterator      cIterator;
    typedef typename HContainer::iterator           HIterator;
    typedef typename HContainer::reverse_iterator   rHIterator;
    typedef typename HContainer::const_iterator     cHIterator;

    typedef memory::shared_ptr< gsHBox > Ptr;

    typedef memory::unique_ptr< gsHBox > uPtr;

public:

    gsHBox();

    gsHBox(const gsHDomainIterator<T,d> * domHIt);

    gsHBox(const gsHDomainIterator<T,d> * domHIt, const index_t pid);

    gsHBox(const typename gsHBox<d,T>::point & low,const typename gsHBox<d,T>::point & upp, index_t level, const gsHTensorBasis<d,T> * basis, const index_t pid = -1);

    gsHBox(const gsAABB<d, index_t> & box, const gsHTensorBasis<d,T> * basis, const index_t pid = -1);

    gsHBox(const std::vector<index_t> & indices, const gsHTensorBasis<d,T> * basis, const index_t pid = -1);

    gsHBox( const gsHBox<d,T> & other );

    gsHBox( gsHBox<d,T> && other );

    gsHBox<d,T> & operator= ( const gsHBox<d,T> & other );

    gsHBox<d,T> & operator= ( gsHBox<d,T> && other );

    bool isContained(const gsHBox<d,T> & other) const;

    bool contains(const gsHBox<d,T> & other) const;

    bool isSame(const gsHBox<d,T> & other) const;

    bool isActive() const;

    bool isActiveOrContained() const;

    const gsMatrix<T> & getCoordinates() const;

    const gsMatrix<T> & getCenter() const;

    gsVector<T,d> lowerCorner() const;

    gsVector<T,d> upperCorner() const;

    T getCellSize() const;

    T getMinCellLength() const;

    T getMaxCellLength() const;

    const point & lowerIndex() const;
    const point & upperIndex() const;

    index_t patch() const;

    index_t level() const;

    index_t levelInCenter() const;

    void setError(T error);

    void setAndProjectError(T error, index_t alpha=2, index_t beta=0);

    T error() const;

    T projectedErrorRef() const;

    T projectedErrorCrs() const;


    T projectedImprovement() const;

    T projectedSetBack() const;


    void setIndex(index_t index);

    index_t index() const;

    void mark();
    void unmark();

    bool marked() const;

    void setMark(bool mark);

    gsHBox<d,T> getParent() const;

    gsHBox<d,T> getAncestor(index_t k) const;

    Container getChildren() const;

    Container getDescendants(index_t k) const;

    Container getSiblings() const;

    Container getSupportExtension();

    Container getMultiLevelSupportExtension(index_t k);

    Container getHneighborhood(index_t m);

    Container getTneighborhood(index_t m);


    template<gsHNeighborhood _mode>
    typename gsHBox<d,T>::Container getNeighborhood(index_t m) { return getNeighborhood_impl<_mode>(m);}


    Container getNeighborhood(index_t m);

    Container getCneighborhood(index_t m);

    Container getCextension(index_t m);

    Container            toContainer();

    HContainer           toHContainer();

    std::ostream& print( std::ostream& os ) const;

    RefBox toBox() const;

    RefBox toRefBox(index_t targetLevel) const;
    RefBox toRefBox() const
    {
        return this->toRefBox(this->level()+1);
    }

    RefBox toCrsBox(index_t targetLevel) const;
    RefBox toCrsBox() const
    {
        return this->toCrsBox(this->level()-1);
    }

    // Helper functions
    HContainer           boxUnion(const HContainer & container1, const HContainer & container2) const;

    const gsHTensorBasis<d,T> & basis() const { return *m_basis; }
    void setBasis(const gsHTensorBasis<d,T> * basis) { m_basis = basis; }

    Container toUnitBoxes() const;

    bool good() const;

    void clean(Container & container) const;

    void computeCoordinates() const;
    void computeCenter() const;

protected:

    void _computeIndices();
    gsAABB<d, index_t> _computeIndices(const gsMatrix<T> & coords, index_t level);
    gsAABB<d, index_t> _computeIndices(const gsMatrix<T> & coords, const gsMatrix<T> & center);
    gsAABB<d, index_t> _computeIndices(const gsMatrix<T> & coords);

    gsAABB<d, index_t> _elevateBox(const gsAABB<d, index_t> & box) const;
    gsAABB<d, index_t> _lowerBox(const gsAABB<d, index_t> & box) const;

    Container  _getParents(typename gsHBox<d,T>::Container  & container) const;
    HContainer _getParents(typename gsHBox<d,T>::HContainer & container) const;


    Container _boxUnion(const Container & container1, const Container & container2) const;
    Container _makeUnique(const Container & container) const;

    template<gsHNeighborhood _mode>
    typename std::enable_if<_mode==gsHNeighborhood::Automatic, typename gsHBox<d,T>::Container>::type
    getNeighborhood_impl(index_t m)
    {
        if (dynamic_cast<const gsTHBSplineBasis<d,T>*>(this->basis()))
            return this->getTneighborhood(m);
        else if (dynamic_cast<const gsHBSplineBasis<d,T>*>(this->basis()))
            return this->getHneighborhood(m);
    }

    template<gsHNeighborhood _mode>
    typename std::enable_if<_mode==gsHNeighborhood::T, typename gsHBox<d,T>::Container>::type
    getNeighborhood_impl(index_t m)
    {
        return this->getTneighborhood(m);
    }

    template<gsHNeighborhood _mode>
    typename std::enable_if<_mode==gsHNeighborhood::H, typename gsHBox<d,T>::Container>::type
    getNeighborhood_impl(index_t m)
    {
        return this->getHneighborhood(m);
    }


protected:
    gsAABB<d, index_t> m_indices;

    index_t m_pid;
    mutable gsMatrix<T> m_coords;
    mutable gsMatrix<T> m_center;
    const gsHTensorBasis<d,T> * m_basis;

    T m_error;
    T m_error_ref;
    T m_error_crs;
    index_t m_index;
    bool m_marked;

}; // class gsHBox


template<int d, class T>
std::ostream& operator<<( std::ostream& os, const gsHBox<d,T>& b )
{
    return b.print( os );
}

} // namespace gismo

// *****************************************************************
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsHBox.hpp)
#else
#ifdef gsHBox_EXPORT
#include GISMO_HPP_HEADER(gsHBox.hpp)
#undef  EXTERN_CLASS_TEMPLATE
#define EXTERN_CLASS_TEMPLATE CLASS_TEMPLATE_INST
#endif
namespace gismo
{
EXTERN_CLASS_TEMPLATE gsHBox<1,real_t>;
EXTERN_CLASS_TEMPLATE gsHBox<2,real_t>;
EXTERN_CLASS_TEMPLATE gsHBox<3,real_t>;
EXTERN_CLASS_TEMPLATE gsHBox<4,real_t>;

EXTERN_CLASS_TEMPLATE internal::gsXml< gsHBox<1,real_t> >;
EXTERN_CLASS_TEMPLATE internal::gsXml< gsHBox<2,real_t> >;
EXTERN_CLASS_TEMPLATE internal::gsXml< gsHBox<3,real_t> >;
EXTERN_CLASS_TEMPLATE internal::gsXml< gsHBox<4,real_t> >;

}
#endif
// *****************************************************************