subset_handler_interface.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__LIBGRID__SUBSET_HANDLER_INTERFACE__
#define __H__LIBGRID__SUBSET_HANDLER_INTERFACE__
 
#include <list>
#include <string>
#include <vector>
#include <map>
#include "lib_grid/grid/grid.h"
#include "lib_grid/common_attachments.h"
#include "common/util/variant.h"
 
namespace ug
{
//  predeclarations
class ISubsetHandler;
 
//  SubsetHandlerElements
 
enum SubsetHandlerElements
{
  SHE_NONE = 0,
  SHE_VERTEX = 1,
  SHE_EDGE = 1<<1,
  SHE_FACE = 1<<2,
  SHE_VOLUME = 1 << 3,
  SHE_ALL = SHE_VERTEX | SHE_EDGE | SHE_FACE | SHE_VOLUME
};
enum SubsetHandlerElements {…};
 
//  SubsetState
 
enum SubsetState
{
  SS_NONE = 0,
  SS_USER_STATE = 1 << 16
};
enum SubsetState {…};
 
//  SubsetInfo
 
struct SubsetInfo
{
  SubsetInfo();
  std::string name;
  int     materialIndex;
  vector4   color;
  uint    subsetState;
 
  typedef std::map<std::string, Variant>  PropertyMap;
 
  PropertyMap m_propertyMap;
 
 
  void set_property(const char* name, Variant prop);
  void set_property(const std::string& name, Variant prop);
 
  Variant get_property(const char* name, Variant defaultValue = Variant()) const;
  Variant get_property(const std::string& name, Variant defaultValue = Variant()) const;
};
struct SubsetInfo {…};
 
/*
//  specialization of attachment_traits for Vertex
template<>
class attachment_traits<Vertex*, ISubsetHandler>
{
  public:
    typedef Vertex*&      ElemRef;
    typedef Vertex*       ElemPtr;
    typedef const Vertex*   ConstElemPtr;
    typedef ISubsetHandler*     ElemHandlerPtr;
    typedef const ISubsetHandler* ConstElemHandlerPtr;
 
    static inline void invalidate_entry(ElemHandlerPtr pHandler, ElemRef elem)        {elem = NULL;}
    static inline bool entry_is_invalid(ElemHandlerPtr pHandler, ElemRef elem)        {return elem != NULL;}
    static inline uint get_data_index(ElemHandlerPtr pHandler, ConstElemPtr elem);
    static inline void set_data_index(ElemHandlerPtr pHandler, ElemPtr elem, uint index);
};
 
//  specialization of attachment_traits for Edge
template<>
class attachment_traits<Edge*, ISubsetHandler>
{
  public:
    typedef Edge*&        ElemRef;
    typedef Edge*       ElemPtr;
    typedef const Edge*     ConstElemPtr;
    typedef ISubsetHandler*     ElemHandlerPtr;
    typedef const ISubsetHandler* ConstElemHandlerPtr;
 
    static inline void invalidate_entry(ElemHandlerPtr pHandler, ElemRef elem)        {elem = NULL;}
    static inline bool entry_is_invalid(ElemHandlerPtr pHandler, ElemRef elem)        {return elem != NULL;}
    static inline uint get_data_index(ElemHandlerPtr pHandler, ConstElemPtr elem);
    static inline void set_data_index(ElemHandlerPtr pHandler, ElemPtr elem, uint index);
};
 
//  specialization of attachment_traits for Face
template<>
class attachment_traits<Face*, ISubsetHandler>
{
  public:
    typedef Face*&          ElemRef;
    typedef Face*         ElemPtr;
    typedef const Face*       ConstElemPtr;
    typedef ISubsetHandler*     ElemHandlerPtr;
    typedef const ISubsetHandler* ConstElemHandlerPtr;
 
    static inline void invalidate_entry(ElemHandlerPtr pHandler, ElemRef elem)        {elem = NULL;}
    static inline bool entry_is_invalid(ElemHandlerPtr pHandler, ElemRef elem)        {return elem != NULL;}
    static inline uint get_data_index(ElemHandlerPtr pHandler, ConstElemPtr elem);
    static inline void set_data_index(ElemHandlerPtr pHandler, ElemPtr elem, uint index);
};
 
//  specialization of attachment_traits for Volume
template<>
class attachment_traits<Volume*, ISubsetHandler>
{
  public:
    typedef Volume*&        ElemRef;
    typedef Volume*         ElemPtr;
    typedef const Volume*     ConstElemPtr;
    typedef ISubsetHandler*     ElemHandlerPtr;
    typedef const ISubsetHandler* ConstElemHandlerPtr;
 
    static inline void invalidate_entry(ElemHandlerPtr pHandler, ElemRef elem)        {elem = NULL;}
    static inline bool entry_is_invalid(ElemHandlerPtr pHandler, ElemRef elem)        {return elem != NULL;}
    static inline uint get_data_index(ElemHandlerPtr pHandler, ConstElemPtr elem);
    static inline void set_data_index(ElemHandlerPtr pHandler, ElemPtr elem, uint index);
};
*/
 
//  ISubsetHandler
class UG_API ISubsetHandler : public GridObserver
{/*
  friend class attachment_traits<Vertex*, ISubsetHandler>;
  friend class attachment_traits<Edge*, ISubsetHandler>;
  friend class attachment_traits<Face*, ISubsetHandler>;
  friend class attachment_traits<Volume*, ISubsetHandler>;*/
 
