Loading...
Searching...
No Matches
domain_indirect.h
Go to the documentation of this file.
#ifndef _RHEOLEF_DOMAIN_INDIRECT_H
#define _RHEOLEF_DOMAIN_INDIRECT_H
/*Class:domain_indirect
NAME: @code{domain_indirect} - a named part of a finite element mesh
@cindex mesh boundary
@clindex domain_indirect
DESCRIPTION:
@noindent
The @code{domain_indirect} class defines a container for a part of a
finite element mesh.
This describes the connectivity of edges or faces.
This class is useful for boundary condition setting.
IMPLEMENTATION NOTE:
The @code{domain} class is split into two parts.
The first one is the @code{domain_indirect} class, that contains the main
renumbering features: it acts as a indirect on a @code{geo} class(@pxref{geo class}).
The second one is the @code{domain} class, that simply contains two
smart_pointers: one on a @code{domain_indirect} and the second on the
@code{geo} where renumbering is acting.
Thus, the domain class develops a complete @code{geo}-like interface,
via the @code{geo_abstract_rep} pure virtual class derivation,
and can be used by the @code{space} class (@pxref{space class}).
The split between domain_indirect and domain is necessary,
because the @code{geo} class contains a list of domain_indirect.
It cannot contains a list of @code{domain} classes, that refers
to the geo class itself: a loop in reference counting
leads to a blocking situation in the automatic deallocation.
DATE: 12 may 1997
End:
*/
#include "rheolef/disarray.h"
#include "rheolef/geo_element.h"
#include "rheolef/geo_element_indirect.h"
#include "rheolef/index_set.h"
namespace rheolef {
// foward declarations:
template <class U, class M> class geo_abstract_rep;
template <class U, class M> class geo_rep;
template <class U, class M> class geo_basic;
// ==================================================================================
// 1) domain_indirect
// representation: domain_indirect_base_rep<M> and domain_indirect_rep<M>
// ==================================================================================
template <class M>
class domain_indirect_base_rep : public disarray<geo_element_indirect,M> {
public:
// typedefs:
typedef disarray<geo_element_indirect,M> base;
typedef typename geo_element_indirect::size_type size_type;
typedef typename geo_element_indirect::orientation_type orientation_type;
typedef typename base::iterator iterator_ioige;
typedef typename base::const_iterator const_iterator_ioige;
// allocators:
domain_indirect_base_rep();
void resize (size_type n) { base::resize (n); }
// build from a table of element indexes
domain_indirect_base_rep (const std::string& name, size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list);
void build_from_list (const std::string& name, size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list);
// c := a union b with c=*this
void build_union (
const domain_indirect_base_rep<M>& a,
const domain_indirect_base_rep<M>& b);
// accessors & modifiers:
size_type size() const { return base::size(); }
size_type dis_size() const { return base::dis_size(); }
const_iterator_ioige ioige_begin() const { return base::begin(); }
const_iterator_ioige ioige_end() const { return base::end(); }
iterator_ioige ioige_begin() { return base::begin(); }
iterator_ioige ioige_end() { return base::end(); }
const geo_element_indirect& oige (size_type ioige) const { return base::operator[] (ioige); }
std::string name () const { return _name; }
size_type map_dimension () const { return _map_dim; }
void set_name (std::string name) { _name = name; }
void set_map_dimension (size_type map_dim) { _map_dim = map_dim; }
bool is_broken() const { return _is_broken; }
void set_broken(bool b) { _is_broken = b; }
protected:
// data:
std::string _name;
size_type _map_dim;
bool _is_broken; // for e.g. "sides" or "internal_sides"
};
template <class M>
inline
domain_indirect_base_rep<M>::domain_indirect_base_rep()
: disarray<geo_element_indirect,M>(),
_name(),
_map_dim(0),
_is_broken(false)
{
}
template<class M>
inline
domain_indirect_base_rep<M>::domain_indirect_base_rep (
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list)
: disarray<geo_element_indirect,M>(),
_name(),
_map_dim(),
_is_broken(false)
{
build_from_list (name, map_dim, comm, ie_list);
}
// ---------------------------------------------------------------------
template <class M> class domain_indirect_rep {};
template<>
class domain_indirect_rep<sequential> : public domain_indirect_base_rep<sequential> {
public:
// typedefs:
typedef domain_indirect_base_rep<sequential> base;
typedef base::size_type size_type;
typedef base::iterator_ioige iterator_ioige;
typedef base::const_iterator_ioige const_iterator_ioige;
typedef base::orientation_type orientation_type;
// allocators:
domain_indirect_rep () : domain_indirect_base_rep<sequential>() {}
domain_indirect_rep (
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list)
: domain_indirect_base_rep<sequential>(name, map_dim, comm, ie_list) {}
void resize (size_type n) { base::resize (n); }
// c := a union b with c=*this
void build_union (
const domain_indirect_rep<sequential>& a,
const domain_indirect_rep<sequential>& b);
// accessors:
size_type size() const { return base::size(); }
size_type dis_size() const { return base::dis_size(); }
const_iterator_ioige ioige_begin() const { return base::ioige_begin(); }
const_iterator_ioige ioige_end() const { return base::ioige_end(); }
iterator_ioige ioige_begin() { return base::ioige_begin(); }
iterator_ioige ioige_end() { return base::ioige_end(); }
const geo_element_indirect& oige (size_type ioige) const {
return base::oige (ioige); }
void set_name (std::string name) { base::set_name(name); }
void set_map_dimension (size_type map_dim) { base::set_map_dimension(map_dim); }
std::string name () const { return base::name(); }
size_type map_dimension () const { return base::map_dimension(); }
bool is_broken() const { return base::is_broken(); }
void set_broken(bool b) { base::set_broken(b); }
// i/o:
template<class U>
void build_from_data (
const geo_rep<U,sequential>& omega,
disarray<geo_element_auto<>,sequential>&
d_tmp,
std::vector<index_set>* ball);
template <class U>
idiststream& get (
idiststream& ips,
const geo_rep<U,sequential>& omega,
std::vector<index_set>* ball);
odiststream& put (odiststream& ops) const;
};
// c := a union b with c=*this
inline
void
domain_indirect_rep<sequential>::build_union (
const domain_indirect_rep<sequential>& a,
const domain_indirect_rep<sequential>& b)
{
base::build_union (a,b);
}
// ---------------------------------------------------------------------
#ifdef _RHEOLEF_HAVE_MPI
template<>
class domain_indirect_rep<distributed> : public domain_indirect_base_rep<distributed> {
public:
// typedefs:
typedef domain_indirect_base_rep<distributed> base;
typedef base::size_type size_type;
typedef base::iterator_ioige iterator_ioige;
typedef base::const_iterator_ioige const_iterator_ioige;
typedef base::orientation_type orientation_type;
// allocators:
domain_indirect_rep();
template<class T>
domain_indirect_rep (
const geo_abstract_rep<T,distributed>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list);
template<class T>
void init_ios (const geo_abstract_rep<T,distributed>& omega);
// c := a union b with c=*this
template<class T>
void build_union (
const geo_basic<T,distributed>& omega,
const domain_indirect_rep<distributed>& a,
const domain_indirect_rep<distributed>& b);
// accessors & modifiers:
size_type size() const { return base::size(); }
size_type dis_size() const { return base::dis_size(); }
const geo_element_indirect& oige (size_type ioige) const {
return base::oige (ioige); }
void set_name (std::string name) { base::set_name(name); }
void set_map_dimension (size_type map_dim) { base::set_map_dimension(map_dim); }
std::string name () const { return base::name(); }
size_type map_dimension () const { return base::map_dimension(); }
bool is_broken() const { return base::is_broken(); }
void set_broken(bool b) { base::set_broken(b); }
// distributed specific acessors:
const distributor& ini_ownership () const { return _ini_ioige2dis_ioige.ownership(); }
size_type ioige2ini_dis_ioige (size_type ioige) const { return _ioige2ini_dis_ioige [ioige]; }
size_type ini_ioige2dis_ioige (size_type ini_ioige) const { return _ini_ioige2dis_ioige [ini_ioige]; }
// i/o:
template <class U>
idiststream& get (idiststream& ips, const geo_rep<U,distributed>& omega);
template <class U>
odiststream& put (odiststream& ops, const geo_rep<U,distributed>& omega) const;
protected:
template <class U1,class M1> friend class geo_rep; // for geo_rep::build_from_domain
// data:
disarray<size_type,distributed> _ioige2ini_dis_ioige;
disarray<size_type,distributed> _ini_ioige2dis_ioige;
};
inline
domain_indirect_rep<distributed>::domain_indirect_rep()
: domain_indirect_base_rep<distributed>(),
_ioige2ini_dis_ioige(),
_ini_ioige2dis_ioige()
{
}
template<class T>
inline
domain_indirect_rep<distributed>::domain_indirect_rep (
const geo_abstract_rep<T,distributed>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list)
: domain_indirect_base_rep<distributed>(name, map_dim, comm, ie_list),
_ioige2ini_dis_ioige(),
_ini_ioige2dis_ioige()
{
init_ios (omega);
}
// c := a union b with c=*this
template<class T>
inline
void
domain_indirect_rep<distributed>::build_union (
const geo_basic<T,distributed>& omega,
const domain_indirect_rep<distributed>& a,
const domain_indirect_rep<distributed>& b)
{
base::build_union (a,b);
init_ios (omega.data());
}
#endif // _RHEOLEF_HAVE_MPI
// ====================================================================
// 2) wrapper: domain_indirect_basic<M>
// ====================================================================
template <class M = rheo_default_memory_model>
class domain_indirect_basic {
public:
};
typedef domain_indirect_basic<rheo_default_memory_model> domain_indirect;
// ---------------------------------------------------------------------
//<verbatim:
template <>
class domain_indirect_basic<sequential> : public smart_pointer<domain_indirect_rep<sequential> > {
public:
// typedefs:
typedef domain_indirect_rep<sequential> rep;
typedef smart_pointer<rep> base;
typedef rep::size_type size_type;
typedef rep::iterator_ioige iterator_ioige;
typedef rep::const_iterator_ioige const_iterator_ioige;
// allocators:
domain_indirect_basic ();
template <class T>
domain_indirect_basic (
const geo_abstract_rep<T,sequential>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list);
template <class T>
domain_indirect_basic (
const geo_basic<T,sequential>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list);
template <class U>
domain_indirect_basic (
disarray<geo_element_auto<>,sequential>&
d_tmp,
const geo_basic<U, sequential>& omega,
std::vector<index_set>* ball);
void resize (size_type n);
// accessors:
size_type size() const;
size_type dis_size() const;
const distributor& ownership() const;
const_iterator_ioige ioige_begin() const;
const_iterator_ioige ioige_end() const;
iterator_ioige ioige_begin();
iterator_ioige ioige_end();
const geo_element_indirect& oige (size_type ioige) const;
void set_name (std::string name);
void set_map_dimension (size_type map_dim);
std::string name () const;
size_type map_dimension () const;
bool is_broken() const;
void set_broken(bool b);
// i/o:
odiststream& put (odiststream&) const;
template <class T>
idiststream& get (idiststream& ips, const geo_rep<T,sequential>& omega, std::vector<index_set> *ball);
};
//>verbatim:
inline
domain_indirect_basic<sequential>::domain_indirect_basic ()
: smart_pointer<rep> (new_macro(rep))
{
}
template<class T>
inline
domain_indirect_basic<sequential>::domain_indirect_basic (
const geo_basic<T,sequential>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list)
: smart_pointer<rep> (new_macro(rep(name, map_dim, comm, ie_list)))
{
}
template<class T>
inline
domain_indirect_basic<sequential>::domain_indirect_basic (
const geo_abstract_rep<T,sequential>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list)
: smart_pointer<rep> (new_macro(rep(name, map_dim, comm, ie_list)))
{
}
inline
void
domain_indirect_basic<sequential>::resize (size_type n)
{
return base::data().resize (n);
}
inline
domain_indirect_basic<sequential>::size_type
domain_indirect_basic<sequential>::size() const
{
return base::data().size();
}
inline
domain_indirect_basic<sequential>::size_type
domain_indirect_basic<sequential>::dis_size() const
{
return base::data().dis_size();
}
inline
const distributor&
domain_indirect_basic<sequential>::ownership() const
{
return base::data().ownership();
}
inline
const geo_element_indirect&
domain_indirect_basic<sequential>::oige (size_type ioige) const
{
return base::data().oige (ioige);
}
inline
domain_indirect_basic<sequential>::const_iterator_ioige
domain_indirect_basic<sequential>::ioige_begin() const
{
return base::data().ioige_begin();
}
inline
domain_indirect_basic<sequential>::const_iterator_ioige
domain_indirect_basic<sequential>::ioige_end() const
{
return base::data().ioige_end();
}
inline
domain_indirect_basic<sequential>::iterator_ioige
domain_indirect_basic<sequential>::ioige_begin()
{
return base::data().ioige_begin();
}
inline
domain_indirect_basic<sequential>::iterator_ioige
domain_indirect_basic<sequential>::ioige_end()
{
return base::data().ioige_end();
}
inline
std::string
domain_indirect_basic<sequential>::name() const
{
return base::data().name();
}
inline
domain_indirect_basic<sequential>::size_type
domain_indirect_basic<sequential>::map_dimension() const
{
return base::data().map_dimension();
}
inline
bool
domain_indirect_basic<sequential>::is_broken() const
{
return base::data().is_broken();
}
inline
void
domain_indirect_basic<sequential>::set_broken(bool b)
{
base::data().set_broken(b);
}
inline
void
domain_indirect_basic<sequential>::set_name(std::string name)
{
return base::data().set_name (name);
}
inline
void
domain_indirect_basic<sequential>::set_map_dimension (size_type map_dim)
{
return base::data().set_map_dimension (map_dim);
}
inline
odiststream&
domain_indirect_basic<sequential>::put (odiststream& ops) const
{
return base::data().put (ops);
}
template<class T>
inline
idiststream&
domain_indirect_basic<sequential>::get (
idiststream& ips,
const geo_rep<T,sequential>& omega,
std::vector<index_set> *ball)
{
return base::data().template get (ips, omega, ball);
}
// union:
template<class T>
inline
domain_indirect_basic<sequential>
build_union (
const geo_basic<T,sequential>& omega,
const domain_indirect_basic<sequential>& a,
const domain_indirect_basic<sequential>& b)
{
domain_indirect_basic<sequential> c;
c.data().build_union (a.data(), b.data());
return c;
}
// ---------------------------------------------------------------------
#ifdef _RHEOLEF_HAVE_MPI
//<verbatim:
template <>
class domain_indirect_basic<distributed> : public smart_pointer<domain_indirect_rep<distributed> > {
public:
// typedefs:
typedef domain_indirect_rep<distributed> rep;
typedef smart_pointer<rep> base;
typedef rep::size_type size_type;
typedef rep::iterator_ioige iterator_ioige;
typedef rep::const_iterator_ioige const_iterator_ioige;
// allocators:
domain_indirect_basic ();
template<class T>
domain_indirect_basic (
const geo_basic<T,distributed>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list);
template<class T>
domain_indirect_basic (
const geo_abstract_rep<T,distributed>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list);
// accessors/modifiers:
size_type size() const;
size_type dis_size() const;
const distributor& ownership() const;
const geo_element_indirect& oige (size_type ioige) const;
void set_name (std::string name);
void set_map_dimension (size_type map_dim);
std::string name () const;
size_type map_dimension () const;
bool is_broken() const;
void set_broken(bool b);
// distributed specific acessors:
const_iterator_ioige ioige_begin() const;
const_iterator_ioige ioige_end() const;
iterator_ioige ioige_begin();
iterator_ioige ioige_end();
const distributor& ini_ownership() const;
size_type ioige2ini_dis_ioige (size_type ioige) const;
size_type ini_ioige2dis_ioige (size_type ini_ioige) const;
// i/o:
template <class T>
idiststream& get (idiststream& ips, const geo_rep<T,distributed>& omega);
template <class T>
odiststream& put (odiststream& ops, const geo_rep<T,distributed>& omega) const;
};
//>verbatim:
inline
domain_indirect_basic<distributed>::domain_indirect_basic ()
: smart_pointer<rep> (new_macro(rep))
{
}
template<class T>
inline
domain_indirect_basic<distributed>::domain_indirect_basic (
const geo_basic<T,distributed>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list)
: smart_pointer<rep> (new_macro(rep(omega.data(), name, map_dim, comm, ie_list)))
{
}
template<class T>
inline
domain_indirect_basic<distributed>::domain_indirect_basic (
const geo_abstract_rep<T,distributed>& omega,
const std::string& name,
size_type map_dim,
const communicator& comm,
const std::vector<size_type>& ie_list)
: smart_pointer<rep> (new_macro(rep(omega, name, map_dim, comm, ie_list)))
{
}
inline
domain_indirect_basic<distributed>::size_type
domain_indirect_basic<distributed>::size() const
{
return base::data().size();
}
inline
domain_indirect_basic<distributed>::size_type
domain_indirect_basic<distributed>::dis_size() const
{
return base::data().dis_size();
}
inline
const distributor&
domain_indirect_basic<distributed>::ownership() const
{
return base::data().ownership();
}
template<class T>
inline
idiststream&
domain_indirect_basic<distributed>::get (
idiststream& ips,
const geo_rep<T,distributed>& omega)
{
return base::data().template get (ips, omega);
}
template<class T>
inline
odiststream&
domain_indirect_basic<distributed>::put (
odiststream& ops,
const geo_rep<T,distributed>& omega) const
{
return base::data().template put (ops, omega);
}
inline
std::string
domain_indirect_basic<distributed>::name() const
{
return base::data().name();
}
inline
domain_indirect_basic<distributed>::size_type
domain_indirect_basic<distributed>::map_dimension() const
{
return base::data().map_dimension();
}
inline
void
domain_indirect_basic<distributed>::set_name(std::string name)
{
return base::data().set_name (name);
}
inline
void
domain_indirect_basic<distributed>::set_map_dimension (size_type map_dim)
{
return base::data().set_map_dimension (map_dim);
}
inline
bool
domain_indirect_basic<distributed>::is_broken() const
{
return base::data().is_broken();
}
inline
void
domain_indirect_basic<distributed>::set_broken(bool b)
{
base::data().set_broken(b);
}
inline
const geo_element_indirect&
domain_indirect_basic<distributed>::oige (size_type ioige) const
{
return base::data().oige (ioige);
}
inline
domain_indirect_basic<distributed>::const_iterator_ioige
domain_indirect_basic<distributed>::ioige_begin() const
{
return base::data().ioige_begin();
}
inline
domain_indirect_basic<distributed>::const_iterator_ioige
domain_indirect_basic<distributed>::ioige_end() const
{
return base::data().ioige_end();
}
inline
domain_indirect_basic<distributed>::iterator_ioige
domain_indirect_basic<distributed>::ioige_begin()
{
return base::data().ioige_begin();
}
inline
domain_indirect_basic<distributed>::iterator_ioige
domain_indirect_basic<distributed>::ioige_end()
{
return base::data().ioige_end();
}
inline
const distributor&
domain_indirect_basic<distributed>::ini_ownership() const
{
return base::data().ini_ownership();
}
inline
domain_indirect_basic<distributed>::size_type
domain_indirect_basic<distributed>::ioige2ini_dis_ioige (size_type ioige) const
{
return base::data().ioige2ini_dis_ioige (ioige);
}
inline
domain_indirect_basic<distributed>::size_type
domain_indirect_basic<distributed>::ini_ioige2dis_ioige (size_type ini_ioige) const
{
return base::data().ini_ioige2dis_ioige (ini_ioige);
}
// union:
template<class T>
inline
domain_indirect_basic<distributed>
build_union (
const geo_basic<T,distributed>& omega,
const domain_indirect_basic<distributed>& a,
const domain_indirect_basic<distributed>& b)
{
domain_indirect_basic<distributed> c;
c.data().build_union (omega, a.data(), b.data());
return c;
}
#endif // _RHEOLEF_HAVE_MPI
} // namespace rheolef
#endif // _RHEOLEF_DOMAIN_INDIRECT_H
communicator
see the communicator page for the full documentation
rheolef::disarray
see the disarray page for the full documentation
Definition disarray.h:497
rheolef::disarray< geo_element_indirect, M >::const_iterator
rep::base::const_iterator const_iterator
Definition disarray.h:503
rheolef::disarray< geo_element_indirect, M >::iterator
rep::base::iterator iterator
Definition disarray.h:502
rheolef::distributor
see the distributor page for the full documentation
Definition distributor.h:69
rheolef::domain_indirect_base_rep::build_from_list
void build_from_list(const std::string &name, size_type map_dim, const communicator &comm, const std::vector< size_type > &ie_list)
Definition domain_indirect_seq.cc:32
rheolef::domain_indirect_base_rep::build_union
void build_union(const domain_indirect_base_rep< M > &a, const domain_indirect_base_rep< M > &b)
Definition domain_indirect_seq.cc:55
rheolef::domain_indirect_base_rep::orientation_type
geo_element_indirect::orientation_type orientation_type
Definition domain_indirect.h:78
rheolef::domain_indirect_base_rep::ioige_begin
iterator_ioige ioige_begin()
Definition domain_indirect.h:107
rheolef::domain_indirect_base_rep< sequential >::name
std::string name() const
Definition domain_indirect.h:112
rheolef::domain_indirect_base_rep::size_type
geo_element_indirect::size_type size_type
Definition domain_indirect.h:77
rheolef::domain_indirect_base_rep::dis_size
size_type dis_size() const
Definition domain_indirect.h:103
rheolef::domain_indirect_base_rep::set_map_dimension
void set_map_dimension(size_type map_dim)
Definition domain_indirect.h:115
rheolef::domain_indirect_base_rep::const_iterator_ioige
base::const_iterator const_iterator_ioige
Definition domain_indirect.h:80
rheolef::domain_indirect_base_rep::map_dimension
size_type map_dimension() const
Definition domain_indirect.h:113
rheolef::domain_indirect_base_rep::size
size_type size() const
Definition domain_indirect.h:102
rheolef::domain_indirect_base_rep::resize
void resize(size_type n)
Definition domain_indirect.h:85
rheolef::domain_indirect_base_rep::set_name
void set_name(std::string name)
Definition domain_indirect.h:114
rheolef::domain_indirect_base_rep::ioige_begin
const_iterator_ioige ioige_begin() const
Definition domain_indirect.h:105
rheolef::domain_indirect_base_rep::domain_indirect_base_rep
domain_indirect_base_rep(const std::string &name, size_type map_dim, const communicator &comm, const std::vector< size_type > &ie_list)
Definition domain_indirect.h:135
rheolef::domain_indirect_base_rep::iterator_ioige
base::iterator iterator_ioige
Definition domain_indirect.h:79
rheolef::domain_indirect_base_rep::ioige_end
const_iterator_ioige ioige_end() const
Definition domain_indirect.h:106
rheolef::domain_indirect_base_rep::domain_indirect_base_rep
domain_indirect_base_rep()
Definition domain_indirect.h:126
rheolef::domain_indirect_base_rep< sequential >::_is_broken
bool _is_broken
Definition domain_indirect.h:122
rheolef::domain_indirect_base_rep::set_broken
void set_broken(bool b)
Definition domain_indirect.h:117
rheolef::domain_indirect_base_rep::oige
const geo_element_indirect & oige(size_type ioige) const
Definition domain_indirect.h:110
rheolef::domain_indirect_base_rep::is_broken
bool is_broken() const
Definition domain_indirect.h:116
rheolef::domain_indirect_base_rep< sequential >::_name
std::string _name
Definition domain_indirect.h:120
rheolef::domain_indirect_base_rep< sequential >::_map_dim
size_type _map_dim
Definition domain_indirect.h:121
rheolef::domain_indirect_base_rep::base
disarray< geo_element_indirect, M > base
Definition domain_indirect.h:76
rheolef::domain_indirect_base_rep::ioige_end
iterator_ioige ioige_end()
Definition domain_indirect.h:108
rheolef::domain_indirect_basic< distributed >::name
std::string name() const
Definition domain_indirect.h:689
rheolef::domain_indirect_basic< distributed >::ioige_end
const_iterator_ioige ioige_end() const
Definition domain_indirect.h:737
rheolef::domain_indirect_basic< distributed >::set_map_dimension
void set_map_dimension(size_type map_dim)
Definition domain_indirect.h:707
rheolef::domain_indirect_basic< distributed >::ioige2ini_dis_ioige
size_type ioige2ini_dis_ioige(size_type ioige) const
Definition domain_indirect.h:761
rheolef::domain_indirect_basic< distributed >::rep
domain_indirect_rep< distributed > rep
Definition domain_indirect.h:564
rheolef::domain_indirect_basic< distributed >::dis_size
size_type dis_size() const
Definition domain_indirect.h:659
rheolef::domain_indirect_basic< distributed >::domain_indirect_basic
domain_indirect_basic()
Definition domain_indirect.h:625
rheolef::domain_indirect_basic< distributed >::set_name
void set_name(std::string name)
Definition domain_indirect.h:701
rheolef::domain_indirect_basic< distributed >::iterator_ioige
rep::iterator_ioige iterator_ioige
Definition domain_indirect.h:567
rheolef::domain_indirect_basic< distributed >::ioige_begin
const_iterator_ioige ioige_begin() const
Definition domain_indirect.h:731
rheolef::domain_indirect_basic< distributed >::base
smart_pointer< rep > base
Definition domain_indirect.h:565
rheolef::domain_indirect_basic< distributed >::ini_ownership
const distributor & ini_ownership() const
Definition domain_indirect.h:755
rheolef::domain_indirect_basic< distributed >::map_dimension
size_type map_dimension() const
Definition domain_indirect.h:695
rheolef::domain_indirect_basic< distributed >::set_broken
void set_broken(bool b)
Definition domain_indirect.h:719
rheolef::domain_indirect_basic< distributed >::size
size_type size() const
Definition domain_indirect.h:653
rheolef::domain_indirect_basic< distributed >::oige
const geo_element_indirect & oige(size_type ioige) const
Definition domain_indirect.h:725
rheolef::domain_indirect_basic< distributed >::is_broken
bool is_broken() const
Definition domain_indirect.h:713
rheolef::domain_indirect_basic< distributed >::const_iterator_ioige
rep::const_iterator_ioige const_iterator_ioige
Definition domain_indirect.h:568
rheolef::domain_indirect_basic< distributed >::ini_ioige2dis_ioige
size_type ini_ioige2dis_ioige(size_type ini_ioige) const
Definition domain_indirect.h:767
rheolef::domain_indirect_basic< distributed >::size_type
rep::size_type size_type
Definition domain_indirect.h:566
rheolef::domain_indirect_basic< distributed >::get
idiststream & get(idiststream &ips, const geo_rep< T, distributed > &omega)
Definition domain_indirect.h:672
rheolef::domain_indirect_basic< distributed >::ownership
const distributor & ownership() const
Definition domain_indirect.h:665
rheolef::domain_indirect_basic< sequential >::size
size_type size() const
Definition domain_indirect.h:444
rheolef::domain_indirect_basic< sequential >::name
std::string name() const
Definition domain_indirect.h:492
rheolef::domain_indirect_basic< sequential >::set_map_dimension
void set_map_dimension(size_type map_dim)
Definition domain_indirect.h:522
rheolef::domain_indirect_basic< sequential >::ioige_end
const_iterator_ioige ioige_end() const
Definition domain_indirect.h:474
rheolef::domain_indirect_basic< sequential >::resize
void resize(size_type n)
Definition domain_indirect.h:438
rheolef::domain_indirect_basic< sequential >::domain_indirect_basic
domain_indirect_basic()
Definition domain_indirect.h:410
rheolef::domain_indirect_basic< sequential >::set_name
void set_name(std::string name)
Definition domain_indirect.h:516
rheolef::domain_indirect_basic< sequential >::iterator_ioige
rep::iterator_ioige iterator_ioige
Definition domain_indirect.h:350
rheolef::domain_indirect_basic< sequential >::base
smart_pointer< rep > base
Definition domain_indirect.h:348
rheolef::domain_indirect_basic< sequential >::set_broken
void set_broken(bool b)
Definition domain_indirect.h:510
rheolef::domain_indirect_basic< sequential >::oige
const geo_element_indirect & oige(size_type ioige) const
Definition domain_indirect.h:462
rheolef::domain_indirect_basic< sequential >::is_broken
bool is_broken() const
Definition domain_indirect.h:504
rheolef::domain_indirect_basic< sequential >::const_iterator_ioige
rep::const_iterator_ioige const_iterator_ioige
Definition domain_indirect.h:351
rheolef::domain_indirect_basic< sequential >::dis_size
size_type dis_size() const
Definition domain_indirect.h:450
rheolef::domain_indirect_basic< sequential >::get
idiststream & get(idiststream &ips, const geo_rep< T, sequential > &omega, std::vector< index_set > *ball)
Definition domain_indirect.h:535
rheolef::domain_indirect_basic< sequential >::size_type
rep::size_type size_type
Definition domain_indirect.h:349
rheolef::domain_indirect_basic< sequential >::rep
domain_indirect_rep< sequential > rep
Definition domain_indirect.h:347
rheolef::domain_indirect_basic< sequential >::ioige_begin
const_iterator_ioige ioige_begin() const
Definition domain_indirect.h:468
rheolef::domain_indirect_basic< sequential >::map_dimension
size_type map_dimension() const
Definition domain_indirect.h:498
rheolef::domain_indirect_basic< sequential >::ownership
const distributor & ownership() const
Definition domain_indirect.h:456
rheolef::domain_indirect_basic
the finite element boundary domain
Definition domain_indirect.h:335
rheolef::domain_indirect_rep< distributed >::ioige2ini_dis_ioige
size_type ioige2ini_dis_ioige(size_type ioige) const
Definition domain_indirect.h:280
rheolef::domain_indirect_rep< distributed >::_ioige2ini_dis_ioige
disarray< size_type, distributed > _ioige2ini_dis_ioige
Definition domain_indirect.h:293
rheolef::domain_indirect_rep< distributed >::name
std::string name() const
Definition domain_indirect.h:272
rheolef::domain_indirect_rep< distributed >::dis_size
size_type dis_size() const
Definition domain_indirect.h:265
rheolef::domain_indirect_rep< distributed >::set_map_dimension
void set_map_dimension(size_type map_dim)
Definition domain_indirect.h:271
rheolef::domain_indirect_rep< distributed >::_ini_ioige2dis_ioige
disarray< size_type, distributed > _ini_ioige2dis_ioige
Definition domain_indirect.h:294
rheolef::domain_indirect_rep< distributed >::ini_ioige2dis_ioige
size_type ini_ioige2dis_ioige(size_type ini_ioige) const
Definition domain_indirect.h:281
rheolef::domain_indirect_rep< distributed >::const_iterator_ioige
base::const_iterator_ioige const_iterator_ioige
Definition domain_indirect.h:237
rheolef::domain_indirect_rep< distributed >::map_dimension
size_type map_dimension() const
Definition domain_indirect.h:273
rheolef::domain_indirect_rep< distributed >::size
size_type size() const
Definition domain_indirect.h:264
rheolef::domain_indirect_rep< distributed >::size_type
base::size_type size_type
Definition domain_indirect.h:235
rheolef::domain_indirect_rep< distributed >::set_name
void set_name(std::string name)
Definition domain_indirect.h:270
rheolef::domain_indirect_rep< distributed >::base
domain_indirect_base_rep< distributed > base
Definition domain_indirect.h:234
rheolef::domain_indirect_rep< distributed >::domain_indirect_rep
domain_indirect_rep()
Definition domain_indirect.h:297
rheolef::domain_indirect_rep< distributed >::ini_ownership
const distributor & ini_ownership() const
Definition domain_indirect.h:279
rheolef::domain_indirect_rep< distributed >::set_broken
void set_broken(bool b)
Definition domain_indirect.h:275
rheolef::domain_indirect_rep< distributed >::orientation_type
base::orientation_type orientation_type
Definition domain_indirect.h:238
rheolef::domain_indirect_rep< distributed >::oige
const geo_element_indirect & oige(size_type ioige) const
Definition domain_indirect.h:267
rheolef::domain_indirect_rep< distributed >::is_broken
bool is_broken() const
Definition domain_indirect.h:274
rheolef::domain_indirect_rep< distributed >::init_ios
void init_ios(const geo_abstract_rep< T, distributed > &omega)
Definition domain_indirect_mpi.cc:35
rheolef::domain_indirect_rep< distributed >::geo_rep
friend class geo_rep
Definition domain_indirect.h:291
rheolef::domain_indirect_rep< distributed >::iterator_ioige
base::iterator_ioige iterator_ioige
Definition domain_indirect.h:236
rheolef::domain_indirect_rep< sequential >::domain_indirect_rep
domain_indirect_rep(const std::string &name, size_type map_dim, const communicator &comm, const std::vector< size_type > &ie_list)
Definition domain_indirect.h:166
rheolef::domain_indirect_rep< sequential >::ioige_begin
iterator_ioige ioige_begin()
Definition domain_indirect.h:187
rheolef::domain_indirect_rep< sequential >::name
std::string name() const
Definition domain_indirect.h:195
rheolef::domain_indirect_rep< sequential >::dis_size
size_type dis_size() const
Definition domain_indirect.h:183
rheolef::domain_indirect_rep< sequential >::base
domain_indirect_base_rep< sequential > base
Definition domain_indirect.h:156
rheolef::domain_indirect_rep< sequential >::set_map_dimension
void set_map_dimension(size_type map_dim)
Definition domain_indirect.h:194
rheolef::domain_indirect_rep< sequential >::const_iterator_ioige
base::const_iterator_ioige const_iterator_ioige
Definition domain_indirect.h:159
rheolef::domain_indirect_rep< sequential >::map_dimension
size_type map_dimension() const
Definition domain_indirect.h:196
rheolef::domain_indirect_rep< sequential >::size
size_type size() const
Definition domain_indirect.h:182
rheolef::domain_indirect_rep< sequential >::resize
void resize(size_type n)
Definition domain_indirect.h:173
rheolef::domain_indirect_rep< sequential >::size_type
base::size_type size_type
Definition domain_indirect.h:157
rheolef::domain_indirect_rep< sequential >::set_name
void set_name(std::string name)
Definition domain_indirect.h:193
rheolef::domain_indirect_rep< sequential >::ioige_begin
const_iterator_ioige ioige_begin() const
Definition domain_indirect.h:185
rheolef::domain_indirect_rep< sequential >::ioige_end
const_iterator_ioige ioige_end() const
Definition domain_indirect.h:186
rheolef::domain_indirect_rep< sequential >::domain_indirect_rep
domain_indirect_rep()
Definition domain_indirect.h:164
rheolef::domain_indirect_rep< sequential >::set_broken
void set_broken(bool b)
Definition domain_indirect.h:198
rheolef::domain_indirect_rep< sequential >::orientation_type
base::orientation_type orientation_type
Definition domain_indirect.h:160
rheolef::domain_indirect_rep< sequential >::oige
const geo_element_indirect & oige(size_type ioige) const
Definition domain_indirect.h:190
rheolef::domain_indirect_rep< sequential >::is_broken
bool is_broken() const
Definition domain_indirect.h:197
rheolef::domain_indirect_rep< sequential >::ioige_end
iterator_ioige ioige_end()
Definition domain_indirect.h:188
rheolef::domain_indirect_rep< sequential >::iterator_ioige
base::iterator_ioige iterator_ioige
Definition domain_indirect.h:158
rheolef::domain_indirect_rep
Definition domain_indirect.h:148
rheolef::geo_abstract_rep
abstract interface class
Definition geo.h:401
rheolef::geo_basic
generic mesh with rerefence counting
Definition geo.h:1089
rheolef::geo_element_auto
Definition geo_element.h:376
rheolef::geo_element_indirect
Definition geo_element_indirect.h:32
rheolef::geo_element_indirect::size_type
size_t size_type
Definition geo_element_indirect.h:37
rheolef::geo_element_indirect::orientation_type
short int orientation_type
Definition geo_element_indirect.h:38
rheolef::geo_rep
sequential mesh representation
Definition geo.h:778
rheolef::idiststream
idiststream: see the diststream page for the full documentation
Definition diststream.h:336
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition diststream.h:137
rheolef::smart_pointer_base::data
const T & data() const
Definition smart_pointer.h:266
rheolef::smart_pointer< domain_indirect_rep< sequential > >::smart_pointer
smart_pointer(domain_indirect_rep< sequential > *p=0)
Definition smart_pointer.h:357
rheolef::domain_indirect
domain_indirect_basic< rheo_default_memory_model > domain_indirect
Definition domain_indirect.h:338
rheolef
This file is part of Rheolef.
Definition compiler_eigen.h:39
rheolef::put
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
Definition tiny_lu.h:155
rheolef::build_union
domain_indirect_basic< sequential > build_union(const geo_basic< T, sequential > &omega, const domain_indirect_basic< sequential > &a, const domain_indirect_basic< sequential > &b)
Definition domain_indirect.h:546
rheolef::distributed
Definition communicator.h:128
rheolef::sequential
Definition communicator.h:62
M
Expr1::memory_type M
Definition vec_expr_v2.h:416