convection_diffusion_sss.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019:  G-CSC, Goethe University Frankfurt
 * Author: Dmitry Logashenko / Michael Lampe
 * 
 * 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.
 */
 
/*
 * Singular (point and line) sources and sinks in ConvectionDiffusion.
 */
#ifndef __H__UG__PLUGINS__CD__SINGULAR_SOURCES_AND_SINKS__
#define __H__UG__PLUGINS__CD__SINGULAR_SOURCES_AND_SINKS__
 
#include <vector>
 
// ug4 headers
#include "lib_disc/spatial_disc/disc_util/fv1_sss.h"
#include "lib_disc/spatial_disc/user_data/user_data.h"
 
#ifdef UG_FOR_LUA
#include "bindings/lua/lua_user_data.h"
#endif
 
namespace ug {
namespace ConvectionDiffusionPlugin {
 
template <int dim>
class cd_sss_data
{
public:
  typedef SmartPtr<CplUserData<number, dim> > user_data_type;
protected:
  //MathVector<1> m_values;
  number m_values;
  
  user_data_type m_spData; 
  
public:
  
  cd_sss_data () {m_values = 0;}
  
  number flux () {return m_values ;}
  
  void compute
  (
    const MathVector<dim>& x, 
    number time, 
    int si 
  )
  {
    if (m_spData.valid ())
      (* m_spData) (m_values, x, time, si);
  }
  void compute {…}
  
  void set (number flux)
  {
    m_values = flux;
    m_spData = SPNULL;
  }
  void set (number flux) {…}
  
  void set (user_data_type spData)
  {
    m_spData = spData;
  }
  void set (user_data_type spData) {…}
 
#ifdef UG_FOR_LUA
  void set (LuaFunctionHandle func)
  { m_spData = make_sp (new LuaUserData<number, dim> (func)); }
#endif
 
};
class cd_sss_data {…};
 
class point_sss_marker
{
  GridObject * m_elem; 
  size_t m_co; 
  
public:
 
  point_sss_marker () : m_elem (NULL), m_co (0) {};
  
  void init () {m_elem = NULL; m_co = 0;}
  
  bool marked_for (GridObject * elem, size_t co)
  {
    if (m_elem == NULL)
    {
      m_elem = elem; m_co = co;
      return true;
    }
    return m_elem == elem && m_co == co;
  }
  bool marked_for (GridObject * elem, size_t co) {…}
};
class point_sss_marker {…};
 
class line_sss_marker
{
// All the members are used in the fractures only!
 
  struct t_fract_elem
  {
    IVertexGroup * fract_face;
    size_t fract_co;
    
    t_fract_elem (IVertexGroup * face, size_t co) : fract_face (face), fract_co (co) {};
  };
  struct t_fract_elem {…};
  
  std::vector<t_fract_elem> m_intersections;
  
public:
 
  line_sss_marker () {};
  
  void init () {m_intersections.clear ();}
  
  bool marked_for (IVertexGroup * elem, size_t co)
  {
  //  is the fracture already processed?
    for (size_t i = 0; i < m_intersections.size (); i++)
    {
    //  check if we have already registered this mark
      t_fract_elem& intersection = m_intersections[i];
      if (intersection.fract_face == elem)
        return intersection.fract_co == co;
      
    //  check if a different corner is meant (i.e. this is the same fracture)
      Vertex * vrt = elem->vertex (co);
      for (size_t j = 0; j < intersection.fract_face->num_vertices (); j++)
        if (vrt == intersection.fract_face->vertex (j))
          return false; // in this fracture, we use a different corner
    }
  // no, register this fracture, too
    m_intersections.push_back (t_fract_elem (elem, co));
    return true;
  }
  bool marked_for (IVertexGroup * elem, size_t co) {…}
};
class line_sss_marker {…};
 
template <int dim> class cd_point_sss_data : public cd_sss_data<dim>, public point_sss_marker {};
template <int dim> class cd_line_sss_data : public cd_sss_data<dim>, public line_sss_marker {};
template <int dim>
class CDSingularSourcesAndSinks
  : public FVSingularSourcesAndSinks<dim, cd_point_sss_data<dim>, cd_line_sss_data<dim> >
{
public:
  typedef cd_point_sss_data<dim> user_data_type;
};
class CDSingularSourcesAndSinks {…};
 
} // namespace ConvectionDiffusionPlugin
} // end namespace ug
 
#endif // __H__UG__PLUGINS__CD__SINGULAR_SOURCES_AND_SINKS__
 
/* End of File */