Loading...
Searching...
No Matches
space.h
Go to the documentation of this file.
#ifndef _RHEOLEF_SPACE_H
#define _RHEOLEF_SPACE_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
//
// =========================================================================
// AUTHORS: Pierre.Saramito@imag.fr
// DATE: 14 december 2010
namespace rheolef {
} // namespace rheolef
#include "rheolef/geo.h"
#include "rheolef/geo_domain.h"
#include "rheolef/space_constitution.h"
namespace rheolef {
// forward declarations:
template <class T, class M> class field_basic;
template <class T, class M> class space_mult_list;
template <class T, class M> class space_component;
template <class T, class M> class space_component_const;
// =====================================================================
// a dof = a degree-of-freedom
// = space_pair
// = pair (bool is_blocked ; size_t dis_iub)
// =====================================================================
// TODO: compact the bool as an extra bit in size_type ?
struct space_pair_type {
typedef disarray<size_t>::size_type size_type;
space_pair_type () : _blk(false), _dis_iub (std::numeric_limits<size_type>::max()) {}
space_pair_type (bool blk, size_type dis_iub) : _blk(blk), _dis_iub(dis_iub) {}
bool is_blocked() const { return _blk; }
size_type dis_iub() const { return _dis_iub; }
void set_dis_iub (size_type dis_iub) { _dis_iub = dis_iub; }
void set_blocked (bool blk) { _blk = blk; }
friend std::ostream& operator<< (std::ostream& os, const space_pair_type& x) {
return os << "{" << x.is_blocked() << "," << x.dis_iub() << "}"; }
template<class Archive>
void serialize (Archive& ar, const unsigned int version) { ar & _blk; ar & _dis_iub; }
protected:
bool _blk;
size_type _dis_iub;
};
} // namespace rheolef
#ifdef _RHEOLEF_HAVE_MPI
// =====================================================================
// Some serializable types, like geo_element, have a fixed amount of data stored at fixed field positions.
// When this is the case, boost::mpi can optimize their serialization and transmission to avoid extraneous
// copy operations.
// To enable this optimization, we specialize the type trait is_mpi_datatype, e.g.:
namespace boost {
namespace mpi {
template <> struct is_mpi_datatype<rheolef::space_pair_type> : mpl::true_ { };
} // namespace mpi
} // namespace boost
#endif // _RHEOLEF_HAVE_MPI
namespace rheolef {
// =====================================================================
// 1) representation: space_base_rep and space_rep
// =====================================================================
template <class T, class M>
class space_base_rep {
public:
// typedefs:
typedef typename space_pair_type::size_type size_type;
typedef typename space_constant::valued_type valued_type;
// allocators:
space_base_rep ();
space_base_rep (
const geo_basic<T,M>& omega,
std::string approx,
std::string prod_valued);
space_base_rep (
const geo_basic<T,M>& omega,
const basis_basic<T>& b);
space_base_rep (const space_constitution<T,M>& constit);
space_base_rep (const space_mult_list<T,M>&);
virtual ~space_base_rep () {}
// accessors:
const distributor& ownership() const { return _idof2blk_dis_iub.ownership(); }
size_type ndof() const { return ownership().size(); }
size_type dis_ndof() const { return ownership().dis_size(); }
const communicator& comm() const { return ownership().comm(); }
const space_constitution<T,M>& get_constitution() const { return _constit; }
const geo_basic<T,M>& get_geo() const { return _constit.get_geo(); }
const basis_basic<T>& get_basis() const { return _constit.get_basis(); }
valued_type valued_tag() const { return _constit.valued_tag(); }
const std::string& valued() const { return _constit.valued(); }
size_type size() const { return _constit.size(); }
space_component<T,M> operator[] (size_type i_comp);
space_component_const<T,M> operator[] (size_type i_comp) const;
std::string name() const;
void block (const domain_indirect_basic<M>& dom) { no_freeze_check(); _constit.block (dom); }
void unblock(const domain_indirect_basic<M>& dom) { no_freeze_check(); _constit.unblock(dom);}
void block_n (const domain_indirect_basic<M>& dom) { no_freeze_check(); _constit.block_n (dom); }
void unblock_n(const domain_indirect_basic<M>& dom) { no_freeze_check(); _constit.unblock_n(dom);}
bool is_blocked (size_type idof) const { freeze_check(); return _idof2blk_dis_iub [idof].is_blocked(); }
size_type dis_iub (size_type idof) const { freeze_check(); return _idof2blk_dis_iub [idof].dis_iub(); }
const point_basic<T>& xdof (size_type idof) const { return _xdof [idof]; }
const disarray<point_basic<T>,M >& get_xdofs() const { return _xdof; }
const distributor& iu_ownership() const { freeze_guard(); return _iu_ownership; }
const distributor& ib_ownership() const { freeze_guard(); return _ib_ownership; }
void dis_idof (const geo_element& K, std::vector<size_type>& dis_idof) const;
// TODO: merge all V.xxx_momentum: the return type can be computed from Function::result_type
template <class Function>
T momentum (const Function& f, size_type idof) const { return f (xdof(idof)); }
template <class Function>
point_basic<T> vector_momentum (const Function& f, size_type idof) const { return f (xdof(idof)); }
template <class Function>
tensor_basic<T> tensor_momentum (const Function& f, size_type idof) const { return f (xdof(idof)); }
disarray<size_type, M> build_dom_dis_idof2bgd_dis_idof (
const space_base_rep<T,M>& Wh, const std::string& dom_name) const;
disarray<size_type, M> build_dom_dis_idof2bgd_dis_idof (
const space_base_rep<T,M>& Wh, const geo_basic<T,M>& bgd_gamma) const;
// comparator:
bool operator== (const space_base_rep<T,M>& V2) const {
return _constit.operator==(V2._constit); } // TODO: compare also blocked/unknown sizes:
friend bool are_compatible (const space_base_rep<T,M>& V1, const space_base_rep<T,M>& V2) {
return V1._constit.operator==(V2._constit); }
// for lazy (un-assembled) on geo_domains:
void parent_subgeo_owner_check() const {
check_macro (_parent_subgeo_owner_initialized, "parent_subgeo_owner_guard() should be called before local accessors");
}
bool parent_subgeo_owner_guard() const;
size_type get_parent_subgeo_owner (size_type dis_idof) const;
template <class Set>
void get_parent_subgeo_owner_dis_indexes (Set& ext_dis_idofs) const;
protected:
template <class T1, class M1> friend class field_basic;
// internal:
void init_xdof();
void freeze_guard() const {
if (_have_freezed) return;
_have_freezed = true;
freeze_body();
}
void freeze_check() const {
check_macro (_have_freezed, "space should be freezed before calling local accessors");
}
void no_freeze_check() const {
check_macro (!_have_freezed, "freezed space cannot accept new (un)blocked domains");
}
void base_freeze_body() const;
virtual void freeze_body() const { return base_freeze_body(); }
// data: lazy initialization (on demand only), thus most are mutable
space_constitution<T,M> _constit;
disarray<point_basic<T>,M > _xdof; // nodal approx only
mutable bool _have_freezed;
mutable disarray<space_pair_type,M> _idof2blk_dis_iub; // pair (is_blocked ; dis_iu_or_ib); use ownership
mutable disarray<int,M> _has_nt_basis; // whether block_n or block_t : for piola ; use ownership
mutable disarray<point_basic<T>,M> _normal; // when block_{nt} ; use ownership
mutable distributor _iu_ownership; // unknown values distribution
mutable distributor _ib_ownership; // blocked values distribution
mutable bool _parent_subgeo_owner_initialized;
mutable bool _parent_subgeo_owner_reattribution_required;
mutable disarray<size_type,M> _parent_subgeo_owner;
};
template <class T, class M>
template <class Set>
void
space_base_rep<T,M>::get_parent_subgeo_owner_dis_indexes (Set& ext_dis_idofs) const
{
parent_subgeo_owner_guard();
if (! _parent_subgeo_owner_reattribution_required) {
ext_dis_idofs = Set();
return;
}
_parent_subgeo_owner.get_dis_indexes (ext_dis_idofs);
}
// ---------------------------------------------------------------------
// space_rep
// ---------------------------------------------------------------------
template <class T, class M> class space_rep {};
template <class T>
class space_rep<T,sequential> : public space_base_rep<T,sequential> {
public:
// typedefs:
typedef space_base_rep<T,sequential> base;
typedef typename base::size_type size_type;
// allocators:
space_rep ( const geo_basic<T,sequential>& omega,
std::string approx,
std::string prod_valued);
space_rep ( const geo_basic<T,sequential>& omega,
const basis_basic<T>& b);
space_rep (const space_constitution<T,sequential>& constit);
space_rep (const space_mult_list<T,sequential>&);
~space_rep () {}
// for compatibility with the distributed interface:
bool dis_is_blocked (size_type dis_idof) const { return base::is_blocked(dis_idof); }
size_type dis_idof2dis_iub (size_type dis_idof) const { return base::dis_iub (dis_idof); }
const distributor& ios_ownership() const { return base::ownership(); }
size_type idof2ios_dis_idof (size_type idof) const { return idof; }
size_type ios_idof2dis_idof (size_type ios_idof) const { return ios_idof; }
// for compatibility with the distributed case:
const std::set<size_type>& ext_iu_set() const;
const std::set<size_type>& ext_ib_set() const;
};
// ---------------------------------------------------------------------
#ifdef _RHEOLEF_HAVE_MPI
template <class T>
class space_rep<T,distributed> : public space_base_rep<T,distributed> {
public:
// typedefs:
typedef space_base_rep<T,distributed> base;
typedef typename base::size_type size_type;
// allocators:
space_rep ( const geo_basic<T,distributed>& omega,
std::string approx,
std::string prod_valued);
space_rep ( const geo_basic<T,distributed>& omega,
const basis_basic<T>& b);
space_rep (const space_constitution<T,distributed>& constit);
space_rep (const space_mult_list<T,distributed>&);
~space_rep () {}
// accessors:
const communicator& comm() const { return base::comm(); }
bool dis_is_blocked (size_type dis_idof) const;
size_type dis_idof2dis_iub (size_type dis_idof) const;
const distributor& ios_ownership() const { return _ios_idof2dis_idof.ownership(); }
size_type idof2ios_dis_idof (size_type idof) const { base::freeze_guard(); return _idof2ios_dis_idof [idof]; }
size_type ios_idof2dis_idof (size_type ios_idof) const { base::freeze_guard(); return _ios_idof2dis_idof [ios_idof]; }
const std::set<size_type>& ext_iu_set() const { return _ext_iu_set; }
const std::set<size_type>& ext_ib_set() const { return _ext_ib_set; }
protected:
template <class T1, class M1> friend class field_basic;
// internal procedures:
void freeze_body() const;
void append_external_dof (const geo_basic<T,distributed>& dom, std::set<size_type>& ext_dof_set) const;
// data:
disarray<size_type,distributed> _idof2ios_dis_idof; // permut to/from ios dof numbering (before geo part), for i/o
disarray<size_type,distributed> _ios_idof2dis_idof;
// mutable data, affected by freeze_*()const:
mutable std::set<size_type> _ext_iu_set; // external dofs used by field::dis_dof
mutable std::set<size_type> _ext_ib_set;
};
#endif // _RHEOLEF_HAVE_MPI
// ====================================================================
// 2) wrapper class: seq & mpi specializations
// ====================================================================
template <class T, class M = rheo_default_memory_model>
class space_basic {
public:
};
// [verbatim_space]
typedef space_basic<Float> space;
// [verbatim_space]
// ---------------------------------------------------------------------
// [verbatim_space_basic]
template <class T>
class space_basic<T,sequential> : public smart_pointer<space_rep<T,sequential> > {
public:
// typedefs:
typedef space_rep<T,sequential> rep;
typedef smart_pointer<rep> base;
typedef typename rep::size_type size_type;
typedef typename rep::valued_type valued_type;
// allocators:
space_basic (const geo_basic<T,sequential>& omega = (geo_basic<T,sequential>()),
std::string approx = "",
std::string prod_valued = "scalar");
space_basic (const geo_basic<T,sequential>& omega,
const basis_basic<T>& b);
space_basic (const space_mult_list<T,sequential>& expr);
space_basic (const space_constitution<T,sequential>& constit);
static space_basic<T,sequential> real();
// accessors:
void block (std::string dom_name);
void unblock(std::string dom_name);
void block (const domain_indirect_basic<sequential>& dom);
void unblock(const domain_indirect_basic<sequential>& dom);
void block_n (std::string dom_name);
void unblock_n(std::string dom_name);
void block_n (const domain_indirect_basic<sequential>& dom);
void unblock_n(const domain_indirect_basic<sequential>& dom);
const distributor& ownership() const;
const communicator& comm() const;
size_type ndof() const;
size_type dis_ndof() const;
const geo_basic<T,sequential>& get_geo() const;
const basis_basic<T>& get_basis() const;
size_type size() const;
valued_type valued_tag() const;
const std::string& valued() const;
space_component<T,sequential> operator[] (size_type i_comp);
space_component_const<T,sequential> operator[] (size_type i_comp) const;
const space_constitution<T,sequential>& get_constitution() const;
size_type degree() const;
std::string get_approx() const;
std::string name() const;
void dis_idof (const geo_element& K, std::vector<size_type>& dis_idof) const;
const distributor& iu_ownership() const;
const distributor& ib_ownership() const;
bool is_blocked (size_type idof) const;
size_type dis_iub (size_type idof) const;
bool dis_is_blocked (size_type dis_idof) const;
size_type dis_idof2dis_iub (size_type dis_idof) const;
const distributor& ios_ownership() const;
size_type idof2ios_dis_idof (size_type idof) const;
size_type ios_idof2dis_idof (size_type ios_idof) const;
const point_basic<T>& xdof (size_type idof) const;
const disarray<point_basic<T>,sequential>& get_xdofs() const;
template <class Function>
T momentum (const Function& f, size_type idof) const;
template <class Function>
point_basic<T> vector_momentum (const Function& f, size_type idof) const;
template <class Function>
tensor_basic<T> tensor_momentum (const Function& f, size_type idof) const;
disarray<size_type, sequential> build_dom_dis_idof2bgd_dis_idof (
const space_basic<T,sequential>& Wh, const std::string& dom_name) const;
disarray<size_type, sequential> build_dom_dis_idof2bgd_dis_idof (
const space_basic<T,sequential>& Wh, const geo_basic<T,sequential>& bgd_gamma) const;
const std::set<size_type>& ext_iu_set() const { return base::data().ext_iu_set(); }
const std::set<size_type>& ext_ib_set() const { return base::data().ext_ib_set(); }
// comparator:
bool operator== (const space_basic<T,sequential>& V2) const { return base::data().operator==(V2.data()); }
bool operator!= (const space_basic<T,sequential>& V2) const { return ! operator== (V2); }
friend bool are_compatible (const space_basic<T,sequential>& V1, const space_basic<T,sequential>& V2) {
return are_compatible (V1.data(), V2.data()); }
// for lazy (un-assembled) on geo_domains:
template <class Set>
void get_parent_subgeo_owner_dis_indexes (Set& ext_dis_idofs) const
{ base::data().get_parent_subgeo_owner_dis_indexes (ext_dis_idofs); }
size_type get_parent_subgeo_owner (size_type dis_idof) const
{ return base::data().get_parent_subgeo_owner (dis_idof); }
};
// [verbatim_space_basic]
template<class T>
inline
space_basic<T,sequential>::space_basic (
const geo_basic<T,sequential>& omega,
std::string approx,
std::string prod_valued)
: base (new_macro(rep(omega, approx, prod_valued)))
{
}
template<class T>
inline
space_basic<T,sequential>::space_basic (
const geo_basic<T,sequential>& omega,
const basis_basic<T>& b)
: base (new_macro(rep(omega, b)))
{
}
template<class T>
inline
space_basic<T,sequential>::space_basic (
const space_constitution<T,sequential>& constit)
: base (new_macro(rep(constit)))
{
}
template<class T>
inline
space_basic<T,sequential>::space_basic (const space_mult_list<T,sequential>& expr)
: base (new_macro(rep(expr)))
{
}
template<class T>
inline
const distributor&
space_basic<T,sequential>::ownership() const
{
return base::data().ownership();
}
template<class T>
inline
const distributor&
space_basic<T,sequential>::ios_ownership() const
{
return base::data().ios_ownership();
}
template<class T>
inline
const communicator&
space_basic<T,sequential>::comm() const
{
return base::data().comm();
}
template<class T>
inline
typename space_basic<T,sequential>::size_type
space_basic<T,sequential>::ndof() const
{
return base::data().ndof();
}
template<class T>
inline
typename space_basic<T,sequential>::size_type
space_basic<T,sequential>::dis_ndof() const
{
return base::data().dis_ndof();
}
template<class T>
inline
const geo_basic<T,sequential>&
space_basic<T,sequential>::get_geo() const
{
return base::data().get_geo();
}
template<class T>
inline
const basis_basic<T>&
space_basic<T,sequential>::get_basis() const
{
return base::data().get_basis();
}
template<class T>
inline
const space_constitution<T,sequential>&
space_basic<T,sequential>::get_constitution() const
{
return base::data().get_constitution();
}
template<class T>
inline
typename space_basic<T,sequential>::size_type
space_basic<T,sequential>::size() const
{
return base::data().size();
}
template<class T>
inline
const std::string&
space_basic<T,sequential>::valued() const
{
return base::data().valued();
}
template<class T>
inline
typename space_basic<T,sequential>::valued_type
space_basic<T,sequential>::valued_tag() const
{
return base::data().valued_tag();
}
template<class T>
inline
space_component<T,sequential>
space_basic<T,sequential>::operator[] (size_type i_comp)
{
return base::data().operator[] (i_comp);
}
template<class T>
inline
space_component_const<T,sequential>
space_basic<T,sequential>::operator[] (size_type i_comp) const
{
return base::data().operator[] (i_comp);
}
template<class T>
inline
typename space_basic<T,sequential>::size_type
space_basic<T,sequential>::degree() const
{
return get_basis().degree();
}
template<class T>
inline
std::string
space_basic<T,sequential>::get_approx() const
{
return get_basis().name();
}
template<class T>
inline
std::string
space_basic<T,sequential>::name() const
{
return base::data().name();
}
template<class T>
inline
void
space_basic<T,sequential>::dis_idof (const geo_element& K, std::vector<size_type>& dis_idof) const
{
return base::data().dis_idof (K, dis_idof);
}
template<class T>
inline
typename space_basic<T,sequential>::size_type
space_basic<T,sequential>::idof2ios_dis_idof (size_type idof) const
{
return base::data().idof2ios_dis_idof (idof);
}
template<class T>
inline
typename space_basic<T,sequential>::size_type
space_basic<T,sequential>::ios_idof2dis_idof (size_type ios_idof) const
{
return base::data().ios_idof2dis_idof (ios_idof);
}
template<class T>
inline
const distributor&
space_basic<T,sequential>::iu_ownership() const
{
return base::data().iu_ownership();
}
template<class T>
inline
const distributor&
space_basic<T,sequential>::ib_ownership() const
{
return base::data().ib_ownership();
}
template<class T>
inline
bool
space_basic<T,sequential>::is_blocked (size_type idof) const
{
return base::data().is_blocked (idof);
}
template<class T>
inline
typename space_basic<T,sequential>::size_type
space_basic<T,sequential>::dis_iub (size_type idof) const
{
return base::data().dis_iub (idof);
}
template<class T>
inline
bool
space_basic<T,sequential>::dis_is_blocked (size_type dis_idof) const
{
return base::data().dis_is_blocked (dis_idof);
}
template<class T>
inline
typename space_basic<T,sequential>::size_type
space_basic<T,sequential>::dis_idof2dis_iub (size_type dis_idof) const
{
return base::data().dis_idof2dis_iub (dis_idof);
}
template<class T>
inline
void
space_basic<T,sequential>::block (std::string dom_name)
{
return base::data().block (get_geo().get_domain_indirect(dom_name));
}
template<class T>
inline
void
space_basic<T,sequential>::unblock (std::string dom_name)
{
return base::data().unblock (get_geo().get_domain_indirect(dom_name));
}
template<class T>
inline
void
space_basic<T,sequential>::block (const domain_indirect_basic<sequential>& dom)
{
return base::data().block (dom);
}
template<class T>
inline
void
space_basic<T,sequential>::unblock (const domain_indirect_basic<sequential>& dom)
{
return base::data().unblock (dom);
}
template<class T>
inline
void
space_basic<T,sequential>::block_n (std::string dom_name)
{
return base::data().block_n (get_geo().get_domain_indirect(dom_name));
}
template<class T>
inline
void
space_basic<T,sequential>::unblock_n (std::string dom_name)
{
return base::data().unblock_n (get_geo().get_domain_indirect(dom_name));
}
template<class T>
inline
void
space_basic<T,sequential>::block_n (const domain_indirect_basic<sequential>& dom)
{
return base::data().block_n (dom);
}
template<class T>
inline
void
space_basic<T,sequential>::unblock_n (const domain_indirect_basic<sequential>& dom)
{
return base::data().unblock_n (dom);
}
template<class T>
inline
const point_basic<T>&
space_basic<T,sequential>::xdof (size_type idof) const
{
return base::data().xdof (idof);
}
template<class T>
inline
const disarray<point_basic<T>,sequential>&
space_basic<T,sequential>::get_xdofs() const
{
return base::data().get_xdofs();
}
template<class T>
template <class Function>
inline
T
space_basic<T,sequential>::momentum (const Function& f, size_type idof) const
{
return base::data().momentum (f, idof);
}
template<class T>
template <class Function>
inline
point_basic<T>
space_basic<T,sequential>::vector_momentum (const Function& f, size_type idof) const
{
return base::data().vector_momentum (f, idof);
}
template<class T>
template <class Function>
tensor_basic<T>
space_basic<T,sequential>::tensor_momentum (const Function& f, size_type idof) const
{
return base::data().tensor_momentum (f, idof);
}
// ---------------------------------------------------------------------
#ifdef _RHEOLEF_HAVE_MPI
//<verbatim:
template <class T>
class space_basic<T,distributed> : public smart_pointer<space_rep<T,distributed> > {
public:
// typedefs:
typedef space_rep<T,distributed> rep;
typedef smart_pointer<rep> base;
typedef typename rep::size_type size_type;
typedef typename rep::valued_type valued_type;
// allocators:
space_basic (const geo_basic<T,distributed>& omega = (geo_basic<T,distributed>()),
std::string approx = "",
std::string prod_valued = "scalar");
space_basic (const geo_basic<T,distributed>& omega,
const basis_basic<T>& b);
space_basic (const space_mult_list<T,distributed>&);
space_basic (const space_constitution<T,distributed>& constit);
static space_basic<T,distributed> real();
// accessors:
void block (std::string dom_name);
void unblock(std::string dom_name);
void block (const domain_indirect_basic<distributed>& dom);
void unblock(const domain_indirect_basic<distributed>& dom);
void block_n (std::string dom_name);
void unblock_n(std::string dom_name);
void block_n (const domain_indirect_basic<distributed>& dom);
void unblock_n(const domain_indirect_basic<distributed>& dom);
const distributor& ownership() const;
const communicator& comm() const;
size_type ndof() const;
size_type dis_ndof() const;
const geo_basic<T,distributed>& get_geo() const;
const basis_basic<T>& get_basis() const;
size_type size() const;
valued_type valued_tag() const;
const std::string& valued() const;
space_component<T,distributed> operator[] (size_type i_comp);
space_component_const<T,distributed> operator[] (size_type i_comp) const;
const space_constitution<T,distributed>& get_constitution() const;
size_type degree() const;
std::string get_approx() const;
std::string name() const;
void dis_idof (const geo_element& K, std::vector<size_type>& dis_idof) const;
const distributor& iu_ownership() const;
const distributor& ib_ownership() const;
bool is_blocked (size_type idof) const;
size_type dis_iub (size_type idof) const;
bool dis_is_blocked (size_type dis_idof) const;
size_type dis_idof2dis_iub (size_type dis_idof) const;
const distributor& ios_ownership() const;
size_type idof2ios_dis_idof (size_type idof) const;
size_type ios_idof2dis_idof (size_type ios_idof) const;
const point_basic<T>& xdof (size_type idof) const;
const disarray<point_basic<T>,distributed>& get_xdofs() const;
template <class Function>
T momentum (const Function& f, size_type idof) const;
template <class Function>
point_basic<T> vector_momentum (const Function& f, size_type idof) const;
template <class Function>
tensor_basic<T> tensor_momentum (const Function& f, size_type idof) const;
disarray<size_type, distributed> build_dom_dis_idof2bgd_dis_idof (
const space_basic<T,distributed>& Wh, const std::string& dom_name) const;
disarray<size_type, distributed> build_dom_dis_idof2bgd_dis_idof (
const space_basic<T,distributed>& Wh, const geo_basic<T,distributed>& bgd_gamma) const;
const std::set<size_type>& ext_iu_set() const { return base::data().ext_iu_set(); }
const std::set<size_type>& ext_ib_set() const { return base::data().ext_ib_set(); }
// comparator:
bool operator== (const space_basic<T,distributed>& V2) const { return base::data().operator==(V2.data()); }
bool operator!= (const space_basic<T,distributed>& V2) const { return ! operator== (V2); }
friend bool are_compatible (const space_basic<T,distributed>& V1, const space_basic<T,distributed>& V2) {
return are_compatible (V1.data(), V2.data()); }
// for lazy (un-assembled) on geo_domains:
template <class Set>
void get_parent_subgeo_owner_dis_indexes (Set& ext_dis_idofs) const
{ base::data().get_parent_subgeo_owner_dis_indexes (ext_dis_idofs); }
size_type get_parent_subgeo_owner (size_type dis_idof) const
{ return base::data().get_parent_subgeo_owner (dis_idof); }
};
//>verbatim:
template<class T>
inline
space_basic<T,distributed>::space_basic (
const geo_basic<T,distributed>& omega,
std::string approx,
std::string prod_valued)
: base (new_macro(rep(omega, approx, prod_valued)))
{
}
template<class T>
inline
space_basic<T,distributed>::space_basic (
const geo_basic<T,distributed>& omega,
const basis_basic<T>& b)
: base (new_macro(rep(omega, b)))
{
}
template<class T>
inline
space_basic<T,distributed>::space_basic (
const space_constitution<T,distributed>& constit)
: base (new_macro(rep(constit)))
{
}
template<class T>
inline
space_basic<T,distributed>::space_basic (const space_mult_list<T,distributed>& expr)
: base (new_macro(rep(expr)))
{
}
template<class T>
inline
const distributor&
space_basic<T,distributed>::ownership() const
{
return base::data().ownership();
}
template<class T>
inline
const distributor&
space_basic<T,distributed>::ios_ownership() const
{
return base::data().ios_ownership();
}
template<class T>
inline
const communicator&
space_basic<T,distributed>::comm() const
{
return base::data().comm();
}
template<class T>
inline
typename space_basic<T,distributed>::size_type
space_basic<T,distributed>::ndof() const
{
return base::data().ndof();
}
template<class T>
inline
typename space_basic<T,distributed>::size_type
space_basic<T,distributed>::dis_ndof() const
{
return base::data().dis_ndof();
}
template<class T>
inline
const geo_basic<T,distributed>&
space_basic<T,distributed>::get_geo() const
{
return base::data().get_geo();
}
template<class T>
inline
const basis_basic<T>&
space_basic<T,distributed>::get_basis() const
{
return base::data().get_basis();
}
template<class T>
inline
const space_constitution<T,distributed>&
space_basic<T,distributed>::get_constitution() const
{
return base::data().get_constitution();
}
template<class T>
inline
typename space_basic<T,distributed>::size_type
space_basic<T,distributed>::size() const
{
return base::data().size();
}
template<class T>
inline
const std::string&
space_basic<T,distributed>::valued() const
{
return base::data().valued();
}
template<class T>
inline
typename space_basic<T,distributed>::valued_type
space_basic<T,distributed>::valued_tag() const
{
return base::data().valued_tag();
}
template<class T>
inline
space_component<T,distributed>
space_basic<T,distributed>::operator[] (size_type i_comp)
{
return base::data().operator[] (i_comp);
}
template<class T>
inline
space_component_const<T,distributed>
space_basic<T,distributed>::operator[] (size_type i_comp) const
{
return base::data().operator[] (i_comp);
}
template<class T>
inline
typename space_basic<T,distributed>::size_type
space_basic<T,distributed>::degree() const
{
return get_basis().degree();
}
template<class T>
inline
std::string
space_basic<T,distributed>::get_approx() const
{
return get_basis().name();
}
template<class T>
inline
std::string
space_basic<T,distributed>::name() const
{
return base::data().name();
}
template<class T>
inline
void
space_basic<T,distributed>::dis_idof (const geo_element& K, std::vector<size_type>& dis_idof) const
{
return base::data().dis_idof (K, dis_idof);
}
template<class T>
inline
typename space_basic<T,distributed>::size_type
space_basic<T,distributed>::idof2ios_dis_idof (size_type idof) const
{
return base::data().idof2ios_dis_idof (idof);
}
template<class T>
inline
typename space_basic<T,distributed>::size_type
space_basic<T,distributed>::ios_idof2dis_idof (size_type ios_idof) const
{
return base::data().ios_idof2dis_idof (ios_idof);
}
template<class T>
inline
const distributor&
space_basic<T,distributed>::iu_ownership() const
{
return base::data().iu_ownership();
}
template<class T>
inline
const distributor&
space_basic<T,distributed>::ib_ownership() const
{
return base::data().ib_ownership();
}
template<class T>
inline
bool
space_basic<T,distributed>::is_blocked (size_type idof) const
{
return base::data().is_blocked (idof);
}
template<class T>
inline
typename space_basic<T,distributed>::size_type
space_basic<T,distributed>::dis_iub (size_type idof) const
{
return base::data().dis_iub (idof);
}
template<class T>
inline
bool
space_basic<T,distributed>::dis_is_blocked (size_type dis_idof) const
{
return base::data().dis_is_blocked (dis_idof);
}
template<class T>
inline
typename space_basic<T,distributed>::size_type
space_basic<T,distributed>::dis_idof2dis_iub (size_type dis_idof) const
{
return base::data().dis_idof2dis_iub (dis_idof);
}
template<class T>
inline
void
space_basic<T,distributed>::block (std::string dom_name)
{
return base::data().block (get_geo().get_domain_indirect(dom_name));
}
template<class T>
inline
void
space_basic<T,distributed>::unblock (std::string dom_name)
{
return base::data().unblock (get_geo().get_domain_indirect(dom_name));
}
template<class T>
inline
void
space_basic<T,distributed>::block (const domain_indirect_basic<distributed>& dom)
{
base::data().block (dom);
}
template<class T>
inline
void
space_basic<T,distributed>::unblock (const domain_indirect_basic<distributed>& dom)
{
base::data().unblock (dom);
}
template<class T>
inline
void
space_basic<T,distributed>::block_n (std::string dom_name)
{
return base::data().block_n (get_geo().get_domain_indirect(dom_name));
}
template<class T>
inline
void
space_basic<T,distributed>::unblock_n (std::string dom_name)
{
return base::data().unblock_n (get_geo().get_domain_indirect(dom_name));
}
template<class T>
inline
void
space_basic<T,distributed>::block_n (const domain_indirect_basic<distributed>& dom)
{
base::data().block_n (dom);
}
template<class T>
inline
void
space_basic<T,distributed>::unblock_n (const domain_indirect_basic<distributed>& dom)
{
base::data().unblock_n (dom);
}
template<class T>
inline
const point_basic<T>&
space_basic<T,distributed>::xdof (size_type idof) const
{
return base::data().xdof (idof);
}
template<class T>
inline
const disarray<point_basic<T>,distributed>&
space_basic<T,distributed>::get_xdofs() const
{
return base::data().get_xdofs();
}
template<class T>
template <class Function>
inline
T
space_basic<T,distributed>::momentum (const Function& f, size_type idof) const
{
return base::data().momentum (f, idof);
}
template<class T>
template <class Function>
inline
point_basic<T>
space_basic<T,distributed>::vector_momentum (const Function& f, size_type idof) const
{
return base::data().vector_momentum (f, idof);
}
template<class T>
template <class Function>
tensor_basic<T>
space_basic<T,distributed>::tensor_momentum (const Function& f, size_type idof) const
{
return base::data().tensor_momentum (f, idof);
}
#endif // _RHEOLEF_HAVE_MPI
// only valid when M=sequential or M=distributed => use a macro
#define _RHEOLEF_space_build_dom_dis_idof2bgd_dis_idof(M) \
template<class T> \
inline \
disarray<typename space_basic<T,M>::size_type, M> \
space_basic<T,M>::build_dom_dis_idof2bgd_dis_idof ( \
const space_basic<T,M>& Wh, \
const std::string& dom_name) const \
{ \
return base::data().build_dom_dis_idof2bgd_dis_idof (Wh.data(), dom_name); \
} \
template<class T> \
inline \
disarray<typename space_basic<T,M>::size_type, M> \
space_basic<T,M>::build_dom_dis_idof2bgd_dis_idof ( \
const space_basic<T,M>& Wh, \
const geo_basic<T,M>& bgd_gamma) const \
{ \
return base::data().build_dom_dis_idof2bgd_dis_idof (Wh.data(), bgd_gamma); \
}
_RHEOLEF_space_build_dom_dis_idof2bgd_dis_idof(sequential)
#ifdef _RHEOLEF_HAVE_MPI
_RHEOLEF_space_build_dom_dis_idof2bgd_dis_idof(distributed)
#endif // _RHEOLEF_HAVE_MPI
#undef _RHEOLEF_space_build_dom_dis_idof2bgd_dis_idof
} // namespace rheolef
#endif // _RHEOLEF_SPACE_H
f
point f(const Float &u)
Definition burgers.icc:25
communicator
see the communicator page for the full documentation
rheolef::basis_basic
Definition basis.h:566
rheolef::disarray
see the disarray page for the full documentation
Definition disarray.h:497
rheolef::disarray::size_type
rep::base::size_type size_type
Definition disarray.h:501
rheolef::distributor
see the distributor page for the full documentation
Definition distributor.h:69
rheolef::distributor::dis_size
size_type dis_size() const
global and local sizes
Definition distributor.h:214
rheolef::distributor::size
size_type size(size_type iproc) const
Definition distributor.h:170
rheolef::distributor::comm
const communicator_type & comm() const
Definition distributor.h:152
rheolef::domain_indirect_basic
the finite element boundary domain
Definition domain_indirect.h:335
rheolef::geo_basic
generic mesh with rerefence counting
Definition geo.h:1089
rheolef::geo_element
see the geo_element page for the full documentation
Definition geo_element.h:102
rheolef::point_basic
Definition point.h:86
rheolef::smart_pointer_base::data
const T & data() const
Definition smart_pointer.h:266
rheolef::smart_pointer< space_rep< T, sequential > >::smart_pointer
smart_pointer(T *p=0)
Definition smart_pointer.h:357
rheolef::space_base_rep::space_base_rep
space_base_rep(const space_mult_list< T, M > &)
rheolef::space_base_rep::space_base_rep
space_base_rep(const space_constitution< T, M > &constit)
rheolef::space_base_rep< T, sequential >::_normal
disarray< point_basic< T >, sequential > _normal
Definition space.h:272
rheolef::space_base_rep::dis_idof
void dis_idof(const geo_element &K, std::vector< size_type > &dis_idof) const
rheolef::space_base_rep::are_compatible
friend bool are_compatible(const space_base_rep< T, M > &V1, const space_base_rep< T, M > &V2)
Definition space.h:236
rheolef::space_base_rep::base_freeze_body
void base_freeze_body() const
rheolef::space_base_rep::name
std::string name() const
rheolef::space_base_rep::get_basis
const basis_basic< T > & get_basis() const
Definition space.h:190
rheolef::space_base_rep::get_constitution
const space_constitution< T, M > & get_constitution() const
Definition space.h:188
rheolef::space_base_rep::dis_ndof
size_type dis_ndof() const
Definition space.h:185
rheolef::space_base_rep::xdof
const point_basic< T > & xdof(size_type idof) const
Definition space.h:207
rheolef::space_base_rep::dis_iub
size_type dis_iub(size_type idof) const
Definition space.h:206
rheolef::space_base_rep< T, sequential >::_constit
space_constitution< T, sequential > _constit
Definition space.h:267
rheolef::space_base_rep< T, sequential >::_parent_subgeo_owner_reattribution_required
bool _parent_subgeo_owner_reattribution_required
Definition space.h:276
rheolef::space_base_rep::valued_tag
valued_type valued_tag() const
Definition space.h:191
rheolef::space_base_rep::space_base_rep
space_base_rep()
rheolef::space_base_rep::block
void block(const domain_indirect_basic< M > &dom)
e.g. "P1(square)", for field_expr<Expr> checks
Definition space.h:199
rheolef::space_base_rep::~space_base_rep
virtual ~space_base_rep()
Definition space.h:179
rheolef::space_base_rep< T, sequential >::_parent_subgeo_owner_initialized
bool _parent_subgeo_owner_initialized
Definition space.h:275
rheolef::space_base_rep::build_dom_dis_idof2bgd_dis_idof
disarray< size_type, M > build_dom_dis_idof2bgd_dis_idof(const space_base_rep< T, M > &Wh, const std::string &dom_name) const
rheolef::space_base_rep::get_parent_subgeo_owner_dis_indexes
void get_parent_subgeo_owner_dis_indexes(Set &ext_dis_idofs) const
rheolef::space_base_rep< T, sequential >::_xdof
disarray< point_basic< T >, sequential > _xdof
Definition space.h:268
rheolef::space_base_rep::size
size_type size() const
Definition space.h:193
rheolef::space_base_rep::space_base_rep
space_base_rep(const geo_basic< T, M > &omega, const basis_basic< T > &b)
rheolef::space_base_rep::get_xdofs
const disarray< point_basic< T >, M > & get_xdofs() const
Definition space.h:208
rheolef::space_base_rep< T, sequential >::_parent_subgeo_owner
disarray< size_type, sequential > _parent_subgeo_owner
Definition space.h:277
rheolef::space_base_rep< T, sequential >::field_basic
friend class field_basic
Definition space.h:250
rheolef::space_base_rep::tensor_momentum
tensor_basic< T > tensor_momentum(const Function &f, size_type idof) const
Definition space.h:223
rheolef::space_base_rep::unblock_n
void unblock_n(const domain_indirect_basic< M > &dom)
Definition space.h:203
rheolef::space_base_rep::valued_type
space_constant::valued_type valued_type
Definition space.h:165
rheolef::space_base_rep::get_parent_subgeo_owner
size_type get_parent_subgeo_owner(size_type dis_idof) const
rheolef::space_base_rep< T, sequential >::_iu_ownership
distributor _iu_ownership
Definition space.h:273
rheolef::space_base_rep::vector_momentum
point_basic< T > vector_momentum(const Function &f, size_type idof) const
Definition space.h:220
rheolef::space_base_rep< T, sequential >::_has_nt_basis
disarray< int, sequential > _has_nt_basis
Definition space.h:271
rheolef::space_base_rep::freeze_body
virtual void freeze_body() const
Definition space.h:265
rheolef::space_base_rep::size_type
space_pair_type::size_type size_type
Definition space.h:164
rheolef::space_base_rep::momentum
T momentum(const Function &f, size_type idof) const
Definition space.h:217
rheolef::space_base_rep::space_base_rep
space_base_rep(const geo_basic< T, M > &omega, std::string approx, std::string prod_valued)
rheolef::space_base_rep::parent_subgeo_owner_guard
bool parent_subgeo_owner_guard() const
rheolef::space_base_rep::is_blocked
bool is_blocked(size_type idof) const
Definition space.h:205
rheolef::space_base_rep::block_n
void block_n(const domain_indirect_basic< M > &dom)
Definition space.h:202
rheolef::space_base_rep::iu_ownership
const distributor & iu_ownership() const
Definition space.h:210
rheolef::space_base_rep::unblock
void unblock(const domain_indirect_basic< M > &dom)
Definition space.h:200
rheolef::space_base_rep::operator[]
space_component< T, M > operator[](size_type i_comp)
rheolef::space_base_rep< T, sequential >::_ib_ownership
distributor _ib_ownership
Definition space.h:274
rheolef::space_base_rep::freeze_guard
void freeze_guard() const
Definition space.h:253
rheolef::space_base_rep::no_freeze_check
void no_freeze_check() const
Definition space.h:261
rheolef::space_base_rep::parent_subgeo_owner_check
void parent_subgeo_owner_check() const
Definition space.h:241
rheolef::space_base_rep::ib_ownership
const distributor & ib_ownership() const
Definition space.h:211
rheolef::space_base_rep::ndof
size_type ndof() const
Definition space.h:184
rheolef::space_base_rep::build_dom_dis_idof2bgd_dis_idof
disarray< size_type, M > build_dom_dis_idof2bgd_dis_idof(const space_base_rep< T, M > &Wh, const geo_basic< T, M > &bgd_gamma) const
rheolef::space_base_rep::valued
const std::string & valued() const
Definition space.h:192
rheolef::space_base_rep::get_geo
const geo_basic< T, M > & get_geo() const
Definition space.h:189
rheolef::space_base_rep::freeze_check
void freeze_check() const
Definition space.h:258
rheolef::space_base_rep< T, sequential >::_idof2blk_dis_iub
disarray< space_pair_type, sequential > _idof2blk_dis_iub
Definition space.h:270
rheolef::space_base_rep::init_xdof
void init_xdof()
rheolef::space_base_rep::ownership
const distributor & ownership() const
Definition space.h:183
rheolef::space_base_rep< T, sequential >::_have_freezed
bool _have_freezed
Definition space.h:269
rheolef::space_base_rep::operator==
bool operator==(const space_base_rep< T, M > &V2) const
Definition space.h:233
rheolef::space_base_rep::comm
const communicator & comm() const
Definition space.h:186
rheolef::space_basic< T, distributed >::get_constitution
const space_constitution< T, distributed > & get_constitution() const
Definition space.h:980
rheolef::space_basic< T, distributed >::dis_idof
void dis_idof(const geo_element &K, std::vector< size_type > &dis_idof) const
Definition space.h:1043
rheolef::space_basic< T, distributed >::size
size_type size() const
Definition space.h:987
rheolef::space_basic< T, distributed >::name
std::string name() const
Definition space.h:1036
rheolef::space_basic< T, distributed >::idof2ios_dis_idof
size_type idof2ios_dis_idof(size_type idof) const
Definition space.h:1050
rheolef::space_basic< T, distributed >::get_basis
const basis_basic< T > & get_basis() const
Definition space.h:973
rheolef::space_basic< T, distributed >::xdof
const point_basic< T > & xdof(size_type idof) const
Definition space.h:1162
rheolef::space_basic< T, distributed >::build_dom_dis_idof2bgd_dis_idof
disarray< size_type, distributed > build_dom_dis_idof2bgd_dis_idof(const space_basic< T, distributed > &Wh, const std::string &dom_name) const
rheolef::space_basic< T, distributed >::ios_idof2dis_idof
size_type ios_idof2dis_idof(size_type ios_idof) const
Definition space.h:1057
rheolef::space_basic< T, distributed >::get_approx
std::string get_approx() const
Definition space.h:1029
rheolef::space_basic< T, distributed >::ext_ib_set
const std::set< size_type > & ext_ib_set() const
Definition space.h:879
rheolef::space_basic< T, distributed >::degree
size_type degree() const
Definition space.h:1022
rheolef::space_basic< T, distributed >::build_dom_dis_idof2bgd_dis_idof
disarray< size_type, distributed > build_dom_dis_idof2bgd_dis_idof(const space_basic< T, distributed > &Wh, const geo_basic< T, distributed > &bgd_gamma) const
rheolef::space_basic< T, distributed >::dis_idof2dis_iub
size_type dis_idof2dis_iub(size_type dis_idof) const
Definition space.h:1099
rheolef::space_basic< T, distributed >::get_parent_subgeo_owner_dis_indexes
void get_parent_subgeo_owner_dis_indexes(Set &ext_dis_idofs) const
Definition space.h:891
rheolef::space_basic< T, distributed >::unblock_n
void unblock_n(std::string dom_name)
Definition space.h:1141
rheolef::space_basic< T, distributed >::ios_ownership
const distributor & ios_ownership() const
Definition space.h:938
rheolef::space_basic< T, distributed >::tensor_momentum
tensor_basic< T > tensor_momentum(const Function &f, size_type idof) const
Definition space.h:1192
rheolef::space_basic< T, distributed >::ndof
size_type ndof() const
Definition space.h:952
rheolef::space_basic< T, distributed >::block
void block(std::string dom_name)
Definition space.h:1106
rheolef::space_basic< T, distributed >::are_compatible
friend bool are_compatible(const space_basic< T, distributed > &V1, const space_basic< T, distributed > &V2)
Definition space.h:885
rheolef::space_basic< T, distributed >::block_n
void block_n(std::string dom_name)
Definition space.h:1134
rheolef::space_basic< T, distributed >::dis_ndof
size_type dis_ndof() const
Definition space.h:959
rheolef::space_basic< T, distributed >::get_parent_subgeo_owner
size_type get_parent_subgeo_owner(size_type dis_idof) const
Definition space.h:893
rheolef::space_basic< T, distributed >::vector_momentum
point_basic< T > vector_momentum(const Function &f, size_type idof) const
Definition space.h:1185
rheolef::space_basic< T, distributed >::valued_type
rep::valued_type valued_type
Definition space.h:803
rheolef::space_basic< T, distributed >::base
smart_pointer< rep > base
Definition space.h:801
rheolef::space_basic< T, distributed >::momentum
T momentum(const Function &f, size_type idof) const
Definition space.h:1177
rheolef::space_basic< T, distributed >::dis_is_blocked
bool dis_is_blocked(size_type dis_idof) const
Definition space.h:1092
rheolef::space_basic< T, distributed >::is_blocked
bool is_blocked(size_type idof) const
Definition space.h:1078
rheolef::space_basic< T, distributed >::iu_ownership
const distributor & iu_ownership() const
Definition space.h:1064
rheolef::space_basic< T, distributed >::dis_iub
size_type dis_iub(size_type idof) const
Definition space.h:1085
rheolef::space_basic< T, distributed >::size_type
rep::size_type size_type
Definition space.h:802
rheolef::space_basic< T, distributed >::rep
space_rep< T, distributed > rep
Definition space.h:800
rheolef::space_basic< T, distributed >::ib_ownership
const distributor & ib_ownership() const
Definition space.h:1071
rheolef::space_basic< T, distributed >::valued
const std::string & valued() const
Definition space.h:994
rheolef::space_basic< T, distributed >::space_basic
space_basic(const geo_basic< T, distributed > &omega=(geo_basic< T, distributed >()), std::string approx="", std::string prod_valued="scalar")
Definition space.h:900
rheolef::space_basic< T, distributed >::get_xdofs
const disarray< point_basic< T >, distributed > & get_xdofs() const
Definition space.h:1169
rheolef::space_basic< T, distributed >::unblock
void unblock(std::string dom_name)
Definition space.h:1113
rheolef::space_basic< T, distributed >::real
static space_basic< T, distributed > real()
rheolef::space_basic< T, distributed >::ext_iu_set
const std::set< size_type > & ext_iu_set() const
Definition space.h:878
rheolef::space_basic< T, distributed >::ownership
const distributor & ownership() const
Definition space.h:931
rheolef::space_basic< T, distributed >::comm
const communicator & comm() const
Definition space.h:945
rheolef::space_basic< T, sequential >::dis_idof
void dis_idof(const geo_element &K, std::vector< size_type > &dis_idof) const
Definition space.h:637
rheolef::space_basic< T, sequential >::real
static space_basic< T, sequential > real()
rheolef::space_basic< T, sequential >::get_xdofs
const disarray< point_basic< T >, sequential > & get_xdofs() const
Definition space.h:763
rheolef::space_basic< T, sequential >::name
std::string name() const
Definition space.h:630
rheolef::space_basic< T, sequential >::size
size_type size() const
Definition space.h:581
rheolef::space_basic< T, sequential >::ios_idof2dis_idof
size_type ios_idof2dis_idof(size_type ios_idof) const
Definition space.h:651
rheolef::space_basic< T, sequential >::get_basis
const basis_basic< T > & get_basis() const
Definition space.h:567
rheolef::space_basic< T, sequential >::xdof
const point_basic< T > & xdof(size_type idof) const
Definition space.h:756
rheolef::space_basic< T, sequential >::degree
size_type degree() const
Definition space.h:616
rheolef::space_basic< T, sequential >::build_dom_dis_idof2bgd_dis_idof
disarray< size_type, sequential > build_dom_dis_idof2bgd_dis_idof(const space_basic< T, sequential > &Wh, const geo_basic< T, sequential > &bgd_gamma) const
rheolef::space_basic< T, sequential >::get_approx
std::string get_approx() const
Definition space.h:623
rheolef::space_basic< T, sequential >::space_basic
space_basic(const geo_basic< T, sequential > &omega=(geo_basic< T, sequential >()), std::string approx="", std::string prod_valued="scalar")
Definition space.h:494
rheolef::space_basic< T, sequential >::dis_ndof
size_type dis_ndof() const
Definition space.h:553
rheolef::space_basic< T, sequential >::ext_ib_set
const std::set< size_type > & ext_ib_set() const
Definition space.h:474
rheolef::space_basic< T, sequential >::get_parent_subgeo_owner_dis_indexes
void get_parent_subgeo_owner_dis_indexes(Set &ext_dis_idofs) const
Definition space.h:486
rheolef::space_basic< T, sequential >::idof2ios_dis_idof
size_type idof2ios_dis_idof(size_type idof) const
Definition space.h:644
rheolef::space_basic< T, sequential >::build_dom_dis_idof2bgd_dis_idof
disarray< size_type, sequential > build_dom_dis_idof2bgd_dis_idof(const space_basic< T, sequential > &Wh, const std::string &dom_name) const
rheolef::space_basic< T, sequential >::unblock_n
void unblock_n(std::string dom_name)
Definition space.h:735
rheolef::space_basic< T, sequential >::rep
space_rep< T, sequential > rep
Definition space.h:396
rheolef::space_basic< T, sequential >::ios_ownership
const distributor & ios_ownership() const
Definition space.h:532
rheolef::space_basic< T, sequential >::dis_iub
size_type dis_iub(size_type idof) const
Definition space.h:679
rheolef::space_basic< T, sequential >::tensor_momentum
tensor_basic< T > tensor_momentum(const Function &f, size_type idof) const
Definition space.h:786
rheolef::space_basic< T, sequential >::block
void block(std::string dom_name)
Definition space.h:700
rheolef::space_basic< T, sequential >::block_n
void block_n(std::string dom_name)
Definition space.h:728
rheolef::space_basic< T, sequential >::get_parent_subgeo_owner
size_type get_parent_subgeo_owner(size_type dis_idof) const
Definition space.h:488
rheolef::space_basic< T, sequential >::vector_momentum
point_basic< T > vector_momentum(const Function &f, size_type idof) const
Definition space.h:779
rheolef::space_basic< T, sequential >::are_compatible
friend bool are_compatible(const space_basic< T, sequential > &V1, const space_basic< T, sequential > &V2)
Definition space.h:480
rheolef::space_basic< T, sequential >::valued_type
rep::valued_type valued_type
Definition space.h:399
rheolef::space_basic< T, sequential >::base
smart_pointer< rep > base
Definition space.h:397
rheolef::space_basic< T, sequential >::momentum
T momentum(const Function &f, size_type idof) const
Definition space.h:771
rheolef::space_basic< T, sequential >::dis_is_blocked
bool dis_is_blocked(size_type dis_idof) const
Definition space.h:686
rheolef::space_basic< T, sequential >::get_constitution
const space_constitution< T, sequential > & get_constitution() const
Definition space.h:574
rheolef::space_basic< T, sequential >::is_blocked
bool is_blocked(size_type idof) const
Definition space.h:672
rheolef::space_basic< T, sequential >::iu_ownership
const distributor & iu_ownership() const
Definition space.h:658
rheolef::space_basic< T, sequential >::ndof
size_type ndof() const
Definition space.h:546
rheolef::space_basic< T, sequential >::size_type
rep::size_type size_type
Definition space.h:398
rheolef::space_basic< T, sequential >::ib_ownership
const distributor & ib_ownership() const
Definition space.h:665
rheolef::space_basic< T, sequential >::valued
const std::string & valued() const
Definition space.h:588
rheolef::space_basic< T, sequential >::unblock
void unblock(std::string dom_name)
Definition space.h:707
rheolef::space_basic< T, sequential >::ext_iu_set
const std::set< size_type > & ext_iu_set() const
Definition space.h:473
rheolef::space_basic< T, sequential >::ownership
const distributor & ownership() const
Definition space.h:525
rheolef::space_basic< T, sequential >::dis_idof2dis_iub
size_type dis_idof2dis_iub(size_type dis_idof) const
Definition space.h:693
rheolef::space_basic< T, sequential >::comm
const communicator & comm() const
Definition space.h:539
rheolef::space_basic
the finite element space
Definition space.h:382
rheolef::space_component_const
Definition space_component.h:84
rheolef::space_component
Definition space_component.h:29
rheolef::space_constitution
Definition space_constitution.h:405
rheolef::space_mult_list
Definition space_mult.h:54
rheolef::space_rep< T, distributed >::base
space_base_rep< T, distributed > base
Definition space.h:337
rheolef::space_rep< T, distributed >::append_external_dof
void append_external_dof(const geo_basic< T, distributed > &dom, std::set< size_type > &ext_dof_set) const
rheolef::space_rep< T, distributed >::ext_ib_set
const std::set< size_type > & ext_ib_set() const
Definition space.h:362
rheolef::space_rep< T, distributed >::idof2ios_dis_idof
size_type idof2ios_dis_idof(size_type idof) const
Definition space.h:359
rheolef::space_rep< T, distributed >::_ios_idof2dis_idof
disarray< size_type, distributed > _ios_idof2dis_idof
Definition space.h:371
rheolef::space_rep< T, distributed >::ios_ownership
const distributor & ios_ownership() const
Definition space.h:358
rheolef::space_rep< T, distributed >::size_type
base::size_type size_type
Definition space.h:338
rheolef::space_rep< T, distributed >::field_basic
friend class field_basic
Definition space.h:365
rheolef::space_rep< T, distributed >::freeze_body
void freeze_body() const
Definition space_mpi.cc:81
rheolef::space_rep< T, distributed >::~space_rep
~space_rep()
Definition space.h:349
rheolef::space_rep< T, distributed >::_idof2ios_dis_idof
disarray< size_type, distributed > _idof2ios_dis_idof
Definition space.h:370
rheolef::space_rep< T, distributed >::space_rep
space_rep(const geo_basic< T, distributed > &omega, std::string approx, std::string prod_valued)
Definition space_mpi.cc:43
rheolef::space_rep< T, distributed >::ios_idof2dis_idof
size_type ios_idof2dis_idof(size_type ios_idof) const
Definition space.h:360
rheolef::space_rep< T, distributed >::_ext_ib_set
std::set< size_type > _ext_ib_set
Definition space.h:374
rheolef::space_rep< T, distributed >::ext_iu_set
const std::set< size_type > & ext_iu_set() const
Definition space.h:361
rheolef::space_rep< T, distributed >::_ext_iu_set
std::set< size_type > _ext_iu_set
Definition space.h:373
rheolef::space_rep< T, distributed >::comm
const communicator & comm() const
Definition space.h:353
rheolef::space_rep< T, sequential >::space_rep
space_rep(const geo_basic< T, sequential > &omega, std::string approx, std::string prod_valued)
Definition space_seq.cc:38
rheolef::space_rep< T, sequential >::idof2ios_dis_idof
size_type idof2ios_dis_idof(size_type idof) const
Definition space.h:322
rheolef::space_rep< T, sequential >::ios_ownership
const distributor & ios_ownership() const
Definition space.h:321
rheolef::space_rep< T, sequential >::size_type
base::size_type size_type
Definition space.h:303
rheolef::space_rep< T, sequential >::dis_idof2dis_iub
size_type dis_idof2dis_iub(size_type dis_idof) const
Definition space.h:319
rheolef::space_rep< T, sequential >::~space_rep
~space_rep()
Definition space.h:314
rheolef::space_rep< T, sequential >::dis_is_blocked
bool dis_is_blocked(size_type dis_idof) const
Definition space.h:318
rheolef::space_rep< T, sequential >::ios_idof2dis_idof
size_type ios_idof2dis_idof(size_type ios_idof) const
Definition space.h:323
rheolef::space_rep< T, sequential >::base
space_base_rep< T, sequential > base
Definition space.h:302
rheolef::space_rep
Definition space.h:294
rheolef::tensor_basic
Definition tensor.h:90
rheolef::distributed
distributed
Definition asr.cc:228
rheolef::space
space_basic< Float > space
Definition space.h:386
get_geo
void get_geo(istream &in, my_geo &omega)
Definition field2gmsh_pos.cc:126
T
Expr1::float_type T
Definition field_expr.h:230
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
boost
Definition mpi_pair_datatype.h:51
rheolef::space_constant::valued_type
valued_type
Definition space_constant.h:133
rheolef
This file is part of Rheolef.
Definition compiler_eigen.h:39
rheolef::operator!=
bool operator!=(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition heap_allocator.h:176
rheolef::operator==
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition heap_allocator.h:171
rheolef::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_recursive.h:620
std
STL namespace.
_RHEOLEF_space_build_dom_dis_idof2bgd_dis_idof
#define _RHEOLEF_space_build_dom_dis_idof2bgd_dis_idof(M)
Definition space.h:1199
f
Definition cavity_dg.h:29
rheolef::distributed
Definition communicator.h:128
rheolef::sequential
Definition communicator.h:62
rheolef::space_pair_type::operator<<
friend std::ostream & operator<<(std::ostream &os, const space_pair_type &x)
Definition space.h:129
rheolef::space_pair_type::size_type
disarray< size_t >::size_type size_type
Definition space.h:122
rheolef::space_pair_type::set_dis_iub
void set_dis_iub(size_type dis_iub)
Definition space.h:127
rheolef::space_pair_type::set_blocked
void set_blocked(bool blk)
Definition space.h:128
rheolef::space_pair_type::_dis_iub
size_type _dis_iub
Definition space.h:135
rheolef::space_pair_type::dis_iub
size_type dis_iub() const
Definition space.h:126
rheolef::space_pair_type::serialize
void serialize(Archive &ar, const unsigned int version)
Definition space.h:132
rheolef::space_pair_type::_blk
bool _blk
Definition space.h:134
rheolef::space_pair_type::space_pair_type
space_pair_type()
Definition space.h:123
rheolef::space_pair_type::space_pair_type
space_pair_type(bool blk, size_type dis_iub)
Definition space.h:124
rheolef::space_pair_type::is_blocked
bool is_blocked() const
Definition space.h:125
M
Expr1::memory_type M
Definition vec_expr_v2.h:416