gsBoxTopology.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsCore/gsExport.h>
 
#include <gsCore/gsBoundary.h>
#include <gsMesh2/gsProperty.h>
 
namespace gismo
{
 
class GISMO_EXPORT gsBoxTopology
{
 
public:
    typedef memory::shared_ptr< gsBoxTopology > Ptr;
    typedef memory::unique_ptr< gsBoxTopology > uPtr;
 
    typedef std::vector< patchSide > bContainer;
    typedef bContainer::iterator biterator;
    typedef bContainer::const_iterator const_biterator;
 
    typedef std::vector<boundaryInterface> ifContainer;
    typedef ifContainer::iterator iiterator;
    typedef ifContainer::const_iterator const_iiterator;
 
    typedef const boundaryInterface * InterfacePtr;
    typedef patchSide * BoundaryPtr;
public:
 
    gsBoxTopology(short_t d = -1, index_t n = 0) : m_dim(d), nboxes(0) 
    { 
        addBox(n);
    }
 
    gsBoxTopology( short_t d, index_t boxes,
            const bContainer & boundary,
            const ifContainer & interfaces )
    : m_dim(d), nboxes(0), m_boundary(boundary), m_interfaces(interfaces) 
    { 
        addBox(boxes);
    }
 
    // Default copy constructor does the same as the following:
    //gsBoxTopology(const gsBoxTopology & other) : dim(other.dim), nboxes(other.nboxes), 
    //    m_boundary(other.m_boundary), m_interfaces(other.m_interfaces)
    // { }
    
    gsBoxTopology * clone() const
    {
        return new gsBoxTopology(*this);
    }
 
public:
 
    std::ostream &print(std::ostream &os) const;
 
    friend std::ostream& operator<<( std::ostream& os, const gsBoxTopology& b )
    {
        return b.print( os );
    }
    
    index_t nBoxes() const       { return nboxes; }
 
    short_t dim  () const       { return m_dim; }
 
    void setDim  (short_t i)
    { 
        GISMO_ASSERT(m_dim==-1 || i==m_dim, "Changing box dimension.");
        m_dim = i; 
    }
 
    size_t nInterfaces() const { return m_interfaces.size(); }
 
    size_t nBoundary() const   { return m_boundary.size(); }
 
/*
 * Additional members for Multipatch geometries
 */
 
        const_iiterator iBegin() const
        { return m_interfaces.begin(); }
 
        const_iiterator iEnd() const
        { return m_interfaces.end(); }
 
        iiterator iBegin()
        { return m_interfaces.begin(); }
 
        iiterator iEnd()
        { return m_interfaces.end(); }
 
        const_biterator bBegin() const
        { return m_boundary.begin(); }
 
        const_biterator bEnd() const
        { return m_boundary.end(); }
 
        biterator bBegin()
        { return m_boundary.begin(); }
 
        biterator bEnd()
        { return m_boundary.end(); }
 
    void clearTopology()
    {
        m_boundary  .clear();
        m_interfaces.clear();
    }
 
    void clearAll()
    {
        clearTopology();
        m_dim  = -1;
        nboxes =  0;
        m_boxProp.clear();
    }
 
    void swap(gsBoxTopology& other)
    {
        std::swap( m_dim, other.m_dim );
        std::swap( nboxes, other.nboxes );
        m_boundary.swap( other.m_boundary );
        m_interfaces.swap( other.m_interfaces );
        std::swap( m_boxProp, other.m_boxProp );
    }
 
    void addInterface(index_t p1, boxSide s1,
                      index_t p2, boxSide s2,
                      std::string l = "")
    {
        addInterface(boundaryInterface(patchSide(p1, s1), patchSide(p2, s2), m_dim,l));
    }
 
    void addInterface( const boundaryInterface& bi )
    {
        m_interfaces.push_back( bi );
    }
 
    void addBox(index_t i = 1)
    {
        nboxes += i;
 
        m_boxProp.reserve(m_boxProp.size()+i);
        for (index_t k=0; k!=i; k++)
            m_boxProp.push_back();
    }
 
    void addBoundary(index_t p, boxSide s, std::string l = "")
    {
        addBoundary(patchSide(p, s, l));
    }
 
    void addBoundary(const patchSide& ps)
    {
        m_boundary.push_back( ps );
    }
 
    void addAutoBoundaries();
 
    bool isBoundary(const patchSide& ps) const
    {
        return std::find(m_boundary.begin(), m_boundary.end(), ps) != m_boundary.end();
    }
 
    bool isBoundary( index_t p, boxSide s )
    {
        return isBoundary( patchSide(p,s) );
    }
 
    bool isInterface(const patchSide& ps) const;
 
    const bContainer & boundaries() const { return m_boundary;}
    bContainer & boundaries() { return m_boundary;}
 
    bContainer   boundaries(const std::string l) const
    {
        bContainer result;
        for (const_biterator bit = bBegin(); bit!=bEnd(); bit++)
            if (bit->label() == l)
                result.push_back(*bit);
        return result;
    }
 
    const ifContainer & interfaces() const { return m_interfaces; }
    ifContainer & interfaces() { return m_interfaces; }
 
    ifContainer   interfaces(const std::string l) const
    {
        ifContainer result;
        for (const_iiterator iit = iBegin(); iit!=iEnd(); iit++)
            if (iit->label() == l)
                result.push_back(*iit);
        return result;
    }
 
    ifContainer selectInterfaces(interaction::type ifc_type) const;
 
    void checkConsistency() const;
 
    const boundaryInterface & bInterface(int i) const {return m_interfaces[i];}
 
    bool getNeighbour(const patchSide& ps ,patchSide& result, int & ii) const;
 
    bool getNeighbour(const patchSide& ps ,patchSide& result) const;
 
    InterfacePtr findInterface(const index_t b1, const index_t b2) const;
 
    BoundaryPtr getBoundary(const patchSide & ps);
 
    bool getInterface(const patchSide& ps,boundaryInterface & result) const
    {
        for ( unsigned i = 0; i < m_interfaces.size(); ++i )
            if ( m_interfaces[i].first() == ps || m_interfaces[i].second() == ps )
            {
                result = m_interfaces[i];
                return true;
            }
        return false;
    }
 
    bool getCornerList(const patchCorner& start, std::vector<patchCorner> & cornerList) const;
 
    int getMaxValence() const;
 
    std::vector< std::vector<patchComponent> > allComponents(bool combineCorners = false) const;
 
    void getEVs(std::vector<std::vector<patchCorner> > & cornerLists, bool boundaries = false) const;
 
    void getOVs(std::vector<std::vector<patchCorner> > & cornerLists) const;
 
 
    std::vector<std::vector<patchCorner>> vertices() const;
 
    template <class T> 
    gsProperty<T> addBoxProperty(const std::string& name, T t=T())
    {
        return m_boxProp.add<T>(name, give(t));
    }
 
    template <class T> 
    gsProperty<T> getBoxProperty(const std::string& name) const
    {
        return m_boxProp.get<T>(name);
    }
 
    index_t numBoxProperties() const
    {
        return m_boxProp.n_properties();
    }
 
protected:
    // Data members
 
    short_t m_dim;
 
    index_t nboxes;
 
    bContainer m_boundary;
 
    ifContainer m_interfaces;
 
    gsProperty_container m_boxProp;
 
}; // class gsBoxTopology
 
#ifdef GISMO_WITH_PYBIND11
 
  void pybind11_init_gsBoxTopology(pybind11::module &m);
 
#endif // GISMO_WITH_PYBIND11
 
} // namespace gismo