periodic_boundary_manager.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2015:  G-CSC, Goethe University Frankfurt
 * Author: Martin Scherer
 * 
 * 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 PERIODIC_IDENTIFIER_H_
#define PERIODIC_IDENTIFIER_H_
 
#include "lib_grid/grid/grid.h"
#include "lib_grid/multi_grid.h"
#include "lib_grid/grid/grid_base_objects.h"
 
#include <set>
 
namespace ug {
 
 
class IIdentifier {
public:
  virtual ~IIdentifier() {}
  virtual bool match(Vertex*, Vertex*) = 0;
  virtual bool match(Edge*, Edge*) = 0;
  virtual bool match(Face*, Face*) = 0;
  virtual bool match(Volume*, Volume*) {UG_THROW("not impled, because volume identification is not supported.")}
};
class IIdentifier {…};
 
 
template<class TPosAA> class ParallelShiftIdentifier: public IIdentifier {
public:
  virtual bool match(Vertex* v1, Vertex* v2) {return match_impl(v1, v2);}
  virtual bool match(Edge* e1, Edge* e2) {return match_impl(e1, e2);}
  virtual bool match(Face* f1, Face* f2) {return match_impl(f1, f2);}
 
  virtual ~ParallelShiftIdentifier() {}
  typedef typename TPosAA::ValueType AttachmentType;
  ParallelShiftIdentifier(TPosAA& aa) : m_aaPos(aa) {}
  void set_shift(AttachmentType& shift) {m_shift = shift; VecScale(m_shift_opposite, m_shift, -1);}
protected:
  AttachmentType m_shift;
  AttachmentType m_shift_opposite;
  TPosAA& m_aaPos;
  template<class TElem> bool match_impl(TElem*, TElem*) const;
};
template<class TPosAA> class ParallelShiftIdentifier: public IIdentifier {…};
 
 
//template<class TPosAA, int dim> class TransformationBasedIdentifier : public IIdentifier {
//public:
//  TransformationBasedIdentifier(TPosAA& aa) : m_aaPos(aa) {}
//  void setTransformation(MathMatrix<dim,dim>& T) {this->T = T;}
//
//  virtual bool match(Vertex*, Vertex*);
//  virtual bool match(Edge*, Edge*);
//  virtual bool match(Face*, Face*);
//protected:
//  MathMatrix<dim,dim> T;
//  TPosAA& m_aaPos;
//};
 
 
class PeriodicBoundaryManager : public GridObserver {
public:
 
  template <class TElem, class Container = std::vector<TElem*> >
  class Group
  {
    public:
      typedef Container SlaveContainer;
      typedef typename Container::iterator SlaveIterator;
      // the set typedefs are used to check for periodicity after identification
      typedef typename std::pair<TElem*, TElem*> master_slave_pair;
      typedef typename std::set<master_slave_pair> unique_pairs;
 
      Group(TElem* m = NULL) : m_master(m) {}
 
      void add_slave(TElem* e) {
        UG_ASSERT(e, "add_slave: slave not valid");
        UG_ASSERT(e != m_master, "element already master!");
        m_slaves.push_back(e); }
      void add_slave(TElem* e) {…}
 
      Container& get_slaves() { return m_slaves; }
      TElem* m_master;
 
    protected:
      Container m_slaves;
  };
  class Group {…};
 
  enum PeriodicStatus {
    P_SLAVE, P_SLAVE_MASTER_UNKNOWN, P_MASTER, P_NOT_PERIODIC
  };
  enum PeriodicStatus {…};
 
  PeriodicBoundaryManager();
  ~PeriodicBoundaryManager();
 
  // sets grid and inits group info attachment accessors
  void set_grid(Grid* g);
  Grid* get_grid() const;
 
  // sets the subset handler to use for element lookup
//  void set_subset_handler(ISubsetHandler* sh);
 
 
  template <class TElem> void identify(TElem* e1, TElem* e2, IIdentifier& i);
 
  template <class TElem> bool is_periodic(TElem* e) const;
  template <class TElem> bool is_slave(TElem*) const;
  template <class TElem> bool is_master(TElem*) const;
  template <class TElem> TElem* master(TElem* e) const;
  template <class TElem> typename Group<TElem>::SlaveContainer* slaves(
      TElem* e) const;
  template <class TElem> void print_identification() const;
 
 
  virtual void grid_to_be_destroyed(Grid* grid);
  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 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);
 
  bool check_periodicity(const GridObjectCollection& goc1,
                const GridObjectCollection& goc2,
                ISubsetHandler* sh = NULL);
 
  void validity_check();
 
//  void set_identifier(SmartPtr<IIdentifier> i, size_t si);
 
protected:
  // no copy construction allowed
  PeriodicBoundaryManager(const PeriodicBoundaryManager&) {}
 
  MultiGrid* m_pGrid;
 
//  ISubsetHandler* m_pSH;
 
 
//  std::vector<SmartPtr<IIdentifier> > m_vIdentifier;
 
