ass_tuner.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013-2015:  G-CSC, Goethe University Frankfurt
 * Authors: Raphael Prohl, 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__SPATIAL_DISC__ASS_TUNER__
#define __H__UG__LIB_DISC__SPATIAL_DISC__ASS_TUNER__
 
#include "lib_grid/tools/bool_marker.h"
#include "lib_grid/tools/selector_grid.h"
#include "lib_disc/spatial_disc/local_to_global/local_to_global_mapper.h"
#include "lib_disc/spatial_disc/elem_disc/elem_disc_interface.h"
 
namespace ug{
 
template <typename TDomain, typename TAlgebra>
class IDomainConstraint;
 
 
enum ConstraintType
{
  CT_NONE = 0,
  CT_ASSEMBLED = 1,
  CT_MAY_DEPEND_ON_HANGING = 1 << 1,  // constraints which may depend on hanging DoFs; but NOT vice-versa
  CT_HANGING = 1 << 2,      // constraint defined for hanging DoFs
  CT_CONSTRAINTS = 1 << 3,    // any other constraint which MUST NOT depend on a hanging DoF
  CT_DIRICHLET = 1 << 4,      // Dirichlet constraints
  CT_ALL = CT_NONE | CT_ASSEMBLED | CT_MAY_DEPEND_ON_HANGING | CT_HANGING | CT_CONSTRAINTS | CT_DIRICHLET
};
enum ConstraintType {…};
 
template <typename TAlgebra>
class LocalToGlobalMapper
{
  public:
    typedef TAlgebra algebra_type;
 
    typedef typename algebra_type::matrix_type matrix_type;
 
    typedef typename algebra_type::vector_type vector_type;
 
  public:
 
    void add_local_vec_to_global(vector_type& vec, const LocalVector& lvec) const
      { AddLocalVector(vec, lvec);}
    void add_local_vec_to_global(vector_type& vec, const LocalVector& lvec) const {…}
 
    void add_local_mat_to_global(matrix_type& mat, const LocalMatrix& lmat) const
      { AddLocalMatrixToGlobal(mat, lmat);}
    void add_local_mat_to_global(matrix_type& mat, const LocalMatrix& lmat) const {…}
};
class LocalToGlobalMapper {…};
 
template <typename TAlgebra>
class AssemblingTuner
{
  public:
    typedef TAlgebra algebra_type;
 
    typedef typename algebra_type::matrix_type matrix_type;
 
    typedef typename algebra_type::vector_type vector_type;
 
    typedef typename vector_type::value_type value_type;
 
  public:
    AssemblingTuner(): m_pMapper(nullptr), m_pBoolMarker(NULL), m_pSelector(NULL),
    m_bSingleAssIndex(false), m_SingleAssIndex(0),
    m_bForceRegGrid(false), m_bModifySolutionImplemented(false),
    m_ConstraintTypesEnabled(CT_ALL), m_ElemTypesEnabled(EDT_ALL),
    m_bMatrixIsConst(false), m_bMatrixStructureIsConst(false), m_bClearOnResize(true) {}
    AssemblingTuner(): m_pMapper(nullptr), m_pBoolMarker(NULL), m_pSelector(NULL), {…}
 
    virtual ~AssemblingTuner() {}
 
    void set_mapping(ILocalToGlobalMapper<TAlgebra>* pMapper = NULL)
    {
      m_pMapper = pMapper;
    }
    void set_mapping(ILocalToGlobalMapper<TAlgebra>* pMapper = NULL) {…}
 
