integrate_option.h

Go to the documentation of this file.

#ifndef _RHEO_INTEGRATE_OPTION_H
#define _RHEO_INTEGRATE_OPTION_H
//
// This file is part of Rheolef.
//
// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
//
// Rheolef is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Rheolef 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rheolef; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
// 
// =========================================================================
 
namespace rheolef {
} // namespace rheolef
 
#include "rheolef/smart_pointer.h"
#include "rheolef/reference_element.h"
#include "rheolef/point.h"
 
namespace rheolef { 
 
// [verbatim_integrate_option]
class integrate_option {
public:
// typedefs:
 
  typedef size_t size_type;
 
  typedef enum {
        gauss           = 0,
        gauss_lobatto   = 1,
        gauss_radau     = 2,
        middle_edge     = 3,
        superconvergent = 4,
        equispaced      = 5,
        max_family      = 6
  } family_type; // update also family_name[] in quatrature.cc
 
  static const size_type   unset_order    = std::numeric_limits<size_type>::max();
  static const size_type   default_order  = unset_order;
  static const family_type default_family = gauss;
 
// allocators:
 
  integrate_option(
        family_type ft = default_family,
        size_type   k  = default_order);
 
  integrate_option (const std::string& name);
  integrate_option (const integrate_option& iopt);
  integrate_option& operator= (const integrate_option& iopt);
 
// accessors & modifiers:
 
  std::string    name() const;
  size_t         get_order() const;
  family_type    get_family() const;
  std::string    get_family_name() const;
  void reset (const std::string& name);
  void set_order (size_t r);
  void set_family (family_type type);
  void set_family (std::string name);
 
// data:
 
  bool invert, ignore_sys_coord, lump;
 
// [verbatim_integrate_option]
// internals:
 
  template<class T>
  static T epsilon() { return 1e3*std::numeric_limits<T>::epsilon(); }
 
protected:
  family_type   _family;
  size_t        _order;
public:
  mutable bool  _is_on_interface, _is_inside_on_local_sides; // internals
// [verbatim_integrate_option_cont]
};
// [verbatim_integrate_option_cont]
 
// backward compatibility:
using quadrature_option      = integrate_option;
using quadrature_option_type = integrate_option;
using integrate_option_type  = integrate_option;
 
// ------------------------------------------------------------
// inlined
// ------------------------------------------------------------
inline 
integrate_option::integrate_option (family_type ft, size_type k)
 : invert (false),
   ignore_sys_coord (false),
   lump   (false),
   _family(ft),
   _order(k),
   _is_on_interface(false),
   _is_inside_on_local_sides(false)
{
}
inline
integrate_option::integrate_option (const std::string& name)
 : invert (false),
   ignore_sys_coord (false),
   lump   (false),
   _family(default_family),
   _order(default_order),
   _is_on_interface(false),
   _is_inside_on_local_sides(false)
{
  reset (name);
}
inline
integrate_option::integrate_option (const integrate_option& iopt)
 : invert (iopt.invert),
   ignore_sys_coord (iopt.ignore_sys_coord),
   lump   (iopt.lump),
   _family(iopt._family),
   _order(iopt._order),
   _is_on_interface(iopt._is_on_interface),
   _is_inside_on_local_sides(iopt._is_inside_on_local_sides)
{
}
inline
integrate_option&
integrate_option::operator= (const integrate_option& iopt)
{
  invert           = iopt.invert;
  ignore_sys_coord = iopt.ignore_sys_coord;
  lump             = iopt.lump;
  _family          = iopt._family;
  _order           = iopt._order;
  _is_on_interface          = iopt._is_on_interface;
  _is_inside_on_local_sides = iopt._is_inside_on_local_sides;
  return *this;
}
inline
integrate_option::size_type
integrate_option::get_order () const
{
    return _order;
}
inline
integrate_option::family_type
integrate_option::get_family () const
{
    return _family;
}
inline
void
integrate_option::set_order (size_t r)
{
    _order = r;
}
inline
void
integrate_option::set_family (family_type ft)
{
    _family = ft;
}
 
}// namespace rheolef
#endif // _RHEO_INTEGRATE_OPTION_H