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