  public:/*
    typedef AttachmentPipe<Vertex*, ISubsetHandler> VertexAttachmentPipe;
    typedef AttachmentPipe<Edge*, ISubsetHandler> EdgeAttachmentPipe;
    typedef AttachmentPipe<Face*, ISubsetHandler>   FaceAttachmentPipe;
    typedef AttachmentPipe<Volume*, ISubsetHandler>   VolumeAttachmentPipe;*/
 
    template <class TElem>
    struct traits{
      typedef typename geometry_traits<TElem>::iterator   iterator;
      typedef typename geometry_traits<TElem>::const_iterator const_iterator;
    };
    struct traits {…};
 
  public:
 
    ISubsetHandler(uint supportedElements = SHE_ALL);
 
 
    ISubsetHandler(Grid& grid, uint supportedElements = SHE_ALL);
 
    virtual ~ISubsetHandler();
 
 
    ISubsetHandler& operator = (const ISubsetHandler& sh);
 
 
    Grid* grid() const;
 
 
    bool elements_are_supported(uint shElements) const;
 
 
    void set_supported_elements(uint shElements);
 
 
    void enable_element_support(uint shElements);
 
 
    void disable_element_support(uint shElements);
 
    void set_default_subset_index(int subsetIndex);
    inline int get_default_subset_index() {return m_defaultSubsetIndex;}
 
    void enable_subset_inheritance(bool bEnable);
    inline bool subset_inheritance_enabled()  {return m_bSubsetInheritanceEnabled;}
 
    void enable_strict_inheritance(bool bEnable);
    inline bool strict_inheritance_enabled()  {return m_bStrictInheritanceEnabled;}
 
 
    inline void subset_required(int index);
 
    inline void subset_required(int index) const;
 
    inline int num_subsets() const    {return (int)m_subsetInfos.size();}
 
    const char* get_subset_name(int subsetIndex) const;
 
    void set_subset_name(const char* name, int subsetIndex);
 
 
    void set_subset_info(int subsetIndex, const SubsetInfo& subsetInfo);
 
    SubsetInfo& subset_info(int subsetIndex);
 
    const SubsetInfo& subset_info(int subsetIndex) const;
 
    void set_default_subset_info(const SubsetInfo& defSI);
 
  //  clear methods
    void clear();
    void clear_subset(int subsetIndex);
    void clear_subsets();
 
 
    void insert_subset(int subsetIndex);
    void erase_subset(int subsetIndex);
    void swap_subsets(int subsetIndex1, int subsetIndex2);
    void move_subset(int indexFrom, int indexTo);
    void join_subsets(int targetSub, int sub1, int sub2, bool eraseUnusedSubs);
 
    template <class TIterator>
    void assign_subset(TIterator iterBegin, TIterator iterEnd, int subsetIndex);
 
    int get_subset_index(GridObject* elem) const;
    inline int get_subset_index(Vertex* elem) const;
    inline int get_subset_index(Edge* elem) const;
    inline int get_subset_index(Face* elem) const;
    inline int get_subset_index(Volume* elem) const;
 
 
    int get_subset_index(const char* name) const;
 
  //  grid callbacks
    //virtual void registered_at_grid(Grid* grid);
    //virtual void unregistered_from_grid(Grid* grid);
    virtual void grid_to_be_destroyed(Grid* grid);
    virtual void elements_to_be_cleared(Grid* grid);
 
  //  element callbacks
    virtual void vertex_created(Grid* grid, Vertex* vrt,
                  GridObject* pParent = NULL,
                  bool replacesParent = false);
 
    virtual void edge_created(Grid* grid, Edge* e,
                  GridObject* pParent = NULL,
                  bool replacesParent = false);
 
