geo_domain_indirect_seq.cc
Go to the documentation of this file.
#include "rheolef/geo_domain_indirect.h"
namespace rheolef {
template <class T, class M>
const distributor&
geo_domain_indirect_base_rep<T,M>::geo_element_ownership (size_type dim) const
{
if (dim == map_dimension()) return _indirect.ownership();
check_macro (dim < map_dimension(), "unexpected dimension = " << dim << " > domain dimension = " << map_dimension());
return _omega.geo_element_ownership(dim);
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::const_reference
geo_domain_indirect_base_rep<T,M>::get_geo_element (size_type dim, size_type ige) const
{
if (dim == map_dimension()) return _omega.get_geo_element (dim, _indirect.oige(ige).index());
return _omega.get_geo_element (dim, ige);
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::const_iterator_by_variant
geo_domain_indirect_base_rep<T,M>::begin_by_variant (variant_type variant) const
{
error_macro ("domain.begin: not yet");
return _omega.begin_by_variant (variant); // (not reached)
// Note: here, not valid for dim(variant)=map_dimension ; requires a proxy_reference
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::const_iterator_by_variant
geo_domain_indirect_base_rep<T,M>::end_by_variant (variant_type variant) const
{
error_macro ("domain.end: not yet");
return _omega.end_by_variant (variant); // (not reached)
// Note: here, not valid for dim(variant)=map_dimension ; requires a proxy_reference
}
template <class T, class M>
const typename geo_domain_indirect_base_rep<T,M>::geo_element_map_type&
geo_domain_indirect_base_rep<T,M>::get_external_geo_element_map (size_type variant) const
{
error_macro ("domain.get_external_geo_element_map: not yet");
static const geo_element_map_type dummy;
return dummy;
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::size_type
geo_domain_indirect_base_rep<T,M>::n_domain_indirect () const
{
return 0;
}
template <class T, class M>
bool
geo_domain_indirect_base_rep<T,M>::have_domain_indirect(const std::string& name) const
{
return false;
}
template <class T, class M>
const domain_indirect_basic<M>&
geo_domain_indirect_base_rep<T,M>::get_domain_indirect (size_type i) const
{
error_macro ("domain[domain] aka sub-sub-domain: not yet");
return _indirect; // not reached
}
template <class T, class M>
const domain_indirect_basic<M>&
geo_domain_indirect_base_rep<T,M>::get_domain_indirect (const std::string& name) const
{
error_macro ("domain[domain] aka sub-sub-domain: not yet");
return _indirect; // not reached
}
template <class T, class M>
void
geo_domain_indirect_base_rep<T,M>::insert_domain_indirect (const domain_indirect_basic<M>& dom) const
{
error_macro ("insert_domain_indirect: cannot insert inside another domain");
}
template <class T, class M>
odiststream&
geo_domain_indirect_base_rep<T,M>::put (odiststream& ops) const
{
error_macro ("domain.put_geo: not yet");
return ops;
}
template <class T, class M>
const geo_size&
geo_domain_indirect_base_rep<T,M>::sizes() const
{
return _omega.sizes();
}
template <class T, class M>
const geo_size&
geo_domain_indirect_base_rep<T,M>::ios_sizes() const
{
error_macro ("domain.ios_sizes: not yet");
return _omega.ios_sizes();
}
template <class T, class M>
const typename geo_domain_indirect_base_rep<T,M>::node_type&
geo_domain_indirect_base_rep<T,M>::dis_node (size_type dis_inod) const
{
return _omega.dis_node (dis_inod);
}
template <class T, class M>
void
geo_domain_indirect_base_rep<T,M>::dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const
{
_omega.dis_inod (K, dis_inod);
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::size_type
geo_domain_indirect_base_rep<T,M>::dis_inod2dis_iv (size_type dis_inod) const
{
return _omega.dis_inod2dis_iv (dis_inod);
}
template <class T, class M>
void
geo_domain_indirect_base_rep<T,M>::set_nodes (const disarray<node_type,M>&)
{
error_macro ("domain.set_node: cannot do that");
}
template <class T, class M>
bool
geo_domain_indirect_base_rep<T,M>::check(bool verbose) const
{
return true;
}
template <class T, class M>
void
geo_domain_indirect_base_rep<T,M>::reset_order (size_type order)
{
error_macro ("domain.reset_order: cannot do that");
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::size_type
geo_domain_indirect_base_rep<T,M>::seq_locate (const point_basic<T>&, size_type) const
{
error_macro ("domain.seq_locate: no implemented");
return std::numeric_limits<size_type>::max();
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::size_type
geo_domain_indirect_base_rep<T,M>::dis_locate (const point_basic<T>&, size_type) const
{
error_macro ("domain.dis_locate: no implemented");
return std::numeric_limits<size_type>::max();
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::size_type
geo_domain_indirect_base_rep<T,M>::seq_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const
{
error_macro ("domain.seq_trace_move: no implemented");
return std::numeric_limits<size_type>::max();
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::size_type
geo_domain_indirect_base_rep<T,M>::dis_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const
{
error_macro ("domain.dis_trace_move: no implemented");
return std::numeric_limits<size_type>::max();
}
template <class T, class M>
void
geo_domain_indirect_base_rep<T,M>::locate (
const disarray<point_basic<T>, M>& x,
disarray<size_type, M>& dis_ie,
bool do_check) const
{
error_macro ("domain.locate: no implemented");
}
template <class T, class M>
void
geo_domain_indirect_base_rep<T,M>::trace_ray_boundary (
const disarray<point_basic<T>,M>& x,
const disarray<point_basic<T>,M>& v,
disarray<size_type, M>& dis_ie,
disarray<point_basic<T>,M>& y,
bool do_check) const
{
error_macro ("domain.trace_ray_boundary: no implemented");
}
template <class T, class M>
void
geo_domain_indirect_base_rep<T,M>::trace_move (
const disarray<point_basic<T>,M>& x,
const disarray<point_basic<T>,M>& v,
disarray<size_type, M>& dis_ie,
disarray<point_basic<T>,M>& y) const
{
error_macro ("domain.trace_move: no implemented");
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::size_type
geo_domain_indirect_base_rep<T,M>::seq_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const
{
error_macro ("domain.seq_nearest: no implemented");
return std::numeric_limits<size_type>::max();
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::size_type
geo_domain_indirect_base_rep<T,M>::dis_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const
{
error_macro ("domain.dis_nearest: no implemented");
return std::numeric_limits<size_type>::max();
}
template <class T, class M>
void
geo_domain_indirect_base_rep<T,M>::nearest (
const disarray<point_basic<T>,M>& x,
disarray<point_basic<T>,M>& x_nearest,
disarray<size_type, M>& dis_ie) const
{
error_macro ("domain.nearest: no implemented");
}
template <class T, class M>
typename geo_domain_indirect_base_rep<T,M>::size_type
geo_domain_indirect_base_rep<T,M>::neighbour (size_type ie, size_type loc_iside) const
{
error_macro ("domain.neighbour: no implemented");
return std::numeric_limits<size_type>::max();
}
template <class T, class M>
void
geo_domain_indirect_base_rep<T,M>::neighbour_guard() const
{
error_macro ("domain.neighbour_guard: no implemented");
}
// ----------------------------------------------------------------------------
// instanciation in library
// ----------------------------------------------------------------------------
template class geo_domain_indirect_base_rep<Float,sequential>;
#ifdef _RHEOLEF_HAVE_MPI
template class geo_domain_indirect_base_rep<Float,distributed>;
#endif // _RHEOLEF_HAVE_MPI
template class geo_domain_indirect_rep<Float,sequential>;
} // namespace rheolef
rheolef::disarray< node_type, M >
rheolef::domain_indirect_basic< M >
rheolef::geo_domain_indirect_base_rep
Definition: geo_domain_indirect.h:64
rheolef::geo_domain_indirect_base_rep::variant_type
base::variant_type variant_type
Definition: geo_domain_indirect.h:70
rheolef::geo_domain_indirect_base_rep::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition: geo_domain_indirect.h:73
rheolef::geo_domain_indirect_base_rep::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition: geo_domain_indirect_seq.cc:27
rheolef::geo_domain_indirect_base_rep::dis_inod
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition: geo_domain_indirect_seq.cc:124
rheolef::geo_domain_indirect_base_rep::end_by_variant
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition: geo_domain_indirect_seq.cc:50
rheolef::geo_domain_indirect_base_rep::begin_by_variant
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition: geo_domain_indirect_seq.cc:42
rheolef::geo_domain_indirect_base_rep::dis_node
const node_type & dis_node(size_type dis_inod) const
Definition: geo_domain_indirect_seq.cc:118
rheolef::geo_domain_indirect_base_rep::insert_domain_indirect
void insert_domain_indirect(const domain_indirect_basic< M > &dom) const
Definition: geo_domain_indirect_seq.cc:92
rheolef::geo_domain_indirect_base_rep::get_domain_indirect
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
Definition: geo_domain_indirect_seq.cc:78
rheolef::geo_domain_indirect_base_rep::dis_nearest
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo_domain_indirect_seq.cc:227
rheolef::geo_domain_indirect_base_rep::dis_trace_move
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo_domain_indirect_seq.cc:178
rheolef::geo_domain_indirect_base_rep::ios_sizes
const geo_size & ios_sizes() const
Definition: geo_domain_indirect_seq.cc:111
rheolef::geo_domain_indirect_base_rep::dis_locate
size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo_domain_indirect_seq.cc:161
rheolef::geo_domain_indirect_base_rep::put
odiststream & put(odiststream &ops) const
Definition: geo_domain_indirect_seq.cc:98
rheolef::geo_domain_indirect_base_rep::size_type
base::size_type size_type
Definition: geo_domain_indirect.h:68
rheolef::geo_domain_indirect_base_rep::set_nodes
void set_nodes(const disarray< node_type, M > &)
Definition: geo_domain_indirect_seq.cc:136
rheolef::geo_domain_indirect_base_rep::seq_locate
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo_domain_indirect_seq.cc:154
rheolef::geo_domain_indirect_base_rep::const_reference
base::const_reference const_reference
Definition: geo_domain_indirect.h:71
rheolef::geo_domain_indirect_base_rep::check
bool check(bool verbose) const
Definition: geo_domain_indirect_seq.cc:142
rheolef::geo_domain_indirect_base_rep::n_domain_indirect
size_type n_domain_indirect() const
Definition: geo_domain_indirect_seq.cc:66
rheolef::geo_domain_indirect_base_rep::seq_nearest
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo_domain_indirect_seq.cc:218
rheolef::geo_domain_indirect_base_rep::trace_move
void trace_move(const disarray< point_basic< T >, M > &x, const disarray< point_basic< T >, M > &v, disarray< size_type, M > &dis_ie, disarray< point_basic< T >, M > &y) const
Definition: geo_domain_indirect_seq.cc:208
rheolef::geo_domain_indirect_base_rep::neighbour
size_type neighbour(size_type ie, size_type loc_iside) const
Definition: geo_domain_indirect_seq.cc:245
rheolef::geo_domain_indirect_base_rep::dis_inod2dis_iv
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition: geo_domain_indirect_seq.cc:130
rheolef::geo_domain_indirect_base_rep::geo_element_map_type
base::geo_element_map_type geo_element_map_type
Definition: geo_domain_indirect.h:76
rheolef::geo_domain_indirect_base_rep::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo_domain_indirect_seq.cc:35
rheolef::geo_domain_indirect_base_rep::sizes
const geo_size & sizes() const
Definition: geo_domain_indirect_seq.cc:105
rheolef::geo_domain_indirect_base_rep::reset_order
void reset_order(size_type order)
Definition: geo_domain_indirect_seq.cc:148
rheolef::geo_domain_indirect_base_rep::trace_ray_boundary
void trace_ray_boundary(const disarray< point_basic< T >, M > &x, const disarray< point_basic< T >, M > &v, disarray< size_type, M > &dis_ie, disarray< point_basic< T >, M > &y, bool do_check=false) const
Definition: geo_domain_indirect_seq.cc:197
rheolef::geo_domain_indirect_base_rep::seq_trace_move
size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo_domain_indirect_seq.cc:168
rheolef::geo_domain_indirect_base_rep::have_domain_indirect
bool have_domain_indirect(const std::string &name) const
Definition: geo_domain_indirect_seq.cc:72
rheolef::geo_domain_indirect_base_rep::nearest
void nearest(const disarray< point_basic< T >, M > &x, disarray< point_basic< T >, M > &x_nearest, disarray< size_type, M > &dis_ie) const
Definition: geo_domain_indirect_seq.cc:236
rheolef::geo_domain_indirect_base_rep::locate
void locate(const disarray< point_basic< T >, M > &x, disarray< size_type, M > &dis_ie, bool do_check=false) const
Definition: geo_domain_indirect_seq.cc:188
rheolef::geo_domain_indirect_base_rep::get_external_geo_element_map
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition: geo_domain_indirect_seq.cc:58
rheolef::geo_domain_indirect_base_rep::neighbour_guard
void neighbour_guard() const
Definition: geo_domain_indirect_seq.cc:252
rheolef::geo_domain_indirect_base_rep::node_type
base::node_type node_type
Definition: geo_domain_indirect.h:69
rheolef::geo_domain_indirect_rep
Definition: geo_domain_indirect.h:208
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
rheolef::point_basic
Definition: point.h:87
rheolef::dummy
static iorheo::force_initialization dummy
Definition: iorheo.cc:147
error_macro
#define error_macro(message)
Definition: dis_macros.h:49
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
mkgeo_ball.variant
int variant
Definition: mkgeo_ball.sh:149
mkgeo_ball.order
order
Definition: mkgeo_ball.sh:343
mkgeo_ball.verbose
verbose
Definition: mkgeo_ball.sh:133
mkgeo_ball.dim
int dim
Definition: mkgeo_ball.sh:307
mkgeo_contraction.name
string name
Definition: mkgeo_contraction.sh:133
rheolef::space_numbering::dis_inod
void dis_inod(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_inod_tab)
Definition: space_numbering.cc:177
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::geo_size
Definition: geo_size.h:29
M
Expr1::memory_type M
Definition: vec_expr_v2.h:416