surface_view.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__UG__LIB_GRID__TOOLS__SURFACE_VIEW__
#define __H__UG__LIB_GRID__TOOLS__SURFACE_VIEW__
 
#ifdef UG_PARALLEL
  #include "lib_grid/parallelization/distributed_grid.h"
#endif
 
#include "lib_grid/multi_grid.h"
#include "lib_grid/tools/grid_level.h"
#include "subset_handler_multi_grid.h"
#include "lib_grid/algorithms/attachment_util.h"
#include "common/util/flags.h"
 
namespace ug{
 
 
class SurfaceView
{
  public:
    enum SurfaceConstants{
      // each grid-object has exactly on of these states (begin)
      MG_SHADOW_PURE = 1,               
      MG_SURFACE_PURE = 1 << 1,         
      MG_SURFACE_RIM = 1 << 2,          
      MG_SHADOW_RIM_COPY = 1 << 3,      
      MG_SHADOW_RIM_NONCOPY = 1 << 4,   
      // each grid-object has exactly on of these states (end)
 
      // combo-states with flags as in multi-grid (begin)
      MG_SHADOW_RIM = MG_SHADOW_RIM_COPY | MG_SHADOW_RIM_NONCOPY,    
      MG_SHADOW = MG_SHADOW_RIM | MG_SHADOW_PURE,                    
      MG_SURFACE = MG_SURFACE_PURE | MG_SURFACE_RIM,                 
      MG_ALL_BUT_SHADOW_COPY = MG_SURFACE | MG_SHADOW_RIM_NONCOPY,   
      MG_ALL = MG_SURFACE | MG_SHADOW_RIM,                           
      // combo-states with flags as in multi-grid (end)
 
      TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE = 1 << 5,  
 
      // combo-states with flags as in level-view (begin)
      SHADOW_PURE = MG_SHADOW_PURE               | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE,
      SURFACE_PURE = MG_SURFACE_PURE             | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE,
      SURFACE_RIM = MG_SURFACE_RIM               | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE,
      SHADOW_RIM_COPY = MG_SHADOW_RIM_COPY       | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE,
      SHADOW_RIM_NONCOPY = MG_SHADOW_RIM_NONCOPY | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE,
 
      SHADOW_RIM = MG_SHADOW_RIM | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE,
      SHADOW = MG_SHADOW         | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE,
      SURFACE = MG_SURFACE       | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE,
      ALL_BUT_SHADOW_COPY = MG_ALL_BUT_SHADOW_COPY | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE,
      ALL = MG_ALL               | TREAT_TOP_LVL_SHADOWS_AS_SURFACE_PURE
      // combo-states with flags as in level-view (end)
    };
    enum SurfaceConstants {…};
    typedef Flag<SurfaceConstants, byte, SS_NONE> SurfaceState;
    typedef Attachment<SurfaceState>        ASurfaceState;
 
  public:
    SurfaceView(SmartPtr<MGSubsetHandler> spMGSH,
                bool adaptiveMG = true);
 
    ~SurfaceView();
 
    inline SmartPtr<MGSubsetHandler> subset_handler();
 
    inline ConstSmartPtr<MGSubsetHandler> subset_handler() const;
 
    inline bool is_adaptive() const;
 
    template <class TGeomObj>
    inline bool is_contained(TGeomObj* obj, const GridLevel& gl,
                             SurfaceState validStates = ALL) const;
 
    template <class TElem>
    SurfaceState surface_state(TElem* elem, const GridLevel& gl) const;
 
 
    template <class TGeomObj>
    inline bool is_ghost(TGeomObj* obj) const;
 
 
    template <class TGeomObj>
    inline bool is_shadowed(TGeomObj* obj) const;
 
 
    template <class TGeomObj>
    inline bool is_shadowing(TGeomObj* obj) const;
 
    void refresh_surface_states();
 
 
    template <class TElem>
    SurfaceState surface_state(TElem* elem) const {return m_aaSurfState[elem];}
 
    template <typename TElem, typename TBaseElem>
    void collect_associated(std::vector<TBaseElem*>& vAssElem,
                TElem* elem,
                const GridLevel& gl,
                bool clearContainer = true) const;
 
  public:
    template <class TElem> class SurfaceViewElementIterator;
    template <class TElem> class ConstSurfaceViewElementIterator;
 
    template <class TElem>
    class SurfaceViewElementIterator
    {
      public:
        SurfaceViewElementIterator();
 
      private:
        typedef SurfaceViewElementIterator<TElem> this_type;
        typedef TElem* TValue;
 
        friend class SurfaceView;
        friend class ConstSurfaceViewElementIterator<TElem>;
 
        SurfaceViewElementIterator(bool start,
                                   SurfaceView* surfView,
                                   const GridLevel& gl,
                                   SurfaceState validStates,
                                   int si = -1);
 
      public:
        this_type operator ++() {increment(); return *this;}
        this_type operator ++(int unused) {this_type i = *this; increment(); return i;}
 