    virtual void face_created(Grid* grid, Face* f,
                  GridObject* pParent = NULL,
                  bool replacesParent = false);
 
    virtual void volume_created(Grid* grid, Volume* vol,
                  GridObject* pParent = NULL,
                  bool replacesParent = false);
 
    virtual void vertex_to_be_erased(Grid* grid, Vertex* vrt,
                     Vertex* replacedBy = NULL);
 
    virtual void edge_to_be_erased(Grid* grid, Edge* e,
                     Edge* replacedBy = NULL);
 
    virtual void face_to_be_erased(Grid* grid, Face* f,
                     Face* replacedBy = NULL);
 
    virtual void volume_to_be_erased(Grid* grid, Volume* vol,
                     Volume* replacedBy = NULL);
 
    virtual void vertices_to_be_merged(Grid* grid, Vertex* target,
                     Vertex* elem1, Vertex* elem2);
 
    virtual void edges_to_be_merged(Grid* grid, Edge* target,
                     Edge* elem1, Edge* elem2);
 
    virtual void faces_to_be_merged(Grid* grid, Face* target,
                     Face* elem1, Face* elem2);
 
    virtual void volumes_to_be_merged(Grid* grid, Volume* target,
                     Volume* elem1, Volume* elem2);
 
  //  Virtual methods for derived classes
    virtual void assign_subset(Vertex* elem, int subsetIndex) = 0;
 
    virtual void assign_subset(Edge* elem, int subsetIndex) = 0;
 
    virtual void assign_subset(Face* elem, int subsetIndex) = 0;
 
    virtual void assign_subset(Volume* elem, int subsetIndex) = 0;
 
    virtual void assign_subset(GridObject* elem, int subsetIndex);
 
 
    //virtual size_t collect_subset_elements(std::vector<Vertex*>& vrtsOut,
    //                     int subsetIndex) const = 0;
 
 
    //virtual size_t collect_subset_elements(std::vector<Edge*>& edgesOut,
    //                     int subsetIndex) const = 0;
 
 
    //virtual size_t collect_subset_elements(std::vector<Face*>& facesOut,
    //                    int subsetIndex) const = 0;
 
 
    //virtual size_t collect_subset_elements(std::vector<Volume*>& volsOut,
    //                     int subsetIndex) const = 0;
 
    virtual bool contains_vertices(int subsetIndex) const = 0;
 
    virtual bool contains_edges(int subsetIndex) const = 0;
 
    virtual bool contains_faces(int subsetIndex) const = 0;
 
    virtual bool contains_volumes(int subsetIndex) const = 0;
 
 
    virtual GridObjectCollection
      get_grid_objects_in_subset(int subsetInd) const = 0;
 
  //  attachments
 
 
    //void enable_subset_attachments(bool bEnable);
 
    /*inline bool subset_attachments_are_enabled()  {return m_bSubsetAttachmentsEnabled;};
 
    inline uint get_attachment_data_index(const Vertex* v) const  {return m_aaDataIndVRT[v];}
    inline uint get_attachment_data_index(const Edge* e) const    {return m_aaDataIndEDGE[e];}
    inline uint get_attachment_data_index(const Face* f) const      {return m_aaDataIndFACE[f];}
    inline uint get_attachment_data_index(const Volume* v) const    {return m_aaDataIndVOL[v];}
*/
 
    /*template <class TGeomObjClass>
    inline void attach_to(IAttachment& attachment, int subsetIndex);
*/
 