  Grid::AttachmentAccessor<Vertex, Attachment<Group<Vertex>* > > m_aaGroupVRT;
  Grid::AttachmentAccessor<Edge, Attachment<Group<Edge>* > > m_aaGroupEDG;
  Grid::AttachmentAccessor<Face, Attachment<Group<Face>* > > m_aaGroupFCE;
 
  Grid::AttachmentAccessor<Vertex, Attachment<PeriodicStatus> > m_aaPeriodicStatusVRT;
  Grid::AttachmentAccessor<Edge, Attachment<PeriodicStatus> > m_aaPeriodicStatusEDG;
  Grid::AttachmentAccessor<Face, Attachment<PeriodicStatus> > m_aaPeriodicStatusFCE;
 
  template <class TElem> void make_slave(Group<TElem>* g, TElem* e);
  template <class TElem> bool remove_slave(TElem* slave);
 
  // make e a master of g
  template <class TElem> void make_master(Group<TElem>* g, TElem* e);
 
  template <class TElem> void merge_groups(Group<TElem>* g0, Group<TElem>* g1);
 
  // get typed attachment accessor for group attachment
  template <class TElem>
  const Grid::AttachmentAccessor<TElem, Attachment<Group<TElem>* > >&
  get_group_accessor() const;
 
  template <class TElem>
  Grid::AttachmentAccessor<TElem, Attachment<Group<TElem>* > >&
  get_group_accessor();
 
  // get typed attachment accessor for periodic status attachment
  template <class TElem>
  const Grid::AttachmentAccessor<TElem, Attachment<PeriodicStatus> >&
  get_periodic_status_accessor() const;
 
  template <class TElem>
  Grid::AttachmentAccessor<TElem, Attachment<PeriodicStatus> >&
  get_periodic_status_accessor();
 
  // gets group of given element e
  template <class TElem> Group<TElem>* group(TElem* e) const;
  // set group attachment to element e
  template <class TElem> void set_group(Group<TElem>* g, TElem* e);
  template <class TElem> void remove_group(Group<TElem>* g);
 
  template <class TElem>
  void replace_parent(TElem* e, TElem* pParent);
 
  template <class TElem, class TParent>
  void handle_creation(TElem* e, TParent* pParent);
 
  template <class TElem>
  void handle_deletion(TElem* e, TElem* replacedBy);
 
  template <class TElem>
  void handle_creation_cast_wrapper(TElem* e, GridObject* parent, bool replacesParent);
 
  template <class TElem, class TIterator>
  void check_elements_periodicity(
      TIterator begin,
      TIterator end,
      typename Group<TElem>::unique_pairs& s,
      ISubsetHandler* sh);
 
  template <class TElem>
  void validity_check();
 
};
class PeriodicBoundaryManager : public GridObserver {…};
 
 
template <class TElem,class TAttachment>
class PeriodicAttachmentAccessor
{
  public:
    typedef typename TAttachment::ValueType ValueType;
    typedef typename attachment_value_traits<ValueType>::reference RefType;
    typedef typename attachment_value_traits<ValueType>::const_reference ConstRefType;
 
    PeriodicAttachmentAccessor() : m_pbm(NULL)  {}
 
    PeriodicAttachmentAccessor(Grid& g, TAttachment& a) : m_pbm(NULL)
    {
      access(g, a);
    }
    PeriodicAttachmentAccessor(Grid& g, TAttachment& a) : m_pbm(NULL) {…}
 
    PeriodicAttachmentAccessor(PeriodicBoundaryManager& pbm) : m_pbm(&pbm) {}
 
    bool access(Grid& g, TAttachment& a)
    {
      if (!(m_pbm)) m_pbm = g.periodic_boundary_manager();
      return m_aa.access(g, a);
    }
    bool access(Grid& g, TAttachment& a) {…}
 
    RefType operator[](TElem* e)  {
      if(m_pbm && m_pbm->is_slave(e))
        return m_aa[m_pbm->master(e)];
      return m_aa[e];
    }
    RefType operator[](TElem* e) {…}
 
    ConstRefType operator[](TElem* e) const {
      if(m_pbm && m_pbm->is_slave(e))
        return m_aa[m_pbm->master(e)];
      return m_aa[e];
    }
    ConstRefType operator[](TElem* e) const  {…}
 
  private:
    Grid::AttachmentAccessor<TElem, TAttachment>  m_aa;
    PeriodicBoundaryManager* m_pbm;
};
class PeriodicAttachmentAccessor {…};
 
 
template <class TDomain>
void IdentifySubsets(TDomain& dom, int sInd1, int sInd2);
 
template <class TDomain>
void IdentifySubsets(TDomain& dom, const char* sName1, const char* sName2);
 
} // end of namespace ug
 
// include implementation
#include "./periodic_boundary_manager_impl.hpp"
 
#endif /* PERIODIC_IDENTIFIER_H_ */