        bool operator ==(const this_type& iter) const {return equal(iter);}
        bool operator !=(const this_type& iter) const {return !equal(iter);}
 
        TValue operator *() {return dereference();}
 
      private:
        inline bool equal(SurfaceViewElementIterator<TElem> const& other) const;
 
        template <class TGeomObj>
        inline bool is_contained(TGeomObj* obj) const;
 
        void increment();
 
        bool increment_section();
 
        inline TValue dereference() const;
 
      private:
        SurfaceView* m_pSurfView;
        GridLevel m_gl;
        SurfaceState m_validStates;
        int m_fromSI;
        int m_toSI;
        int m_si;
        int m_topLvl;
        int m_lvl;
        typename geometry_traits<TElem>::iterator m_elemIter;
        typename geometry_traits<TElem>::iterator m_iterEndSection;
    };
    class SurfaceViewElementIterator {…};
 
    template <class TElem>
    class ConstSurfaceViewElementIterator
    {
      public:
        ConstSurfaceViewElementIterator();
 
        ConstSurfaceViewElementIterator(const SurfaceViewElementIterator<TElem>& iter);
 
      private:
        typedef ConstSurfaceViewElementIterator<TElem> this_type;
        // \todo: should return const TElem*
        typedef TElem* TValue;
        //typedef const TElem* TValue;
 
        friend class SurfaceView;
 
        ConstSurfaceViewElementIterator(bool start,
                                    const SurfaceView* surfView,
                                    const GridLevel& gl,
                                    SurfaceState validStates,
                                    int si = -1);
 
      public:
        this_type operator ++() {increment(); return *this;}
        this_type operator ++(int unused) {this_type i = *this; increment(); return i;}
 
        bool operator ==(const this_type& iter) const {return equal(iter);}
        bool operator !=(const this_type& iter) const {return !equal(iter);}
 
        TValue operator *() {return dereference();}
 
      private:
        inline bool equal(ConstSurfaceViewElementIterator<TElem> const& other) const;
 
        template <class TGeomObj>
        inline bool is_contained(TGeomObj* obj) const;
 
        void increment();
 
        bool increment_section();
 
        inline TValue dereference() const;
 
      private:
        const SurfaceView* m_pSurfView;
        GridLevel m_gl;
        SurfaceState m_validStates;
        int m_fromSI;
        int m_toSI;
        int m_si;
        int m_topLvl;
        int m_lvl;
        typename geometry_traits<TElem>::const_iterator m_elemIter;
        typename geometry_traits<TElem>::const_iterator m_iterEndSection;
      };
    class ConstSurfaceViewElementIterator {…};
 
  public:
    template <class TElem>
    struct traits{
      typedef SurfaceViewElementIterator<TElem>   iterator;
      typedef ConstSurfaceViewElementIterator<TElem>  const_iterator;
    };
    struct traits {…};
 
    template <class TElem>
    typename traits<TElem>::iterator
    begin(int si, const GridLevel& gl, SurfaceState validStates);
 
    template <class TElem>
    typename traits<TElem>::iterator
    end(int si, const GridLevel& gl, SurfaceState validStates);
 
    template <class TElem>
    typename traits<TElem>::const_iterator
    begin(int si, const GridLevel& gl, SurfaceState validStates) const;
 
    template <class TElem>
    typename traits<TElem>::const_iterator
    end(int si, const GridLevel& gl, SurfaceState validStates) const;
 
    template <class TElem>
    typename traits<TElem>::iterator
    begin(const GridLevel& gl, SurfaceState validStates);
 
    template <class TElem>
    typename traits<TElem>::iterator
    end(const GridLevel& gl, SurfaceState validStates);
 
    template <class TElem>
    typename traits<TElem>::const_iterator
    begin(const GridLevel& gl, SurfaceState validStates) const;
 
    template <class TElem>
    typename traits<TElem>::const_iterator
    end(const GridLevel& gl, SurfaceState validStates) const;
 
  private:
 
    template <class TElem>
    bool is_local_surface_view_element(TElem* elem);
 
    template <class TElem>
    void refresh_surface_states();
 
 
    template <class TElem, class TSide>
    void mark_sides_as_surface_or_shadow(TElem* elem,
                       byte surfaceState = MG_SURFACE_PURE);
 
    template <class TElem>
    void mark_shadowing(bool markSides = false);
 
    template <class TElem>
    void adjust_parallel_surface_states();
 
    template <class TElem>
    SurfaceState& surface_state(TElem* elem)    {return m_aaSurfState[elem];}
 
    template <class TElem>
    bool is_vmaster(TElem* elem) const;
 
  private:
    SmartPtr<MGSubsetHandler>     m_spMGSH;
    bool              m_adaptiveMG;
    MultiGrid*            m_pMG;
    DistributedGridManager*     m_distGridMgr;
    ASurfaceState                 m_aSurfState;
    MultiElementAttachmentAccessor<ASurfaceState> m_aaSurfState;
};
class SurfaceView {…};
 
}// end of namespace
 
 
//  include implementation
#include "surface_view_impl.hpp"
 
#endif