    /*template <class TGeomObjClass, class TAttachment>
    void attach_to_dv(TAttachment& attachment, int subsetIndex,
            const typename TAttachment::ValueType& defaultValue);
*/
  //  detach
    /*template <class TGeomObjClass>
    void detach_from(IAttachment& attachment, int subsetIndex);
*/
  //  attachments helper
  //  attach with attachments default pass-on behaviour
    /*inline void attach_to_vertices(IAttachment& attachment, int subsetIndex)  {attach_to<Vertex>(attachment, subsetIndex);}
    inline void attach_to_edges(IAttachment& attachment, int subsetIndex)   {attach_to<Edge>(attachment, subsetIndex);}
    inline void attach_to_faces(IAttachment& attachment, int subsetIndex)   {attach_to<Face>(attachment, subsetIndex);}
    inline void attach_to_volumes(IAttachment& attachment, int subsetIndex)   {attach_to<Volume>(attachment, subsetIndex);}
*/
  //  attach with default value and attachments default pass-on behaviour
    /*template <class TAttachment>
    inline void attach_to_vertices_dv(TAttachment& attachment, int subsetIndex, const typename TAttachment::ValueType& defaultValue)  {attach_to_dv<Vertex>(attachment, subsetIndex, defaultValue);}
    template <class TAttachment>
    inline void attach_to_edges_dv(TAttachment& attachment, int subsetIndex, const typename TAttachment::ValueType& defaultValue)   {attach_to_dv<Edge>(attachment, subsetIndex, defaultValue);}
    template <class TAttachment>
    inline void attach_to_faces_dv(TAttachment& attachment, int subsetIndex, const typename TAttachment::ValueType& defaultValue)   {attach_to_dv<Face>(attachment, subsetIndex, defaultValue);}
    template <class TAttachment>
    inline void attach_to_volumes_dv(TAttachment& attachment, int subsetIndex, const typename TAttachment::ValueType& defaultValue)   {attach_to_dv<Volume>(attachment, subsetIndex, defaultValue);}
*/
  //  detach
    /*inline void detach_from_vertices(IAttachment& attachment, int subsetIndex)  {detach_from<Vertex>(attachment, subsetIndex);}
    inline void detach_from_edges(IAttachment& attachment, int subsetIndex)   {detach_from<Edge>(attachment, subsetIndex);}
    inline void detach_from_faces(IAttachment& attachment, int subsetIndex)   {detach_from<Face>(attachment, subsetIndex);}
    inline void detach_from_volumes(IAttachment& attachment, int subsetIndex) {detach_from<Volume>(attachment, subsetIndex);}
*/
 
    /*template <class TGeomObj, class TAttachment>
    inline typename TAttachment::ContainerType*
    get_attachment_data_container(TAttachment& attachment, int subsetIndex);
*/
  protected:
    typedef Grid::traits<Vertex>::AttachedElementList AttachedVertexList;
    typedef Grid::traits<Edge>::AttachedElementList   AttachedEdgeList;
    typedef Grid::traits<Face>::AttachedElementList     AttachedFaceList;
    typedef Grid::traits<Volume>::AttachedElementList   AttachedVolumeList;
 
    typedef Grid::traits<Vertex>::SectionContainer    VertexSectionContainer;
    typedef Grid::traits<Edge>::SectionContainer    EdgeSectionContainer;
    typedef Grid::traits<Face>::SectionContainer      FaceSectionContainer;
    typedef Grid::traits<Volume>::SectionContainer      VolumeSectionContainer;
 
  protected:
 
    void assign_subset_handler(const ISubsetHandler& sh);
 
 
    void set_grid(Grid* grid);
 
 
    void reset_subset_indices(uint shElements = SHE_ALL);
 
    void create_required_subsets(int index);
 
    inline void subset_assigned(Vertex* v, int subsetIndex);
    inline void subset_assigned(Edge* e, int subsetIndex);
    inline void subset_assigned(Face* f, int subsetIndex);
    inline void subset_assigned(Volume* v, int subsetIndex);
 
    inline void alter_subset_index(Vertex* v, int subsetIndex)  {m_aaSubsetIndexVRT[v] = subsetIndex;}
    inline void alter_subset_index(Edge* e, int subsetIndex)  {m_aaSubsetIndexEDGE[e] = subsetIndex;}
    inline void alter_subset_index(Face* f, int subsetIndex)    {m_aaSubsetIndexFACE[f] = subsetIndex;}
    inline void alter_subset_index(Volume* v, int subsetIndex)    {m_aaSubsetIndexVOL[v] = subsetIndex;}
 
    virtual void erase_subset_lists() = 0;
 
    virtual void clear_subset_lists(int index) = 0;
 
    virtual void change_subset_indices(int indOld, int indNew) = 0;
 
 
    virtual void add_required_subset_lists(int maxIndex) = 0;
 
    virtual void erase_subset_lists(int index) = 0;
 
    virtual void swap_subset_lists(int ind1, int ind2) = 0;
 
    virtual void move_subset_lists(int indexFrom, int indexTo) = 0;
 
    virtual void join_subset_lists(int target, int src1, int src2) = 0;
 
    template <class TElem>
    void elems_to_be_merged(Grid* grid, TElem* target,
                TElem* elem1, TElem* elem2);
 
  //  attachments
    /*inline void set_attachment_data_index(Vertex* v, uint index)  {m_aaDataIndVRT[v] = index;}
    inline void set_attachment_data_index(Edge* e, uint index)    {m_aaDataIndEDGE[e] = index;}
    inline void set_attachment_data_index(Face* f, uint index)      {m_aaDataIndFACE[f] = index;}
    inline void set_attachment_data_index(Volume* v, uint index)    {m_aaDataIndVOL[v] = index;}
 
    void resize_attachment_pipes(size_t newSize);
    void clear_attachment_pipes(int subsetIndex);
    void clear_attachment_pipes();
 
    template <class TGeomObj>
    inline AttachmentPipe<TGeomObj*, ISubsetHandler>&
    get_attachment_pipe(int subsetIndex);
*/
  //  virtual methods for attachments
 
