convection_diffusion_fractfv1.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013-2018:  G-CSC, Goethe University Frankfurt
 * Author: Dmitry Logashenko
 * Based on the modules by 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__CONVECTION_DIFFUSION__CONVECTION_DIFFUSION_FRACT_FV1__
#define __H__UG__LIB_DISC__CONVECTION_DIFFUSION__CONVECTION_DIFFUSION_FRACT_FV1__
 
// ug4 headers
#include "lib_grid/algorithms/deg_layer_mngr.h"
#include "lib_disc/spatial_disc/disc_util/conv_shape_interface.h"
 
// plugin's internal headers
#include "../convection_diffusion_base.h"
#include "../convection_diffusion_sss.h"
 
namespace ug{
namespace ConvectionDiffusionPlugin{
 
 
template<typename TDomain>
class ConvectionDiffusionFractFV1 : public ConvectionDiffusionBase<TDomain>
{
    typedef ConvectionDiffusionFractFV1<TDomain> this_type;
 
  public:
  
    typedef ConvectionDiffusionBase<TDomain> base_type;
 
    typedef typename base_type::domain_type domain_type;
 
    typedef typename base_type::position_type position_type;
  
    static const int dim = base_type::dim;
    
    static const int low_dim = dim - 1;
 
    typedef DegeneratedLayerManager<dim> fract_manager_type;
    
  private:
  
    typedef DimFV1Geometry<low_dim, dim> TFractFVGeom;
  
    typedef typename fract_manager_type::side_type side_type;
  
    static const size_t maxFractSideCorners = fract_manager_type::maxLayerSideCorners;
  
    static const size_t _C_ = 0;
  
    typedef IConvectionShapes<dim> conv_shape_type;
  
  public:
    ConvectionDiffusionFractFV1(const char* functions, const char* subsets);
 
 
    void set_fract_manager (SmartPtr<fract_manager_type> fract_manager) {m_spFractManager = fract_manager;}
  
 
    void set_upwind (SmartPtr<conv_shape_type> shapes) {m_spConvShape = shapes;}
  
  //  set Specific parameters for low-dimensional subdomains (fractures):
 
    void set_aperture(SmartPtr<CplUserData<number, dim> > user)
    {
      m_imAperture.set_data(user);
    }
    void set_aperture(number val)
    {
      set_aperture(make_sp(new ConstUserNumber<dim>(val)));
    }
  #ifdef UG_FOR_LUA
    void set_aperture(const char* fctName)
    {
      set_aperture(LuaUserDataFactory<number, dim>::create(fctName));
    }
    void set_aperture(LuaFunctionHandle fct)
    {
      set_aperture(make_sp(new LuaUserData<number,dim>(fct)));
    }
  #endif
 
    void set_ortho_velocity(SmartPtr<CplUserData<number, dim> > user)
    {
      m_imOrthoVelocity.set_data(user);
    }
    void set_ortho_velocity(number val)
    {
      set_ortho_velocity(make_sp(new ConstUserNumber<dim>(val)));
    }
    #ifdef UG_FOR_LUA
    void set_ortho_velocity(const char* fctName)
    {
      set_ortho_velocity(LuaUserDataFactory<number,dim>::create(fctName));
    }
    void set_ortho_velocity(LuaFunctionHandle fct)
    {
      set_ortho_velocity(make_sp(new LuaUserData<number,dim>(fct)));
    }
    #endif
 
    void set_ortho_diffusion(SmartPtr<CplUserData<number, dim> > user)
    {
      m_imOrthoDiffusion.set_data(user);
    }
    void set_ortho_diffusion(number val)
    {
      set_ortho_diffusion(make_sp(new ConstUserNumber<dim>(val)));
    }
    #ifdef UG_FOR_LUA
    void set_ortho_diffusion(const char* fctName)
    {
      set_ortho_diffusion(LuaUserDataFactory<number,dim>::create(fctName));
    }
    void set_ortho_diffusion(LuaFunctionHandle fct)
    {
      set_ortho_diffusion(make_sp(new LuaUserData<number,dim>(fct)));
    }
    #endif
 
    void set_sss_manager(SmartPtr<CDSingularSourcesAndSinks<dim> > sss_mngr) {m_sss_mngr = sss_mngr;}
 
    SmartPtr<CDSingularSourcesAndSinks<dim> > sss_manager() {return m_sss_mngr;}
 
    virtual bool use_hanging() const {return false;}
  
  private:
  
    void register_all_funcs ();
    
    struct RegisterLocalDiscr
    {
      this_type * m_pThis;
    
      RegisterLocalDiscr(this_type * pThis) : m_pThis(pThis) {}
    
      template<typename TElem> void operator () (TElem &) {m_pThis->register_func<TElem> ();}
    };
 
    template <typename TElem> void register_func ();
  
  private:
  
//---- General interface assembling functions: ----
 
    virtual void prepare_setting(const std::vector<LFEID>& vLfeID, bool bNonRegularGrid);
 
 
    template <typename TElem>
    void prep_elem_loop(const ReferenceObjectID roid, const int si);
 
    template <typename TElem>
    void fsh_elem_loop ();
 
    template <typename TElem>
    void prep_elem(const LocalVector& u, GridObject* elem, const ReferenceObjectID roid, const position_type vCornerCoords[]);
 