    void add_local_vec_to_global(vector_type& vec, const LocalVector& lvec,
                     ConstSmartPtr<DoFDistribution> dd) const
    {
      if (m_pMapper)
        m_pMapper->add_local_vec_to_global(vec, lvec, dd);
      else
        m_defaultMapper.add_local_vec_to_global(vec, lvec);
    }
    void add_local_vec_to_global(vector_type& vec, const LocalVector& lvec, {…}
 
    void add_local_mat_to_global(matrix_type& mat, const LocalMatrix& lmat,
                             ConstSmartPtr<DoFDistribution> dd) const
    {
      if (m_pMapper)
        m_pMapper->add_local_mat_to_global(mat, lmat, dd);
      else
        m_defaultMapper.add_local_mat_to_global(mat, lmat);
    }
    void add_local_mat_to_global(matrix_type& mat, const LocalMatrix& lmat, {…}
 
    void modify_LocalSol(LocalVector& vecMod, const LocalVector& lvec,
                             ConstSmartPtr<DoFDistribution> dd) const
    {
      if (m_pMapper)
        m_pMapper->modify_LocalSol(vecMod, lvec, dd);
    }
    void modify_LocalSol(LocalVector& vecMod, const LocalVector& lvec, {…}
 
    void set_marker(BoolMarker* mark = NULL){ m_pBoolMarker = mark; }
 
 
    void set_selector(Selector* sel = NULL){ m_pSelector = sel; }
 
 
    void disable_single_index_assembling() {m_bSingleAssIndex = false;}
    void set_single_index_assembling(const size_t index)
    {
      m_SingleAssIndex = index; m_bSingleAssIndex = true;
    }
    void set_single_index_assembling(const size_t index) {…}
 
    bool single_index_assembling_enabled() const {return m_bSingleAssIndex;}
 
 
    void enable_modify_solution(bool bEnable) {m_bModifySolutionImplemented = bEnable;}
 
    bool modify_solution_enabled() const {return m_bModifySolutionImplemented;}
 
 
    virtual void set_force_regular_grid(bool bForce) {m_bForceRegGrid = bForce;}
 
    bool regular_grid_forced() const {return m_bForceRegGrid;}
 
 
    void enable_constraints(int bEnableTypes) {m_ConstraintTypesEnabled = bEnableTypes;}
 
    int enabled_constraints() const {return m_ConstraintTypesEnabled;}
 
    bool constraint_type_enabled(int type) const {return (type & m_ConstraintTypesEnabled);}
 
 
    void enable_elem_discs(int bEnableTypes) {m_ElemTypesEnabled = bEnableTypes;}
 
    int enabled_elem_discs() const {return m_ElemTypesEnabled;}
 
    bool elem_disc_type_enabled(int type) const {return (type & m_ElemTypesEnabled);}
 
 
    void resize(ConstSmartPtr<DoFDistribution> dd, vector_type& vec) const;
    void resize(ConstSmartPtr<DoFDistribution> dd, matrix_type& mat) const;
 
    template <typename TElem>
    void collect_selected_elements(std::vector<TElem*>& vElem, ConstSmartPtr<DoFDistribution> dd, int si) const;
 
    bool selected_elements_used() const {return (m_pSelector != NULL);}
 
    template <typename TElem>
    bool element_used(TElem* elem) const;
 
    void set_dirichlet_row(matrix_type& mat, const DoFIndex& ind) const;
    void set_dirichlet_val(vector_type& vec, const DoFIndex& ind, const double val) const;
 
    void disable_clear_on_resize() {m_bClearOnResize = false;}
 
    void set_matrix_is_const(bool bCh) {m_bMatrixIsConst = bCh;}
 
    void set_matrix_structure_is_const(bool b) {m_bMatrixStructureIsConst = b;}
 
    bool matrix_is_const() const {return m_bMatrixIsConst;}
 
  protected:
    LocalToGlobalMapper<TAlgebra> m_defaultMapper;
 
    ILocalToGlobalMapper<TAlgebra>* m_pMapper;
 
    BoolMarker* m_pBoolMarker;
 
    Selector* m_pSelector;
 
    bool m_bSingleAssIndex;
    size_t m_SingleAssIndex;
 
    bool m_bForceRegGrid;
 
    bool m_bModifySolutionImplemented;
 
    int m_ConstraintTypesEnabled;
 
    int m_ElemTypesEnabled;
 
    bool m_bMatrixIsConst;
 
    bool m_bMatrixStructureIsConst;
 
    bool m_bClearOnResize;
};
class AssemblingTuner {…};
 
} // end namespace ug
 
#include "ass_tuner_impl.h"
 
#endif /* __H__UG__LIB_DISC__SPATIAL_DISC__ASS_TUNER__ */