    //virtual void register_subset_elements_at_pipe() = 0;
 
 
    //inline void register_at_pipe(Vertex* elem)  {m_vertexAttachmentPipes[get_subset_index(elem)]->register_element(elem);}
 
 
    //inline void register_at_pipe(Edge* elem)  {m_edgeAttachmentPipes[get_subset_index(elem)]->register_element(elem);}
 
 
    //inline void register_at_pipe(Face* elem)    {m_faceAttachmentPipes[get_subset_index(elem)]->register_element(elem);}
 
 
    //inline void register_at_pipe(Volume* elem)    {m_volumeAttachmentPipes[get_subset_index(elem)]->register_element(elem);}
 
  public:
 
    /*template <class TGeomObj, class TAttachment>
    class AttachmentAccessor : public ug::AttachmentAccessor<TGeomObj*, TAttachment, ISubsetHandler>
    {
      protected:
        typedef ug::AttachmentAccessor<TGeomObj*, TAttachment, ISubsetHandler>  BaseClass;
 
      public:
        AttachmentAccessor()  {}
        AttachmentAccessor(const AttachmentAccessor& aa) : BaseClass(aa)  {}
        AttachmentAccessor(ISubsetHandler& sh, TAttachment& a, int subsetIndex) : BaseClass(sh.get_attachment_pipe<TGeomObj>(subsetIndex), a) {}
 
        inline void access(ISubsetHandler& sh, TAttachment& a, int subsetIndex)
          {BaseClass::access(sh.get_attachment_pipe<TGeomObj>(subsetIndex), a);}
    };*/
 
 
 
/*
    template <class TAttachmet, class TGeomBaseObj>
    class MultiSubsetAttachmentAccessor
    {
    //TODO: implement this!
    };
*/
  private:
    ISubsetHandler(const ISubsetHandler& sh)  {};
 
  protected:
    typedef AInt          ASubsetIndex;
    //typedef Attachment<uint>    ADataIndex;
    typedef std::vector<SubsetInfo> SubsetInfoVec;
    /*typedef std::vector<VertexAttachmentPipe*>  VertexAttachmentPipeVec;
    typedef std::vector<EdgeAttachmentPipe*>  EdgeAttachmentPipeVec;
    typedef std::vector<FaceAttachmentPipe*>  FaceAttachmentPipeVec;
    typedef std::vector<VolumeAttachmentPipe*>  VolumeAttachmentPipeVec;*/
 
  protected:
    Grid*       m_pGrid;
    /*VertexAttachmentPipeVec m_vertexAttachmentPipes;
    EdgeAttachmentPipeVec m_edgeAttachmentPipes;
    FaceAttachmentPipeVec m_faceAttachmentPipes;
    VolumeAttachmentPipeVec m_volumeAttachmentPipes;*/
 
    SubsetInfoVec m_subsetInfos;
    SubsetInfo    m_defaultSubsetInfo;
    uint      m_supportedElements;
 
    ASubsetIndex  m_aSubsetIndex;
    //ADataIndex    m_aDataIndex;
 
    int       m_defaultSubsetIndex;
    bool      m_bSubsetInheritanceEnabled;
    bool      m_bStrictInheritanceEnabled;
    //bool      m_bSubsetAttachmentsEnabled;
 
    Grid::VertexAttachmentAccessor<ASubsetIndex>  m_aaSubsetIndexVRT;
    Grid::EdgeAttachmentAccessor<ASubsetIndex>    m_aaSubsetIndexEDGE;
    Grid::FaceAttachmentAccessor<ASubsetIndex>    m_aaSubsetIndexFACE;
    Grid::VolumeAttachmentAccessor<ASubsetIndex>  m_aaSubsetIndexVOL;
/*
    Grid::VertexAttachmentAccessor<ADataIndex>    m_aaDataIndVRT;
    Grid::EdgeAttachmentAccessor<ADataIndex>    m_aaDataIndEDGE;
    Grid::FaceAttachmentAccessor<ADataIndex>    m_aaDataIndFACE;
    Grid::VolumeAttachmentAccessor<ADataIndex>    m_aaDataIndVOL;*/
};
class UG_API ISubsetHandler : public GridObserver {…};
 
}// end of namespace
 
//  include implementation
#include "subset_handler_interface_impl.hpp"
 
#endif