    template <typename TElem>
    void add_jac_A_elem(LocalMatrix& J, const LocalVector& u, GridObject* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    void add_jac_M_elem(LocalMatrix& J, const LocalVector& u, GridObject* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    void add_def_A_elem(LocalVector& d, const LocalVector& u, GridObject* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    void add_def_A_expl_elem(LocalVector& d, const LocalVector& u, GridObject* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    void add_def_M_elem(LocalVector& d, const LocalVector& u, GridObject* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    void add_rhs_elem(LocalVector& d, GridObject* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    void lin_def_velocity(const LocalVector& u,
                          std::vector<std::vector<MathVector<dim> > > vvvLinDef[],
                          const size_t nip);
 
    template <typename TElem>
    void lin_def_ortho_velocity(const LocalVector& u,
                          std::vector<std::vector<number> > vvvLinDef[],
                          const size_t nip);
 
    template <typename TElem>
    void lin_def_diffusion(const LocalVector& u,
                           std::vector<std::vector<MathMatrix<dim,dim> > > vvvLinDef[],
                           const size_t nip);
 
    template <typename TElem>
    void lin_def_ortho_diffusion(const LocalVector& u,
                           std::vector<std::vector<number> > vvvLinDef[],
                           const size_t nip);
 
    template <typename TElem>
    void lin_def_flux(const LocalVector& u,
                      std::vector<std::vector<MathVector<dim> > > vvvLinDef[],
                      const size_t nip);
 
    template <typename TElem>
    void lin_def_ortho_flux(const LocalVector& u,
                      std::vector<std::vector<number> > vvvLinDef[],
                      const size_t nip);
 
    template <typename TElem>
    void lin_def_reaction(const LocalVector& u,
                          std::vector<std::vector<number> > vvvLinDef[],
                          const size_t nip);
 
    template <typename TElem>
    void lin_def_reaction_rate(const LocalVector& u,
                               std::vector<std::vector<number> > vvvLinDef[],
                               const size_t nip);
 
    template <typename TElem>
    void lin_def_source(const LocalVector& u,
                        std::vector<std::vector<number> > vvvLinDef[],
                        const size_t nip);
 
    template <typename TElem>
    void lin_def_vector_source(const LocalVector& u,
                               std::vector<std::vector<MathVector<dim> > > vvvLinDef[],
                               const size_t nip);
 
    template <typename TElem>
    void lin_def_ortho_vector_source(const LocalVector& u,
                               std::vector<std::vector<number> > vvvLinDef[],
                               const size_t nip);
 
    template <typename TElem>
    void lin_def_mass_scale(const LocalVector& u,
                            std::vector<std::vector<number> > vvvLinDef[],
                            const size_t nip);
 
    template <typename TElem>
    void lin_def_mass(const LocalVector& u,
                      std::vector<std::vector<number> > vvvLinDef[],
                      const size_t nip);
 
//---- Assembling functions for fractures: ----
 
    template <typename TElem>
    inline void fract_add_jac_A_elem(LocalMatrix& J, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    inline void fract_bulk_add_jac_A_elem(LocalMatrix& J, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    inline void fract_add_def_A_elem(LocalVector& d, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    inline void fract_bulk_add_def_A_elem(LocalVector& d, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    inline void fract_add_def_A_expl_elem(LocalVector& d, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    inline void fract_bulk_add_def_A_expl_elem(LocalVector& d, const LocalVector& u, TElem* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    inline void fract_add_rhs_elem(LocalVector& b, TElem* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    inline void fract_bulk_add_rhs_elem(LocalVector& b, TElem* elem, const position_type vCornerCoords[]);
 
    template <typename TElem>
    inline void add_sss_def_elem(LocalVector& d, const LocalVector& u, TElem* pElem, size_t co, number flux);
  
    template <typename TElem>
    inline void add_sss_jac_elem(LocalMatrix& J, const LocalVector& u, TElem* pElem, size_t co, number flux);
  
  private:
    const conv_shape_type& get_updated_conv_shapes (bool computeDeriv);
    
  protected:
  
//  Standard parameters of the convection-diffusion plugin
    using base_type::m_imDiffusion;
    using base_type::m_imVelocity;
    using base_type::m_imFlux;
    using base_type::m_imSource;
    using base_type::m_imSourceExpl;
    using base_type::m_imVectorSource;
    using base_type::m_imReactionRate;
    using base_type::m_imReactionRateExpl;
    using base_type::m_imReaction;
    using base_type::m_imReactionExpl;
    using base_type::m_imMassScale;
    using base_type::m_imMass;
 
    using base_type::m_exGrad;
    using base_type::m_exValue;
  
//  Specific parameters for low-dimensional subdomains (fractures):
    DataImport<number, dim> m_imAperture; 
    DataImport<number, dim> m_imOrthoDiffusion; 
    DataImport<number, dim> m_imOrthoVelocity; 
    DataImport<number, dim> m_imOrthoFlux; 
    DataImport<number, dim> m_imOrthoVectorSource; 
 
    private:
 
//  singular sources and sinks manager
    SmartPtr<CDSingularSourcesAndSinks<dim> > m_sss_mngr;   
    
  protected:
  
//  Parameters of the discretization:
    SmartPtr<fract_manager_type> m_spFractManager; 
    SmartPtr<conv_shape_type> m_spConvShape; 
 
  private:
  
//  Temporary data used in the assembling
  TFractFVGeom * m_pFractGeo; 
  size_t m_numFractCo; 
  side_type * m_innerFractSide; 
  side_type * m_outerFractSide; 
  size_t m_innerFractSideIdx; 
  size_t m_outerFractSideIdx; 
  size_t m_innerSideCo[maxFractSideCorners]; 
  size_t m_outerSideCo[maxFractSideCorners]; 
  size_t m_assCo [2 * maxFractSideCorners]; 
};
 
} // end ConvectionDiffusionPlugin
} // end namespace ug
 
#endif /*__H__UG__LIB_DISC__CONVECTION_DIFFUSION__CONVECTION_DIFFUSION_FRACT_FV1__*/
 
/* End of File */