grid_function.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2015:  G-CSC, Goethe University Frankfurt
 * Author: Andreas Vogel
 * 
 * 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_DISC__FUNCTION_SPACE__GRID_FUNCTION__
#define __H__UG__LIB_DISC__FUNCTION_SPACE__GRID_FUNCTION__
 
#include "lib_disc/local_finite_element/local_finite_element_id.h"
#include "lib_disc/dof_manager/function_pattern.h"
#include "lib_disc/common/local_algebra.h"
#include "approximation_space.h"
#include "lib_disc/dof_manager/dof_distribution.h"
 
#ifdef UG_PARALLEL
  #include "lib_algebra/parallelization/parallel_storage_type.h"
#endif
 
namespace ug{
 
 
class IGridFunction
{
  public:
    virtual ~IGridFunction()  {}
 
 
    virtual void permute_values(const std::vector<size_t>& vIndNew) = 0;
 
 
    virtual void copy_values(const std::vector<std::pair<size_t, size_t> >& vIndexMap,
                             bool bDisjunct = false) = 0;
 
 
    virtual void resize_values(size_t s, number defaultValue = 0.0) = 0;
};
class IGridFunction {…};
 
template <typename TDomain> class AdaptionSurfaceGridFunction;
 
 
template <typename TDomain, typename TAlgebra>
class GridFunction
  :   public TAlgebra::vector_type,
      public IGridFunction,
      public DoFDistributionInfoProvider
{
  public:
    typedef GridFunction<TDomain, TAlgebra> this_type;
 
    typedef ApproximationSpace<TDomain> approximation_space_type;
 
    typedef TDomain domain_type;
 
    static const int dim = domain_type::dim;
 
    typedef TAlgebra algebra_type;
 
    typedef typename algebra_type::vector_type vector_type;
 
  public:
    template <typename TElem>
    struct traits
    {
      typedef typename DoFDistribution::traits<TElem>::grid_object grid_object;
      typedef typename DoFDistribution::traits<TElem>::iterator iterator;
      typedef typename DoFDistribution::traits<TElem>::const_iterator const_iterator;
    };
    struct traits {…};
 
    template <int dim>
    struct dim_traits
    {
      typedef typename DoFDistribution::dim_traits<dim>::grid_base_object grid_base_object;
      typedef typename DoFDistribution::dim_traits<dim>::iterator iterator;
      typedef typename DoFDistribution::dim_traits<dim>::const_iterator const_iterator;
    };
    struct dim_traits {…};
 
    typedef typename dim_traits<dim>::grid_base_object element_type;
    typedef typename dim_traits<dim>::iterator element_iterator;
    typedef typename dim_traits<dim>::const_iterator const_element_iterator;
 
    typedef typename dim_traits<dim-1>::grid_base_object side_type;
    typedef typename dim_traits<dim-1>::iterator side_iterator;
    typedef typename dim_traits<dim-1>::const_iterator const_side_iterator;
 
  protected:
    virtual this_type* virtual_clone() const {return new this_type(*this);}
 
    virtual this_type* virtual_clone_without_values() const;
 
  public:
    GridFunction(SmartPtr<ApproximationSpace<TDomain> > spApproxSpace,
                 SmartPtr<DoFDistribution> spDoFDistr, bool bManage = true);
 
    GridFunction(SmartPtr<ApproximationSpace<TDomain> > spApproxSpace, bool bManage = true);
 
    GridFunction(SmartPtr<ApproximationSpace<TDomain> > spApproxSpace, int level, bool bManage = true);
 
    GridFunction(SmartPtr<ApproximationSpace<TDomain> > spApproxSpace, const GridLevel& gl, bool bManage = true);
 
  protected:
    void check_algebra();
 
    void init(SmartPtr<ApproximationSpace<TDomain> > spApproxSpace,
              SmartPtr<DoFDistribution> spDoFDistr, bool bManage);
 
  public:
    GridFunction(const this_type& v) : IGridFunction(v) {assign(v);}
 
    this_type& operator=(const this_type& v) 
    { 
      if (this!= &v) assign(v); 
      return *this;
    }
    this_type& operator=(const this_type& v)  {…}
 
    this_type& operator=(number d) 
    {
      vector_type::operator=(d); 
      return *this;
    }
    this_type& operator=(number d)  {…}
 
    SmartPtr<this_type> clone() const {return SmartPtr<this_type>(this->virtual_clone());}
 
 
    SmartPtr<this_type> clone_without_values() const {return SmartPtr<this_type>(this->virtual_clone_without_values());}
 
    virtual void clone_pattern(const this_type& v);
 
    void assign(const this_type& v);
 
    void assign(const vector_type& v);
 
    virtual ~GridFunction() {m_spDD->unmanage_grid_function(*this);}
 
  public:
    SmartPtr<DoFDistribution> dof_distribution() {return m_spDD;}
    SmartPtr<DoFDistribution> dd() {return dof_distribution();}
 
    ConstSmartPtr<DoFDistribution> dof_distribution() const {return m_spDD;}
    ConstSmartPtr<DoFDistribution> dd() const {return dof_distribution();}
 
    const GridLevel& grid_level() const {return m_spDD->grid_level();}
 
    template <typename TElem>
    typename traits<TElem>::const_iterator begin() const
      {return m_spDD->template begin<TElem>();}
    typename traits<TElem>::const_iterator begin() const {…}
 
    template <typename TElem>
    typename traits<TElem>::const_iterator
    begin(SurfaceView::SurfaceConstants validStates) const
      {return m_spDD->template begin<TElem>(validStates);}
    begin(SurfaceView::SurfaceConstants validStates) const {…}
 
    template <typename TElem>
    typename traits<TElem>::const_iterator end() const
      {return m_spDD->template end<TElem>();}
    typename traits<TElem>::const_iterator end() const {…}
 
    template <typename TElem>
    typename traits<TElem>::const_iterator
    end(SurfaceView::SurfaceConstants validStates) const
      {return m_spDD->template end<TElem>(validStates);}
    end(SurfaceView::SurfaceConstants validStates) const {…}
 
    template <typename TElem>
    typename traits<TElem>::const_iterator begin(int si) const
      {return m_spDD->template begin<TElem>(si);}
    typename traits<TElem>::const_iterator begin(int si) const {…}
 
    template <typename TElem>
    typename traits<TElem>::const_iterator
    begin(int si, SurfaceView::SurfaceConstants validStates) const
      {return m_spDD->template begin<TElem>(si, validStates);}
    begin(int si, SurfaceView::SurfaceConstants validStates) const {…}
 
    template <typename TElem>
    typename traits<TElem>::const_iterator end(int si) const
      {return m_spDD->template end<TElem>(si);}
    typename traits<TElem>::const_iterator end(int si) const {…}
 
    template <typename TElem>
    typename traits<TElem>::const_iterator
    end(int si, SurfaceView::SurfaceConstants validStates) const
      {return m_spDD->template end<TElem>(si, validStates);}
    end(int si, SurfaceView::SurfaceConstants validStates) const {…}
 
    template <typename TElem, typename TBaseElem>
    void collect_associated(std::vector<TBaseElem*>& vAssElem,
                TElem* elem, bool clearContainer = true) const{
        m_spDD->collect_associated(vAssElem, elem, clearContainer);
    }
    void collect_associated(std::vector<TBaseElem*>& vAssElem, {…}
 
    template <class TGeomObj>
    bool is_contained(TGeomObj* obj) const{
      return m_spDD->is_contained(obj);
    }
    bool is_contained(TGeomObj* obj) const {…}
 
  public:
    size_t num_indices() const {return m_spDD->num_indices();}
 
    size_t num_indices(int si) const {return m_spDD->num_indices(si);}
 
    size_t num_dofs() const {return num_dofs(DoFCount::ALL_FCT);}
    size_t num_dofs(int fct) const {return num_dofs(fct, DoFCount::ALL_SUBSET);}
    size_t num_dofs(int fct, int si) const;
 
    template <typename TElem>
    void indices(TElem* elem, LocalIndices& ind, bool bHang = false) const
      {m_spDD->indices(elem, ind, bHang);}
    void indices(TElem* elem, LocalIndices& ind, bool bHang = false) const {…}
 
    template <typename TElem>
    size_t dof_indices(TElem* elem, size_t fct, std::vector<DoFIndex>& ind, bool bHang = false, bool bClear = true) const
      {return m_spDD->dof_indices(elem, fct, ind, bHang, bClear);}
    size_t dof_indices(TElem* elem, size_t fct, std::vector<DoFIndex>& ind, bool bHang = false, bool bClear = true) const {…}
 
    template <typename TElem>
    size_t inner_dof_indices(TElem* elem, size_t fct, std::vector<DoFIndex>& ind, bool bClear = true) const
      {return m_spDD->inner_dof_indices(elem, fct, ind, bClear);}
    size_t inner_dof_indices(TElem* elem, size_t fct, std::vector<DoFIndex>& ind, bool bClear = true) const {…}
 
    template <typename TElem>
    size_t algebra_indices(TElem* elem, std::vector<size_t>& ind, bool bClear = true) const
      {return m_spDD->algebra_indices(elem, ind, bClear);}
    size_t algebra_indices(TElem* elem, std::vector<size_t>& ind, bool bClear = true) const {…}
 
    template <typename TElem>
    size_t inner_algebra_indices(TElem* elem, std::vector<size_t>& ind, bool bClear = true) const
      {return m_spDD->inner_algebra_indices(elem, ind, bClear);}
    size_t inner_algebra_indices(TElem* elem, std::vector<size_t>& ind, bool bClear = true) const {…}
 
  public:
    SmartPtr<TDomain> domain() {return m_spApproxSpace->domain();}
 
    ConstSmartPtr<TDomain> domain() const {return m_spApproxSpace->domain();}
 
    SmartPtr<ApproximationSpace<TDomain> > approx_space() {return m_spApproxSpace;}
 
    ConstSmartPtr<ApproximationSpace<TDomain> > approx_space() const {return m_spApproxSpace;}
 
  public:
    bool managed() const {return m_bManaged;}
    
 
    bool redistribution_enabled() const {return m_bRedistribute;}
 
 
    void enable_redistribution(bool enable) {m_bRedistribute = enable;}
 
  // for debugging purposes. To be removed.
    void SetConsistentStorageType()
    {
#ifdef UG_PARALLEL
      this->set_storage_type(PST_CONSISTENT);
#endif
    }
    void SetConsistentStorageType() {…}
 
    virtual void resize_values(size_t s, number defaultValue = 0.0);
 
    virtual void permute_values(const std::vector<size_t>& vIndNew);
 
    virtual void copy_values(const std::vector<std::pair<size_t, size_t> >& vIndexMap,
                             bool bDisjunct = false);
 
 
  protected:
    MessageHub::SPCallbackId m_spGridAdaptionCallbackID;
    MessageHub::SPCallbackId m_spGridDistributionCallbackID;
 
    void register_at_adaption_msg_hub();
 
    void grid_changed_callback(const GridMessage_Adaption& msg);
 
    void grid_distribution_callback(const GridMessage_Distribution& msg);
 
    SmartPtr<AdaptionSurfaceGridFunction<TDomain> > m_spAdaptGridFct;
 
  protected:
    SmartPtr<DoFDistribution> m_spDD;
 
    SmartPtr<ApproximationSpace<TDomain> > m_spApproxSpace;
 
    bool m_bManaged;
 
 
    bool m_bRedistribute;
 
    uint m_preDistStorageType;
};
class GridFunction {…};
 
template <typename TDomain, typename TAlgebra>
const typename TAlgebra::vector_type &getVector(const GridFunction<TDomain, TAlgebra> &t)
{
  return *dynamic_cast<const GridFunction<TDomain, TAlgebra>*>(&t);
}
const typename TAlgebra::vector_type &getVector(const GridFunction<TDomain, TAlgebra> &t) {…}
 
 
template <typename TDomain, typename TAlgebra>
inline std::ostream& operator<< (std::ostream& outStream, const GridFunction<TDomain, TAlgebra>& v)
{
  outStream << *dynamic_cast<const GridFunction<TDomain, TAlgebra>*>(&v);
  return outStream;
}
inline std::ostream& operator<< (std::ostream& outStream, const GridFunction<TDomain, TAlgebra>& v) {…}
 
} // end namespace ug
 
// include implementation
#include "grid_function_impl.h"
 
#endif /* __H__UG__LIB_DISC__FUNCTION_SPACE__GRID_FUNCTION__ */