ls_integral.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021:  G-CSC, Goethe University Frankfurt
 * Author: Dmitry Logashenko
 * 
 * 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.
 */
 
/*
 * Quadrature of grid functions under the level-set
 */
#ifndef __H__UG__PLUGINS__LEVEL_SET_LS_INTEGRAL_H__
#define __H__UG__PLUGINS__LEVEL_SET_LS_INTEGRAL_H__
 
#include <vector>
#include <iostream>
#include <limits>
#include <cmath>
 
#include "common/common.h"
 
#include "lib_grid/tools/subset_group.h"
#include "lib_grid/algorithms/space_partitioning/lg_ntree.h"
#include "lib_disc/common/function_group.h"
#include "lib_disc/common/groups_util.h"
#include "lib_disc/spatial_disc/dom_disc_embb.h"
#include "lib_disc/domain_util.h"
#include "lib_disc/local_finite_element/local_finite_element_provider.h"
#include "lib_disc/reference_element/reference_mapping_provider.h"
#include "lib_disc/reference_element/element_list_traits.h"
#include "lib_disc/function_spaces/grid_function_user_data.h"
 
namespace ug {
namespace LevelSet {
 
template <typename TGridFunction>
class LSIntegral
{
public:
  typedef TGridFunction gf_type;
  
  static const int dim = gf_type::dim;
  
  typedef LSIntegral<gf_type> this_type;
 
  typedef typename gf_type::domain_type domain_type;
  
  typedef typename domain_type::position_accessor_type position_accessor_type;
  
  typedef typename gf_type::algebra_type algebra_type;
  
  typedef CPUAlgebra lsf_algebra_type;
  
  typedef GridFunction<domain_type, lsf_algebra_type> ls_gf_type;
  
public:
 
  LSIntegral
  (
    SmartPtr<ls_gf_type> sp_lsf 
  )
  : m_spLSF (sp_lsf)
  {}
 
  virtual ~LSIntegral () {}
  
  void on_subsets
  (
    const char * ss_names 
  )
  {
    m_ssGrp.set_subset_handler (m_sp_gf->domain()->subset_handler ());
    m_ssGrp.add (TokenizeString (ss_names));
  }
 
  void compute_for
  (
    SmartPtr<gf_type> sp_gf, 
    const char * fct_name 
  );
  
  number integral_over_subsets
  (
    const char * ss_names 
  ) const;
  
  number integral () const
  {
    return m_integral;
  }
  
private:
 
  template <typename TElem>
  void add_integrals_of_all ();
  
  struct AddIntegrals
  {
    this_type * m_pThis;
    
    AddIntegrals
    (
      this_type * pThis 
    )
    : m_pThis (pThis) {}
    
    template <typename TElem> void operator() (TElem)
    {
      m_pThis->template add_integrals_of_all<TElem> ();
    }
  };
  
private:
 
  SmartPtr<gf_type> m_sp_gf; 
  size_t m_fct; 
  
  SmartPtr<ls_gf_type> m_spLSF; 
  SubsetGroup m_ssGrp; 
  
  std::vector<number> m_ss_integral; 
  number m_integral; 
};
 
template <typename TGridFunction>
class LSHeavisideIntegral
{
public:
  typedef TGridFunction gf_type;
  
  static const int dim = gf_type::dim;
  
  typedef LSHeavisideIntegral<gf_type> this_type;
 
  typedef typename gf_type::domain_type domain_type;
  
  typedef typename domain_type::position_accessor_type position_accessor_type;
  
  typedef typename gf_type::algebra_type algebra_type;
  
  typedef CPUAlgebra lsf_algebra_type;
  
  typedef GridFunction<domain_type, lsf_algebra_type> ls_gf_type;
  
public:
 
  LSHeavisideIntegral
  (
    SmartPtr<ls_gf_type> sp_lsf 
  )
  : m_spLSF (sp_lsf)
  {}
 
  virtual ~LSHeavisideIntegral () {}
  
  void on_subsets
  (
    const char * ss_names 
  )
  {
    m_ssGrp.set_subset_handler (m_sp_gf->domain()->subset_handler ());
    m_ssGrp.add (TokenizeString (ss_names));
  }
 
  void compute_for
  (
    SmartPtr<gf_type> sp_gf, 
    const char * fct_name, 
    number limval 
  );
  
  number le_vol_over_subsets
  (
    const char * ss_names 
  ) const;
  
  number ge_vol_over_subsets
  (
    const char * ss_names 
  ) const;
  
  number le_vol () const
  {
    return m_levol;
  }
  
  number ge_vol () const
  {
    return m_gevol;
  }
  
private:
 
  template <typename TElem>
  void add_integrals_of_all ();
  
  struct AddIntegrals
  {
    this_type * m_pThis;
    
    AddIntegrals
    (
      this_type * pThis 
    )
    : m_pThis (pThis) {}
    
    template <typename TElem> void operator() (TElem)
    {
      m_pThis->template add_integrals_of_all<TElem> ();
    }
  };
  
private:
 
  SmartPtr<gf_type> m_sp_gf; 
  size_t m_fct; 
  number m_limval; 
  
  SmartPtr<ls_gf_type> m_spLSF; 
  SubsetGroup m_ssGrp; 
  
  std::vector<number> m_ss_gevol; 
  std::vector<number> m_ss_levol; 
  number m_gevol, m_levol; 
};
 
template <typename TGridFunction>
class FVLSIntegral
{
public:
  typedef TGridFunction gf_type;
  
  static const int dim = gf_type::dim;
  
  typedef FVLSIntegral<gf_type> this_type;
 
  typedef typename gf_type::domain_type domain_type;
  
  typedef typename domain_type::position_accessor_type position_accessor_type;
  
  typedef typename gf_type::algebra_type algebra_type;
  
  typedef CPUAlgebra lsf_algebra_type;
  
  typedef GridFunction<domain_type, lsf_algebra_type> ls_gf_type;
  
public:
 
  FVLSIntegral
  (
    SmartPtr<ls_gf_type> sp_lsf 
  )
  : m_spLSF (sp_lsf)
  {}
 
  virtual ~FVLSIntegral () {}
  
  void on_subsets
  (
    const char * ss_names 
  )
  {
    m_ssGrp.set_subset_handler (m_sp_gf->domain()->subset_handler ());
    m_ssGrp.add (TokenizeString (ss_names));
  }
 
  void compute_for
  (
    SmartPtr<gf_type> sp_gf, 
    const char * fct_name 
  );
  
  number integral_over_subsets
  (
    const char * ss_names 
  ) const;
  
  number integral () const
  {
    return m_integral;
  }
  
private:
 
  template <typename TElem>
  void add_integrals_of_all ();
  
  struct AddIntegrals
  {
    this_type * m_pThis;
    
    AddIntegrals
    (
      this_type * pThis 
    )
    : m_pThis (pThis) {}
    
    template <typename TElem> void operator() (TElem)
    {
      m_pThis->template add_integrals_of_all<TElem> ();
    }
  };
  
private:
 
  SmartPtr<gf_type> m_sp_gf; 
  size_t m_fct; 
  
  SmartPtr<ls_gf_type> m_spLSF; 
  SubsetGroup m_ssGrp; 
  
  std::vector<number> m_ss_integral; 
  number m_integral; 
};
 
} // namespace LevelSet
} // end namespace ug
 
#include "ls_integral_impl.h"
 
#endif // __H__UG__PLUGINS__LEVEL_SET_LS_INTEGRAL_H__
 
/* End of File */