refiner_interface.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011-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__REFINER_INTERFACE__
#define __H__UG__REFINER_INTERFACE__
 
#include <string>
#include "projectors/refinement_projector.h"
 
namespace ug
{
 
//  Make sure not to use refinement marks with a value of 128 or higher! Those
 
enum RefinementMark{
  RM_NONE = 0,          
  RM_CLOSURE = 1,         
  RM_COPY = RM_CLOSURE,     
  RM_ANISOTROPIC = RM_CLOSURE,  
  RM_LOCAL = 1 << 1,        
  RM_FULL = 1 << 2,       
  RM_REFINE = RM_FULL,      
  RM_COARSEN = 1 << 3,      
  RM_DUMMY = 1 << 4,        
  RM_MAX              
};
enum RefinementMark {…};
 
 
class IRefiner
{
  public:
    IRefiner(SPRefinementProjector projector = SPNULL) :
      m_msgIdAdaption(-1), m_projector(projector),
      m_adaptionIsActive(false), m_debuggingEnabled(false)  {}
    IRefiner(SPRefinementProjector projector = SPNULL) : {…}
 
    virtual ~IRefiner() {}
 
    void set_projector(SPRefinementProjector projector)
      {m_projector = projector;}
    void set_projector(SPRefinementProjector projector) {…}
 
    SPRefinementProjector projector()
      {return m_projector;}
    SPRefinementProjector projector() {…}
 
    virtual Grid* get_associated_grid() = 0;
 
    virtual Grid* grid() = 0;
 
    virtual void clear_marks()  {}
 
 
    virtual bool adaptivity_supported() const = 0;
 
 
    virtual bool coarsening_supported() const = 0;
 
    virtual bool local_marks_supported() const  {return false;}
 
 
    virtual bool mark(Vertex* v, RefinementMark refMark = RM_REFINE)  {return false;}
    virtual bool mark(Edge* e, RefinementMark refMark = RM_REFINE)    {return false;}
    virtual bool mark(Face* f, RefinementMark refMark = RM_REFINE)    {return false;}
    virtual bool mark(Volume* v, RefinementMark refMark = RM_REFINE)  {return false;}
 
    virtual bool mark(GridObject* o, RefinementMark refMark = RM_REFINE);
 
 
    template <class TElem>
    inline bool marked_closure(TElem* elem) const
    {
      return (get_mark(elem) == RM_CLOSURE);
    }
    inline bool marked_closure(TElem* elem) const {…}
 
    template <class TElem>
    inline bool marked_local(TElem* elem) const
    {
      return (get_mark(elem) == RM_LOCAL);
    }
    inline bool marked_local(TElem* elem) const {…}
 
    template <class TElem>
    inline bool marked_full(TElem* elem) const
    {
      return (get_mark(elem) == RM_FULL);
    }
    inline bool marked_full(TElem* elem) const {…}
 
 
    virtual void mark_local(Face* e, int mark)    {UG_THROW("mark_local not supported by this refiner!");}
    virtual void mark_local(Volume* e, int mark)  {UG_THROW("mark_local not supported by this refiner!");}
 
    virtual int get_local_mark(Face* e) const {return 0;}
    virtual int get_local_mark(Volume* e) const {return 0;}
 
    int get_local_edge_mark(Face* f, Edge* e) const;
    
 
    int get_local_edge_mark(Volume* vol, Edge* e) const;
 
 
    int get_local_face_mark(Volume* vol, Face* f) const;
 
 
 
    void mark_neighborhood(size_t numIterations)
    {mark_neighborhood(numIterations, RM_NONE, false);}
    void mark_neighborhood(size_t numIterations) {…}
 
 
    virtual void mark_neighborhood(
            size_t numIterations,
            RefinementMark refMark,
            bool sideNbrsOnly)      {}
    virtual void mark_neighborhood( {…}
 
 
    virtual RefinementMark get_mark(Vertex* v) const  {return RM_REFINE;}
    virtual RefinementMark get_mark(Edge* e) const    {return RM_REFINE;}
    virtual RefinementMark get_mark(Face* f) const    {return RM_REFINE;}
    virtual RefinementMark get_mark(Volume* v) const  {return RM_REFINE;}
 
    virtual RefinementMark get_mark(GridObject* o) const;
 
 
    template <class TIterator>
    void mark(const TIterator& iterBegin, const TIterator& iterEnd,
          RefinementMark refMark = RM_REFINE)
      {
        TIterator iter = iterBegin;
        while(iter != iterEnd){
          mark(*iter, refMark);
          ++iter;
        }
      }
    void mark(const TIterator& iterBegin, const TIterator& iterEnd, {…}
 
 
 
    void adaption_begins();
    void adaption_ends();
 
    void refine();
 
 
    bool coarsen();
 
 
    size_t num_marked_edges(std::vector<int>& numMarkedEdgesOut);
    size_t num_marked_faces(std::vector<int>& numMarkedFacesOut);
    size_t num_marked_volumes(std::vector<int>& numMarkedVolsOut);
    size_t num_marked_elements(std::vector<int>& numMarkedElemsOut);
 
    size_t num_marked_edges()   {std::vector<int> t; return num_marked_edges(t);}
    size_t num_marked_faces()   {std::vector<int> t; return num_marked_faces(t);}
    size_t num_marked_volumes()   {std::vector<int> t; return num_marked_volumes(t);}
    size_t num_marked_elements()  {std::vector<int> t; return num_marked_elements(t);}
 
 
    virtual bool save_marks_to_file(const char* filename) = 0;
 
 
    void set_adjusted_marks_debug_filename(const char* filename);
 
    void enable_debugging(bool enable)  {m_debuggingEnabled = enable;}
    bool debugging_enabled() const    {return m_debuggingEnabled;}
 
  protected:
 
    void set_message_hub(SPMessageHub msgHub);
 
    virtual void perform_refinement() = 0;
 
 
    virtual bool perform_coarsening()   {return false;}
 
    virtual void num_marked_edges_local(std::vector<int>& numMarkedEdgesOut) = 0;
    virtual void num_marked_faces_local(std::vector<int>& numMarkedFacesOut) = 0;
    virtual void num_marked_volumes_local(std::vector<int>& numMarkedVolsOut) = 0;
 
  protected:
    SPMessageHub      m_messageHub;
    int           m_msgIdAdaption;
    SPRefinementProjector m_projector;
    bool          m_adaptionIsActive;
    bool          m_debuggingEnabled;
    std::string       m_adjustedMarksDebugFilename;
};
class IRefiner {…};
 
 
}// end of namespace
 
#endif