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