Loading...
Searching...
No Matches
geo.h
Go to the documentation of this file.
#ifndef _RHEOLEF_GEO_H
#define _RHEOLEF_GEO_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
//
// =========================================================================
// author: Pierre.Saramito@imag.fr
// date: 20 april 2013
namespace rheolef {
} // namespace rheolef
/*
Implementation note: geo = mesh data structure
geo is an alias to geo_basic<T,M>
T: the current Float representation (e.g. double)
M: the memory model (sequential or distributed)
the default memory model has been chosen by the configure script
geo_basic<T,M> is a smart_pointer_clone<geo_abstract_rep<T,M> >
i.e. a pointer with shallow copy semantic on a pure virtual base class geo_abstract_rep<T,M>
used by polymorphic hierarchy of classes.
there are three concrete variants for this base class:
geo_rep<T,M> : for usual meshes, as omega
geo_domain_indirect_rep<T,M> : for usual boundary domains, as gamma=omega["boundary"]
geo_domain_rep<T,M> : for compacted boundary domains, as gamma=omega["boundary"]
used when defining a space on a boundary domain, as
space W (omega["boundary"], "P1");
=> elements and vertex are renumbered in a compact form
for easy P1 dofs numbering.
Most code is shared by these three classes and by the sequential/distributed variants.
This leads to the following hierarchy of classes:
geo_abstract_base_rep<T> : virtual methods for M=seq
geo_abstract_rep<T,M> : M=seq,dis have separated impl; add methods for M=dis
geo_domain_indirect_base_rep<T,M>: data + methods for domains
geo_domain_indirect_rep<T,M> : M=seq,dis have separated impl; add methods for M=dis
geo_base_rep<T,M> : data + methods for geometry
geo_rep<T,M> : M=seq,dis have separated impl: add methods for M=dis
geo_domain_rep<T,M> : data + methods for compacted geometry on domain
*/
#include "rheolef/iorheo.h"
#include "rheolef/diststream.h"
#include "rheolef/linalg.h"
#include "rheolef/basis.h"
#include "rheolef/hack_array.h"
#include "rheolef/geo_size.h"
#include "rheolef/domain_indirect.h"
#include "rheolef/geo_header.h"
#include "rheolef/space_constant.h"
#include "rheolef/geo_locate.h"
#include "rheolef/geo_trace_ray_boundary.h"
#include "rheolef/geo_nearest.h"
#include "rheolef/rounder.h"
#include <unordered_map>
namespace rheolef {
namespace details {
struct zero_dimension {}; // used by space IR
} // namespace details
// =========================================================================
// point io helpers
// =========================================================================
template <class T>
struct _point_get {
typedef typename point_basic<T>::size_type size_type;
_point_get (size_type d1) : d(d1) {}
size_type d;
std::istream& operator() (std::istream& is, point_basic<T>& x) { return x.get (is, d); }
};
template <class T>
struct _point_put {
typedef typename point_basic<T>::size_type size_type;
_point_put (size_type d1) : d(d1) {}
size_type d;
std::ostream& operator() (std::ostream& os, const point_basic<T>& x) { return x.put (os, d); }
};
template <class T>
struct _round_point_put {
typedef typename point_basic<T>::size_type size_type;
_round_point_put (size_type d1, const T& eps1) : d(d1), round(eps1) {}
size_type d;
rounder_type<T> round;
std::ostream& operator() (std::ostream& os, const point_basic<T>& x) {
for (size_t i = 0; i < d; ++i) {
os << round(x[i]);
if (i+1 != d) os << " ";
}
return os;
}
};
// forward declaration:
template <class T, class M> class geo_basic;
template <class T, class M> class geo_domain_indirect_rep;
// =========================================================================
// =========================================================================
template<class T, class Ref, class Ptr, class IteratorByVariant>
struct geo_iterator {
typedef geo_iterator<T,Ref,Ptr,IteratorByVariant> _self;
typedef geo_iterator<T,T&,T*,typename hack_array<T>::iterator> _nonconst_iterator;
// typedefs
// see std::deque<T>::iterator : TODO: complete to a full random iterator
typedef std::random_access_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef typename T::size_type size_type;
typedef ptrdiff_t difference_type;
// allocators:
template<class Geo>
geo_iterator (size_type dim, size_type variant, IteratorByVariant iter, Geo& omega);
geo_iterator (const _nonconst_iterator& y); // conversion from iter to const_iter
// accessors & modifiers:
reference operator* () const { return *_iter_by_var; }
pointer operator->() const { return _iter_by_var.operator->(); }
_self& operator++ () {
++_iter_by_var;
_reset_to_next_or_last();
return *this;
}
void _reset_to_next_or_last () {
while (_variant < _variant_max && _iter_by_var == _last_by_var [_variant]) {
++_variant; // then variant <= variant_max
if (_variant < _variant_max) {
_iter_by_var = _first_by_var [_variant];
}
}
}
_self operator++ (int) { _self tmp = *this; operator++(); return tmp; }
bool operator== (const _self& y) const { return _variant == y._variant && _iter_by_var == y._iter_by_var; }
bool operator!= (const _self& y) const { return ! operator== (y); }
// data:
size_type _variant;
size_type _variant_max;
IteratorByVariant _iter_by_var;
IteratorByVariant _first_by_var [reference_element::max_variant];
IteratorByVariant _last_by_var [reference_element::max_variant];
};
// =========================================================================
// =========================================================================
template <class T>
class geo_abstract_base_rep {
public:
// typedefs
typedef enum {
geo = 0,
geo_domain = 1,
geo_domain_indirect = 2,
max_variant = 3
} geo_rep_variant_type;
typedef geo_element_hack::size_type size_type;
typedef point_basic<T> node_type;
typedef reference_element::variant_type variant_type;
typedef geo_element& reference;
typedef const geo_element& const_reference;
typedef space_constant::coordinate_type coordinate_type;
typedef std::map<size_type,geo_element_auto<>> geo_element_map_type;
typedef typename hack_array<geo_element_hack>::iterator
iterator_by_variant;
typedef geo_iterator<
geo_element,
geo_element&,
geo_element*,
iterator_by_variant>
iterator;
typedef typename hack_array<geo_element_hack>::const_iterator
const_iterator_by_variant;
typedef geo_iterator<
geo_element,
const geo_element&,
const geo_element*,
const_iterator_by_variant>
const_iterator;
// allocators:
geo_abstract_base_rep () {}
virtual ~geo_abstract_base_rep () {}
// abstract accessors:
virtual size_type variant() const = 0;
virtual std::string name() const = 0;
virtual std::string familyname() const = 0;
virtual size_type dimension() const = 0;
virtual size_type serial_number() const = 0;
virtual size_type map_dimension() const = 0;
virtual bool is_broken() const = 0;
virtual coordinate_type coordinate_system() const = 0;
virtual const basis_basic<T>& get_piola_basis() const = 0;
virtual const node_type& xmin() const = 0;
virtual const node_type& xmax() const = 0;
virtual const T& hmin() const = 0;
virtual const T& hmax() const = 0;
virtual const geo_size& sizes() const = 0;
virtual const geo_size& ios_sizes() const = 0;
virtual const distributor& geo_element_ownership (size_type dim) const = 0;
virtual const_reference get_geo_element (size_type dim, size_type ige) const = 0;
virtual const geo_element& bgd2dom_geo_element (const geo_element& bgd_K) const { return bgd_K; }
virtual const geo_element& dom2bgd_geo_element (const geo_element& dom_K) const { return dom_K; }
virtual size_type neighbour (size_type ie, size_type loc_isid) const = 0;
virtual void neighbour_guard() const = 0;
virtual const_iterator_by_variant begin_by_variant (variant_type variant) const = 0;
virtual const_iterator_by_variant end_by_variant (variant_type variant) const = 0;
virtual const geo_element_map_type& get_external_geo_element_map (size_type variant) const = 0;
const_iterator begin (size_type dim) const;
const_iterator end (size_type dim) const;
virtual size_type n_node() const = 0;
virtual const node_type& node (size_type inod) const = 0;
virtual const node_type& dis_node (size_type dis_inod) const = 0;
virtual void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const = 0;
virtual size_type dis_inod2dis_iv (size_type dis_inod) const = 0;
virtual size_type n_domain_indirect () const = 0;
virtual bool have_domain_indirect (const std::string& name) const = 0;
virtual void reset_order (size_type order) = 0;
virtual size_type seq_locate (
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const = 0;
virtual size_type dis_locate (
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const = 0;
virtual size_type seq_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const = 0;
virtual size_type dis_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const = 0;
virtual size_type seq_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const = 0;
virtual size_type dis_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const = 0;
// virtual i/o:
virtual odiststream& put (odiststream& ops) const = 0;
virtual bool check(bool verbose) const = 0;
// deduced comparator:
bool operator== (const geo_abstract_base_rep<T>& omega2) const {
return name() == omega2.name(); }
};
template<class T, class Ref, class Ptr, class IteratorByVariant>
template<class Geo>
geo_iterator<T,Ref,Ptr,IteratorByVariant>::geo_iterator (
size_type dim,
size_type variant,
IteratorByVariant iter,
Geo& omega)
: _variant (variant),
_variant_max (reference_element::last_variant_by_dimension(dim)),
_iter_by_var (iter),
_first_by_var(),
_last_by_var()
{
for (size_type variant = reference_element::first_variant_by_dimension(dim);
variant < reference_element::last_variant_by_dimension(dim); variant++) {
_first_by_var [variant] = omega.begin_by_variant (variant);
_last_by_var [variant] = omega. end_by_variant (variant);
}
_reset_to_next_or_last();
}
template<class T, class Ref, class Ptr, class IteratorByVariant>
geo_iterator<T,Ref,Ptr,IteratorByVariant>::geo_iterator (const _nonconst_iterator& y)
: _variant (y._variant),
_variant_max (y._variant_max),
_iter_by_var (y._iter_by_var),
_first_by_var(),
_last_by_var()
{
std::copy (y._first_by_var, y._first_by_var + reference_element::max_variant, _first_by_var);
std::copy (y. _last_by_var, y. _last_by_var + reference_element::max_variant, _last_by_var);
}
// =========================================================================
// =========================================================================
template <class T, class M>
class geo_abstract_rep {};
template <class T>
class geo_abstract_rep<T,sequential> : public geo_abstract_base_rep<T> {
public:
// typedefs
typedef geo_abstract_base_rep<T> base;
typedef typename base::size_type size_type;
typedef typename base::node_type node_type;
typedef typename base::variant_type variant_type;
typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator;
typedef typename base::iterator_by_variant iterator_by_variant;
typedef typename base::const_iterator_by_variant const_iterator_by_variant;
typedef typename base::reference reference;
typedef typename base::const_reference const_reference;
// allocators:
geo_abstract_rep () {}
virtual geo_abstract_rep<T,sequential>* clone() const = 0;
virtual ~geo_abstract_rep () {}
// abstract accessors:
virtual const domain_indirect_basic<sequential>& get_domain_indirect (size_type i) const = 0;
virtual const domain_indirect_basic<sequential>& get_domain_indirect (const std::string& name) const = 0;
virtual void insert_domain_indirect (const domain_indirect_basic<sequential>& dom) const = 0;
virtual const disarray<node_type,sequential>& get_nodes() const = 0;
virtual void set_nodes (const disarray<node_type,sequential>&) = 0;
virtual void locate (
const disarray<point_basic<T>, sequential>& x,
disarray<size_type, sequential>& dis_ie,
bool do_check = false) const = 0;
virtual void trace_ray_boundary (
const disarray<point_basic<T>,sequential>& x,
const disarray<point_basic<T>,sequential>& v,
disarray<size_type, sequential>& dis_ie,
disarray<point_basic<T>,sequential>& y,
bool do_check = false) const = 0;
virtual void trace_move (
const disarray<point_basic<T>,sequential>& x,
const disarray<point_basic<T>,sequential>& v,
disarray<size_type, sequential>& dis_ie,
disarray<point_basic<T>,sequential>& y) const = 0;
virtual void nearest (
const disarray<point_basic<T>,sequential>& x,
disarray<point_basic<T>,sequential>& x_nearest,
disarray<size_type, sequential>& dis_ie) const = 0;
};
#ifdef _RHEOLEF_HAVE_MPI
template <class T>
class geo_abstract_rep<T,distributed> : public geo_abstract_base_rep<T> {
public:
// typedefs
typedef geo_abstract_base_rep<T> base;
typedef typename base::size_type size_type;
typedef typename base::node_type node_type;
typedef typename base::const_reference const_reference;
typedef std::map <size_type, node_type, std::less<size_type>,
heap_allocator<std::pair<size_type,node_type> > > node_map_type;
// allocators:
geo_abstract_rep () {}
virtual geo_abstract_rep<T,distributed>* clone() const = 0;
virtual ~geo_abstract_rep () {}
// abstract accessors:
virtual distributor geo_element_ios_ownership (size_type dim) const = 0;
virtual const_reference dis_get_geo_element (size_type dim, size_type dis_ige) const = 0;
virtual size_type ige2ios_dis_ige (size_type dim, size_type ige) const = 0;
virtual size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const = 0;
virtual size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const = 0;
virtual const domain_indirect_basic<distributed>& get_domain_indirect (size_type i) const = 0;
virtual const domain_indirect_basic<distributed>& get_domain_indirect (const std::string& name) const = 0;
virtual void insert_domain_indirect (const domain_indirect_basic<distributed>& dom) const = 0;
virtual const disarray<node_type,distributed>& get_nodes() const = 0;
virtual void set_nodes (const disarray<node_type,distributed>&) = 0;
virtual void locate (
const disarray<point_basic<T>,distributed>& x,
disarray<size_type, distributed>& dis_ie,
bool do_check = true) const = 0;
virtual void trace_ray_boundary (
const disarray<point_basic<T>,distributed>& x,
const disarray<point_basic<T>,distributed>& v,
disarray<size_type, distributed>& dis_ie,
disarray<point_basic<T>,distributed>& y,
bool do_check = false) const = 0;
virtual void trace_move (
const disarray<point_basic<T>,distributed>& x,
const disarray<point_basic<T>,distributed>& v,
disarray<size_type, distributed>& dis_ie,
disarray<point_basic<T>,distributed>& y) const = 0;
virtual void nearest (
const disarray<point_basic<T>,distributed>& x,
disarray<point_basic<T>,distributed>& x_nearest,
disarray<size_type, distributed>& dis_ie) const = 0;
// utility:
virtual void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof) const = 0;
// used by space_constritution for ios numbering
virtual const std::array<disarray<size_type,distributed>,reference_element::max_variant>&
get_igev2ios_dis_igev() const = 0;
};
#endif // _RHEOLEF_HAVE_MPI
// =========================================================================
// =========================================================================
// NOTE: since geo_rep<seq> contains sequential arrays for vertices and elts,
// the geo_rep<mpi> cannot derive from geo_rep<seq>. The solution is to
// derive both geo_rep<seq> and geo_rep<mpi> classes from a generic base class
// named geo_base_rep that takes the memory model (seq or mpi) as template argument.
template <class T, class M>
class geo_base_rep : public geo_abstract_rep<T,M> {
public:
// typedefs:
typedef geo_abstract_rep<T,M> base;
typedef typename base::size_type size_type;
typedef typename base::node_type node_type;
typedef typename base::variant_type variant_type;
typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator;
typedef typename base::iterator_by_variant iterator_by_variant;
typedef typename base::const_iterator_by_variant const_iterator_by_variant;
typedef typename base::reference reference;
typedef typename base::const_reference const_reference;
typedef typename base::coordinate_type coordinate_type;
// allocators:
geo_base_rep ();
geo_base_rep (const geo_base_rep<T,M>&);
void build_from_list (
const geo_basic<T,M>& lambda,
const disarray<point_basic<T>,M>& node_list,
const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,M>,
reference_element::max_variant>& elt_list);
~geo_base_rep();
// abstract accessors defined:
size_type variant() const { return geo_abstract_base_rep<T>::geo; }
std::string familyname() const { return _name; }
std::string name() const;
size_type serial_number() const { return _serial_number; }
size_type dimension() const { return _dimension; }
size_type map_dimension() const { return _gs.map_dimension(); }
bool is_broken() const { return false; }
coordinate_type coordinate_system() const { return _sys_coord; }
void set_coordinate_system (coordinate_type sys_coord) { _sys_coord = sys_coord; }
void set_name (std::string name) { _name = name; }
void set_dimension (size_type dim) { _dimension = dim; }
void set_serial_number(size_type i) { _serial_number = i; }
const basis_basic<T>& get_piola_basis() const { return _piola_basis; }
const node_type& xmin() const { return _xmin; }
const node_type& xmax() const { return _xmax; }
const T& hmin() const { return _hmin; }
const T& hmax() const { return _hmax; }
const geo_size& sizes() const { return _gs; }
const geo_size& ios_sizes() const { return _gs; }
const distributor& geo_element_ownership (size_type dim) const { return _gs.ownership_by_dimension[dim]; }
const_reference get_geo_element (size_type dim, size_type ige) const;
const_reference dis_get_geo_element (size_type dim, size_type dis_ige) const;
const_iterator_by_variant begin_by_variant (variant_type variant) const;
iterator_by_variant begin_by_variant (variant_type variant);
const_iterator_by_variant end_by_variant (variant_type variant) const;
iterator_by_variant end_by_variant (variant_type variant);
const node_type& node (size_type inod) const { return _node [inod]; }
const node_type& dis_node (size_type dis_inod) const { return _node.dis_at (dis_inod); }
const node_type& node (const geo_element& K, size_type loc_inod) const;
void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const;
const disarray<node_type,M>& get_nodes() const { return _node; }
void set_nodes (const disarray<node_type,M>& x) { _node = x; _node.reset_dis_indexes(); compute_bbox(); }
size_type n_domain_indirect () const { return _domains.size(); }
bool have_domain_indirect (const std::string& name) const;
const domain_indirect_basic<M>& get_domain_indirect (size_type i) const { return _domains[i]; }
const domain_indirect_basic<M>& get_domain_indirect (const std::string& name) const;
void insert_domain_indirect (const domain_indirect_basic<M>& dom) const;
size_type seq_locate (
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const;
size_type dis_locate (
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const;
size_type seq_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const;
size_type dis_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const;
size_type seq_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const;
size_type dis_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const;
size_type neighbour (size_type ie, size_type loc_isid) const;
void neighbour_guard() const;
// additional accessors & modifier:
reference get_geo_element (size_type dim, size_type ige);
iterator begin (size_type dim);
iterator end (size_type dim);
// deduced accessors:
size_type size(size_type dim) const;
size_type dis_size(size_type dim) const;
const distributor& ownership() const { return geo_element_ownership (map_dimension()); }
const distributor& vertex_ownership() const { return geo_element_ownership (0); }
const communicator& comm() const { return ownership().comm(); }
size_type order() const { return get_piola_basis().degree(); }
size_type n_node() const { return _node. size(); }
size_type dis_n_node() const { return _node.dis_size(); }
size_type n_vertex() const { return size (0); }
size_type size() const { return size (map_dimension()); }
size_type dis_n_vertex() const { return dis_size (0); }
size_type dis_size() const { return dis_size (map_dimension()); }
size_type dis_n_edge() const { return dis_size (1); }
size_type dis_n_face() const { return dis_size (2); }
size_type dis_inod2dis_iv (size_type dis_inod) const;
size_type dis_iv2dis_inod (size_type dis_iv) const;
const_reference operator[] (size_type ie) const { return get_geo_element (map_dimension(), ie); }
reference operator[] (size_type ie) { return get_geo_element (map_dimension(), ie); }
const_iterator begin (size_type dim) const { return base::begin (dim); }
const_iterator end (size_type dim) const { return base::end (dim); }
const_iterator begin() const { return base::begin (map_dimension()); }
const_iterator end() const { return base::end (map_dimension()); }
const_iterator begin_edge() const { return base::begin (1); }
const_iterator end_edge() const { return base::end (1); }
const_iterator begin_face() const { return base::begin (2); }
const_iterator end_face() const { return base::end (2); }
protected:
void compute_bbox();
void init_neighbour() const;
template<class U> friend void add_ball_externals (const geo_base_rep<U,M>&, const disarray<index_set,M>&);
friend class geo_rep<T,M>;
// data:
// 0) header:
std::string _name;
size_type _version;
size_type _serial_number;
// 1) connectivity:
std::array<hack_array<geo_element_hack,M>, reference_element::max_variant> _geo_element;
geo_size _gs; // counters by geo_element dimension: 0,1,2,3
mutable std::vector<domain_indirect_basic<M> > _domains;
bool _have_connectivity; // e.g.list of edges in a 2d triangular mesh
mutable bool _have_neighbour; // inter-element connectivity
// 2) coordinates:
disarray<node_type, M> _node;
size_type _dimension;
coordinate_type _sys_coord;
node_type _xmin; // bounding box
node_type _xmax;
T _hmin;
T _hmax;
basis_basic<T> _piola_basis;
geo_locate<T,M> _locator;
geo_trace_ray_boundary<T,M> _tracer_ray_boundary;
geo_nearest<T,M> _nearestor;
// static data member: loaded geo table
public:
typedef std::unordered_map<std::string,void*> loaded_map_t;
static loaded_map_t& loaded_map();
protected:
static loaded_map_t _loaded_map;
};
template <class T, class M>
inline
void
geo_base_rep<T,M>::neighbour_guard() const
{
if (_have_neighbour) return;
_have_neighbour = true;
init_neighbour();
}
template <class T, class M>
typename geo_base_rep<T,M>::iterator_by_variant
geo_base_rep<T,M>::begin_by_variant (variant_type variant)
{
return _geo_element [variant].begin();
}
template <class T, class M>
typename geo_base_rep<T,M>::const_iterator_by_variant
geo_base_rep<T,M>::begin_by_variant (variant_type variant) const
{
return _geo_element [variant].begin();
}
template <class T, class M>
typename geo_base_rep<T,M>::iterator_by_variant
geo_base_rep<T,M>::end_by_variant (variant_type variant)
{
return _geo_element [variant].end();
}
template <class T, class M>
typename geo_base_rep<T,M>::const_iterator_by_variant
geo_base_rep<T,M>::end_by_variant (variant_type variant) const
{
return _geo_element [variant].end();
}
template <class T, class M>
inline
typename geo_base_rep<T,M>::iterator
geo_base_rep<T,M>::begin (size_type dim)
{
variant_type variant = reference_element::first_variant_by_dimension(dim);
iterator_by_variant iter = begin_by_variant (variant);
iterator res = iterator (dim, variant, iter, *this);
return res;
}
template <class T, class M>
inline
typename geo_base_rep<T,M>::iterator
geo_base_rep<T,M>::end (size_type dim)
{
variant_type variant = reference_element::last_variant_by_dimension(dim);
iterator_by_variant iter = end_by_variant (variant - 1);
iterator res = iterator (dim, variant, iter, *this);
return res;
}
template <class T>
inline
typename geo_abstract_base_rep<T>::const_iterator
geo_abstract_base_rep<T>::begin (size_type dim) const
{
variant_type variant = reference_element::first_variant_by_dimension(dim);
const_iterator_by_variant iter = begin_by_variant (variant);
return const_iterator (dim, variant, iter, *this);
}
template <class T>
inline
typename geo_abstract_base_rep<T>::const_iterator
geo_abstract_base_rep<T>::end (size_type dim) const
{
variant_type variant = reference_element::last_variant_by_dimension(dim);
const_iterator_by_variant iter = end_by_variant (variant - 1);
return const_iterator (dim, variant, iter, *this);
}
// =========================================================================
// =========================================================================
template <class T, class M> class geo_rep {};
template <class T, class M>
void geo_build_by_subdividing (
geo_rep <T,M>& new_omega,
const geo_basic<T,M>& old_omega,
typename geo_rep<T,M>::size_type k);
template <class T>
class geo_rep<T,sequential> : public geo_base_rep<T,sequential> {
public:
// typedefs:
typedef geo_base_rep<T,sequential> base;
typedef typename base::size_type size_type;
typedef typename base::node_type node_type;
typedef typename base::variant_type variant_type;
typedef typename base::reference reference;
typedef typename base::const_reference const_reference;
typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator;
typedef typename base::iterator_by_variant iterator_by_variant;
typedef typename base::const_iterator_by_variant const_iterator_by_variant;
typedef typename base::coordinate_type coordinate_type;
typedef typename base::geo_element_map_type geo_element_map_type;
// allocators:
geo_rep();
geo_rep (const geo_rep<T,sequential>&);
geo_abstract_rep<T,sequential>* clone() const;
// build from_list (for level set)
geo_rep (
const geo_basic<T,sequential>& lambda,
const disarray<point_basic<T>,sequential>& node_list,
const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,sequential>,
reference_element::max_variant>& elt_list);
void build_from_domain (
const domain_indirect_rep<sequential>& indirect,
const geo_abstract_rep<T,sequential>& omega,
std::map<size_type,size_type>& bgd_ie2dom_ie,
std::map<size_type,size_type>& dis_bgd_ie2dis_dom_ie);
// abstract accessors redefined:
void locate (
const disarray<point_basic<T>, sequential>& x,
disarray<size_type, sequential>& dis_ie,
bool do_check = false) const;
void trace_ray_boundary (
const disarray<point_basic<T>,sequential>& x,
const disarray<point_basic<T>,sequential>& v,
disarray<size_type, sequential>& dis_ie,
disarray<point_basic<T>,sequential>& y,
bool do_check = false) const;
void trace_move (
const disarray<point_basic<T>,sequential>& x,
const disarray<point_basic<T>,sequential>& v,
disarray<size_type, sequential>& dis_ie,
disarray<point_basic<T>,sequential>& y) const;
void nearest (
const disarray<point_basic<T>,sequential>& x,
disarray<point_basic<T>,sequential>& x_nearest,
disarray<size_type, sequential>& dis_ie) const;
// herited accessors:
size_type map_dimension () const { return base::map_dimension(); }
bool is_broken() const { return base::is_broken(); }
const distributor& geo_element_ownership(size_type dim) const { return base::geo_element_ownership (dim); }
const_reference get_geo_element (size_type dim, size_type ige) const { return base::get_geo_element (dim, ige); }
reference get_geo_element (size_type dim, size_type ige) { return base::get_geo_element (dim, ige); }
iterator begin (size_type dim) { return base::begin(dim); }
iterator end (size_type dim) { return base::end (dim); }
const_iterator begin (size_type dim) const { return base::begin(dim); }
const_iterator end (size_type dim) const { return base::end (dim); }
const geo_element_map_type& get_external_geo_element_map (size_type variant) const;
const domain_indirect_basic<sequential>& get_domain_indirect (size_type idom) const { return base::get_domain_indirect (idom); }
const domain_indirect_basic<sequential>& get_domain_indirect (const std::string& name) const { return base::get_domain_indirect (name); }
// deduced accessors:
const distributor& vertex_ownership() const { return geo_element_ownership(0); }
const_reference operator[] (size_type ie) const { return get_geo_element (map_dimension(), ie); }
reference operator[] (size_type ie) { return get_geo_element (map_dimension(), ie); }
// i/o:
idiststream& get (idiststream&);
odiststream& put_geo (odiststream&) const;
odiststream& put (odiststream& ops) const { return put_geo(ops); }
void dump (std::string name) const;
void load (std::string name, const communicator& = communicator());
bool check(bool verbose) const;
// modifier:
void reset_order (size_type order);
void build_by_subdividing (const geo_basic<T,sequential>& omega, size_type k);
void build_from_data (
const geo_header& hdr,
const disarray<node_type, sequential>& node,
std::array<disarray<geo_element_auto<>,sequential>, reference_element::max_variant>&
tmp_geo_element,
bool do_upgrade);
// internal:
protected:
idiststream& get_standard (idiststream&, const geo_header&);
idiststream& get_upgrade (idiststream&, const geo_header&);
void build_connectivity (
std::array<disarray<geo_element_auto<>,sequential>, reference_element::max_variant>& tmp_geo_element);
void build_connectivity_sides (
size_type side_dim,
std::array<disarray<geo_element_auto<>,sequential>, reference_element::max_variant>& tmp_geo_element);
void set_element_side_index (size_type side_dim);
void domain_set_side_part1 (
const domain_indirect_rep<sequential>& indirect,
const geo_abstract_rep<T,sequential>& bgd_omega,
size_type sid_dim,
disarray<size_type,sequential>& bgd_isid2dom_dis_isid,
disarray<size_type,sequential>& dom_isid2bgd_isid,
disarray<size_type,sequential>& dom_isid2dom_ios_dis_isid,
size_type size_by_variant [reference_element::max_variant]);
void domain_set_side_part2 (
const domain_indirect_rep<sequential>& indirect,
const geo_abstract_rep<T,sequential>& bgd_omega,
disarray<size_type,sequential>& bgd_iv2dom_dis_iv,
size_type sid_dim,
disarray<size_type,sequential>& bgd_isid2dom_dis_isid,
disarray<size_type,sequential>& dom_isid2bgd_isid,
disarray<size_type,sequential>& dom_isid2dom_ios_dis_isid,
size_type size_by_variant [reference_element::max_variant]);
void build_external_entities () {} // for distributed compat
// friends:
friend void geo_build_by_subdividing<> (
geo_rep<T,sequential>& new_omega,
const geo_basic<T,sequential>& old_omega,
typename geo_rep<T,sequential>::size_type k);
};
#ifdef _RHEOLEF_HAVE_MPI
// =========================================================================
// =========================================================================
template <class T>
class geo_rep<T,distributed> : public geo_base_rep<T,distributed> {
public:
// typedefs:
typedef geo_base_rep<T,distributed> base;
typedef typename base::size_type size_type;
typedef typename base::node_type node_type;
typedef typename base::variant_type variant_type;
typedef typename base::node_map_type node_map_type;
typedef typename base::reference reference;
typedef typename base::const_reference const_reference;
typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator;
typedef typename base::iterator_by_variant iterator_by_variant;
typedef typename base::const_iterator_by_variant const_iterator_by_variant;
typedef typename base::coordinate_type coordinate_type;
typedef typename base::geo_element_map_type geo_element_map_type;
// allocators:
geo_rep ();
geo_rep (const geo_rep<T,distributed>&);
geo_abstract_rep<T,distributed>* clone() const;
void build_from_domain (
const domain_indirect_rep<distributed>& indirect,
const geo_abstract_rep<T,distributed>& omega,
std::map<size_type,size_type>& bgd_ie2dom_ie,
std::map<size_type,size_type>& dis_bgd_ie2dis_dom_ie);
// build from_list (for level set)
geo_rep (
const geo_basic<T,distributed>& lambda,
const disarray<point_basic<T>,distributed>& node_list,
const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,distributed>,
reference_element::max_variant>& elt_list);
// abstract accessors defined:
distributor geo_element_ios_ownership (size_type dim) const;
size_type ige2ios_dis_ige (size_type dim, size_type ige) const;
size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const;
size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const;
const geo_size& ios_sizes() const { return _ios_gs; }
void locate (
const disarray<point_basic<T>,distributed>& x,
disarray<size_type, distributed>& dis_ie,
bool do_check = false) const;
void trace_ray_boundary (
const disarray<point_basic<T>,distributed>& x,
const disarray<point_basic<T>,distributed>& v,
disarray<size_type, distributed>& dis_ie,
disarray<point_basic<T>,distributed>& y,
bool do_check = false) const;
void trace_move (
const disarray<point_basic<T>,distributed>& x,
const disarray<point_basic<T>,distributed>& v,
disarray<size_type, distributed>& dis_ie,
disarray<point_basic<T>,distributed>& y) const;
void nearest (
const disarray<point_basic<T>,distributed>& x,
disarray<point_basic<T>,distributed>& x_nearest,
disarray<size_type, distributed>& dis_ie) const;
// herited accessors:
size_type map_dimension () const { return base::map_dimension(); }
bool is_broken() const { return base::is_broken(); }
size_type size (size_type dim) const { return base::size(dim); }
const distributor& geo_element_ownership(size_type dim) const { return base::geo_element_ownership (dim); }
const_reference get_geo_element (size_type dim, size_type ige) const { return base::get_geo_element (dim, ige); }
reference get_geo_element (size_type dim, size_type ige) { return base::get_geo_element (dim, ige); }
const_iterator begin (size_type dim) const { return base::begin(dim); }
const_iterator end (size_type dim) const { return base::end (dim); }
iterator begin (size_type dim) { return base::begin(dim); }
iterator end (size_type dim) { return base::end (dim); }
const geo_element_map_type& get_external_geo_element_map (size_type variant) const
{ return base::_geo_element[variant].get_dis_map_entries(); }
const domain_indirect_basic<distributed>& get_domain_indirect (size_type idom) const { return base::get_domain_indirect (idom); }
const domain_indirect_basic<distributed>& get_domain_indirect (const std::string& name) const { return base::get_domain_indirect (name); }
// deduced accessors:
size_type size () const { return size (map_dimension()); }
const distributor& vertex_ownership() const { return geo_element_ownership(0); }
const_reference operator[] (size_type ie) const { return get_geo_element (map_dimension(), ie); }
#ifdef TODO
reference operator[] (size_type ie) { return get_geo_element (map_dimension(), ie); }
#endif // TODO
// modifier:
void reset_order (size_type order);
void build_by_subdividing (const geo_basic<T,distributed>& omega, size_type k);
// i/o:
idiststream& get (idiststream&);
odiststream& put (odiststream&) const;
void dump (std::string name) const;
void load (std::string name, const communicator& comm);
bool check(bool verbose) const;
// utilities:
void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof) const;
protected:
// internal:
void build_external_entities ();
void set_element_side_index (size_type side_dim);
void domain_set_side_part1 (
const domain_indirect_rep<distributed>& indirect,
const geo_abstract_rep<T,distributed>& bgd_omega,
size_type sid_dim,
disarray<size_type>& bgd_isid2dom_dis_isid,
disarray<size_type>& dom_isid2bgd_isid,
disarray<size_type>& dom_isid2dom_ios_dis_isid,
size_type size_by_variant [reference_element::max_variant]);
void domain_set_side_part2 (
const domain_indirect_rep<distributed>& indirect,
const geo_abstract_rep<T,distributed>& bgd_omega,
disarray<size_type>& bgd_iv2dom_dis_iv,
size_type sid_dim,
disarray<size_type>& bgd_isid2dom_dis_isid,
disarray<size_type>& dom_isid2bgd_isid,
disarray<size_type>& dom_isid2dom_ios_dis_isid,
size_type size_by_variant [reference_element::max_variant]);
void node_renumbering (const distributor& ios_node_ownership);
// data:
disarray<size_type> _inod2ios_dis_inod; // permutation for node
disarray<size_type> _ios_inod2dis_inod; // reverse permutation for node
std::array<disarray<size_type>, 4> _ios_ige2dis_ige; // reverse permutation for geo_element[dim]
geo_size _ios_gs;
std::array<disarray<size_type,distributed>,reference_element::max_variant> _igev2ios_dis_igev;
std::array<disarray<size_type,distributed>,reference_element::max_variant> _ios_igev2dis_igev;
public:
// used by space_constritution for ios numbering
const std::array<disarray<size_type,distributed>,reference_element::max_variant>&
get_igev2ios_dis_igev() const { return _igev2ios_dis_igev; }
// friends:
friend void geo_build_by_subdividing<> (
geo_rep<T,distributed>& new_omega,
const geo_basic<T,distributed>& old_omega,
typename geo_rep<T,distributed>::size_type k);
};
#endif // _RHEOLEF_HAVE_MPI
// =========================================================================
// =========================================================================
template <class T, class M = rheo_default_memory_model>
class geo_basic {
public:
typedef M memory_type;
};
// =========================================================================
// =========================================================================
// handler for complex geo names as "square[boundary]"
template<class T, class M> geo_basic<T,M> geo_load (const std::string& name);
// guards for omega.boundary(), omega.internal_sides() and omega.sides()
template<class T, class M> void boundary_guard (const geo_basic<T,M>&);
template<class T, class M> void internal_sides_guard (const geo_basic<T,M>&);
template<class T, class M> void sides_guard (const geo_basic<T,M>&);
// [verbatim_geo_basic]
template <class T>
class geo_basic<T,sequential> : public smart_pointer_clone<geo_abstract_rep<T,sequential> > {
public:
// typedefs:
typedef sequential memory_type;
typedef geo_abstract_rep<T,sequential> rep;
typedef geo_rep<T,sequential> rep_geo_rep;
typedef smart_pointer_clone<rep> base;
typedef typename rep::size_type size_type;
typedef typename rep::node_type node_type;
typedef typename rep::variant_type variant_type;
typedef typename rep::reference reference;
typedef typename rep::const_reference const_reference;
typedef typename rep::iterator iterator;
typedef typename rep::const_iterator const_iterator;
typedef typename rep::iterator_by_variant iterator_by_variant;
typedef typename rep::const_iterator_by_variant const_iterator_by_variant;
typedef typename rep::coordinate_type coordinate_type;
typedef typename rep::geo_element_map_type geo_element_map_type;
// allocators:
geo_basic ();
geo_basic (std::string name, const communicator& comm = communicator());
void load (std::string name, const communicator& comm = communicator());
geo_basic (const domain_indirect_basic<sequential>& dom, const geo_basic<T,sequential>& omega);
// build from_list (for level set)
geo_basic (
const geo_basic<T,sequential>& lambda,
const disarray<point_basic<T>,sequential>& node_list,
const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,sequential>,
reference_element::max_variant>& elt_list)
: base (new_macro(rep_geo_rep(lambda,node_list,elt_list))) {}
// accessors:
std::string name() const { return base::data().name(); }
std::string familyname() const { return base::data().familyname(); }
size_type dimension() const { return base::data().dimension(); }
size_type map_dimension() const { return base::data().map_dimension(); }
bool is_broken() const { return base::data().is_broken(); }
size_type serial_number() const { return base::data().serial_number(); }
size_type variant() const { return base::data().variant(); }
coordinate_type coordinate_system() const { return base::data().coordinate_system(); }
std::string coordinate_system_name() const { return space_constant::coordinate_system_name(coordinate_system()); }
const basis_basic<T>& get_piola_basis() const { return base::data().get_piola_basis(); }
size_type order() const { return base::data().get_piola_basis().degree(); }
const node_type& xmin() const { return base::data().xmin(); }
const node_type& xmax() const { return base::data().xmax(); }
const T& hmin() const { return base::data().hmin(); }
const T& hmax() const { return base::data().hmax(); }
const distributor& geo_element_ownership(size_type dim) const { return base::data().geo_element_ownership(dim); }
const geo_size& sizes() const { return base::data().sizes(); }
const geo_size& ios_sizes() const { return base::data().ios_sizes(); }
const_reference get_geo_element (size_type dim, size_type ige) const { return base::data().get_geo_element (dim, ige); }
const_reference dis_get_geo_element (size_type dim, size_type dis_ige) const
{ return get_geo_element (dim, dis_ige); }
const geo_element& bgd2dom_geo_element (const geo_element& bgd_K) const { return base::data().bgd2dom_geo_element (bgd_K); }
const geo_element& dom2bgd_geo_element (const geo_element& dom_K) const { return base::data().dom2bgd_geo_element (dom_K); }
size_type neighbour (size_type ie, size_type loc_isid) const {
return base::data().neighbour (ie, loc_isid); }
void neighbour_guard() const { base::data().neighbour_guard(); }
size_type n_node() const { return base::data().n_node(); }
const node_type& node(size_type inod) const { return base::data().node(inod); }
const node_type& dis_node(size_type dis_inod) const { return base::data().dis_node(dis_inod); }
void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const {
return base::data().dis_inod(K,dis_inod); }
const disarray<node_type,sequential>& get_nodes() const { return base::data().get_nodes(); }
size_type dis_inod2dis_iv (size_type dis_inod) const { return base::data().dis_inod2dis_iv(dis_inod); }
size_type n_domain_indirect () const { return base::data().n_domain_indirect (); }
bool have_domain_indirect (const std::string& name) const { return base::data().have_domain_indirect (name); }
const domain_indirect_basic<sequential>& get_domain_indirect (size_type i) const {
return base::data().get_domain_indirect (i); }
const domain_indirect_basic<sequential>& get_domain_indirect (const std::string& name) const {
return base::data().get_domain_indirect (name); }
void insert_domain_indirect (const domain_indirect_basic<sequential>& dom) const {
base::data().insert_domain_indirect (dom); }
size_type n_domain () const { return base::data().n_domain_indirect (); }
geo_basic<T,sequential> get_domain (size_type i) const;
geo_basic<T,sequential> operator[] (const std::string& name) const;
geo_basic<T,sequential> boundary() const;
geo_basic<T,sequential> internal_sides() const;
geo_basic<T,sequential> sides() const;
// modifiers:
void set_name (std::string name);
void set_dimension (size_type dim);
void set_serial_number (size_type i);
void reset_order (size_type order);
void set_coordinate_system (coordinate_type sys_coord);
void set_coordinate_system (std::string sys_coord_name) { set_coordinate_system (space_constant::coordinate_system(sys_coord_name)); }
void set_nodes (const disarray<node_type,sequential>& x);
// extended accessors:
const communicator& comm() const { return geo_element_ownership (0).comm(); }
size_type size(size_type dim) const { return base::data().geo_element_ownership(dim).size(); }
size_type dis_size(size_type dim) const { return base::data().geo_element_ownership(dim).dis_size(); }
size_type size() const { return size (map_dimension()); }
size_type dis_size() const { return dis_size (map_dimension()); }
size_type n_vertex() const { return size (0); }
size_type dis_n_vertex() const { return dis_size (0); }
const_reference operator[] (size_type ie) const { return get_geo_element (map_dimension(), ie); }
const_iterator begin (size_type dim) const { return base::data().begin(dim); }
const_iterator end (size_type dim) const { return base::data().end (dim); }
const_iterator begin () const { return begin(map_dimension()); }
const_iterator end () const { return end (map_dimension()); }
// comparator:
bool operator== (const geo_basic<T,sequential>& omega2) const { return base::data().operator== (omega2.data()); }
// i/o:
void save (std::string filename = "") const;
// [verbatim_geo_basic]
// internals:
geo_basic (details::zero_dimension, const communicator& comm = communicator());
bool check (bool verbose = true) const { return base::data().check(verbose); }
idiststream& get (idiststream& ips);
odiststream& put (odiststream& ops) const;
void build_by_subdividing (const geo_basic<T,sequential>& omega, size_type k);
void build_from_data (
const geo_header& hdr,
const disarray<node_type, sequential>& node,
std::array<disarray<geo_element_auto<>,sequential>, reference_element::max_variant>&
tmp_geo_element,
bool do_upgrade);
// locators:
size_type seq_locate (
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const
{ return base::data().seq_locate (x, dis_ie_guest); }
size_type dis_locate (
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const
{ return base::data().dis_locate (x, dis_ie_guest); }
void locate (
const disarray<point_basic<T>, sequential>& x,
disarray<size_type, sequential>& dis_ie) const
{ return base::data().locate (x, dis_ie); }
size_type seq_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const
{ return base::data().seq_trace_move (x,v,y); }
size_type dis_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const
{ return base::data().dis_trace_move (x,v,y); }
void trace_ray_boundary (
const disarray<point_basic<T>,sequential>& x,
const disarray<point_basic<T>,sequential>& v,
disarray<size_type, sequential>& dis_ie,
disarray<point_basic<T>,sequential>& y) const
{ return base::data().trace_ray_boundary (x,v,dis_ie,y); }
void trace_move (
const disarray<point_basic<T>,sequential>& x,
const disarray<point_basic<T>,sequential>& v,
disarray<size_type, sequential>& dis_ie,
disarray<point_basic<T>,sequential>& y) const
{ return base::data().trace_move (x,v,dis_ie,y); }
size_type seq_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const
{ return base::data().seq_nearest (x, x_nearest); }
size_type dis_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const
{ return base::data().dis_nearest (x, x_nearest); }
void nearest (
const disarray<point_basic<T>,sequential>& x,
disarray<point_basic<T>,sequential>& x_nearest,
disarray<size_type, sequential>& dis_ie) const
{ base::data().nearest (x, x_nearest, dis_ie); }
const_iterator_by_variant begin_by_variant (variant_type variant) const
{ return base::data().begin_by_variant (variant); }
const_iterator_by_variant end_by_variant (variant_type variant) const
{ return base::data(). end_by_variant (variant); }
const geo_element_map_type& get_external_geo_element_map (size_type variant) const
{ return base::data().get_external_geo_element_map(variant); }
const geo_basic<T,sequential>& get_background_geo() const; // code in geo_domain.h
geo_basic<T,sequential> get_background_domain() const;
// for compatibility with distributed interface:
size_type ige2ios_dis_ige (size_type dim, size_type ige) const { return ige; }
size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const { return dis_ige; }
size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const { return ios_ige; }
void set_ios_permutation (disarray<size_type,sequential>& idof2ios_dis_idof) const {}
// [verbatim_geo_basic_cont]
};
template <class T, class M>
idiststream& operator>> (idiststream& ips, geo_basic<T,M>& omega);
template <class T, class M>
odiststream& operator<< (odiststream& ops, const geo_basic<T,M>& omega);
// [verbatim_geo_basic_cont]
template <class T>
inline
geo_basic<T,sequential>::geo_basic()
: base (new_macro((geo_rep<T,sequential>)))
{
}
template <class T>
inline
geo_basic<T,sequential>::geo_basic (std::string name, const communicator& comm)
: base (0)
{
base::operator= (geo_load<T,sequential>(name));
}
template <class T>
inline
void
geo_basic<T,sequential>::load (std::string name, const communicator& comm)
{
base::operator= (geo_load<T,sequential>(name));
}
template <class T>
inline
geo_basic<T,sequential>
geo_basic<T,sequential>::boundary() const
{
boundary_guard (*this);
return operator[] ("boundary");
}
template <class T>
inline
geo_basic<T,sequential>
geo_basic<T,sequential>::internal_sides() const
{
internal_sides_guard (*this);
return operator[] ("internal_sides");
}
template <class T>
inline
geo_basic<T,sequential>
geo_basic<T,sequential>::sides() const
{
sides_guard (*this);
return operator[] ("sides");
}
#ifdef _RHEOLEF_HAVE_MPI
// =========================================================================
// =========================================================================
template <class T>
class geo_basic<T,distributed> : public smart_pointer_clone<geo_abstract_rep<T,distributed> > {
public:
// typedefs:
typedef distributed memory_type;
typedef geo_abstract_rep<T,distributed> rep;
typedef geo_rep<T,distributed> rep_geo_rep;
typedef smart_pointer_clone<rep> base;
typedef typename rep::size_type size_type;
typedef typename rep::node_type node_type;
typedef typename rep::variant_type variant_type;
typedef typename rep::node_map_type node_map_type;
typedef typename rep::reference reference;
typedef typename rep::const_reference const_reference;
typedef typename rep::iterator iterator;
typedef typename rep::const_iterator const_iterator;
typedef typename rep::iterator_by_variant iterator_by_variant;
typedef typename rep::const_iterator_by_variant const_iterator_by_variant;
typedef typename rep::coordinate_type coordinate_type;
typedef typename rep::geo_element_map_type geo_element_map_type;
// allocators:
geo_basic ();
geo_basic (std::string name, const communicator& comm = communicator());
void load (std::string name, const communicator& comm = communicator());
geo_basic (const domain_indirect_basic<distributed>& dom, const geo_basic<T,distributed>& omega);
geo_basic (details::zero_dimension, const communicator& comm = communicator());
// build from_list (for level set)
geo_basic (
const geo_basic<T,distributed>& lambda,
const disarray<point_basic<T>,distributed>& node_list,
const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,distributed>,
reference_element::max_variant>& elt_list)
: base (new_macro(rep_geo_rep(lambda,node_list,elt_list))) {}
// accessors:
std::string name() const { return base::data().name(); }
std::string familyname() const { return base::data().familyname(); }
size_type dimension() const { return base::data().dimension(); }
size_type map_dimension() const { return base::data().map_dimension(); }
bool is_broken() const { return base::data().is_broken(); }
size_type serial_number() const { return base::data().serial_number(); }
size_type variant() const { return base::data().variant(); }
coordinate_type coordinate_system() const { return base::data().coordinate_system(); }
std::string coordinate_system_name() const { return space_constant::coordinate_system_name(coordinate_system()); }
const basis_basic<T>& get_piola_basis() const { return base::data().get_piola_basis(); }
size_type order() const { return base::data().get_piola_basis().degree(); }
const node_type& xmin() const { return base::data().xmin(); }
const node_type& xmax() const { return base::data().xmax(); }
const T& hmin() const { return base::data().hmin(); }
const T& hmax() const { return base::data().hmax(); }
const distributor& geo_element_ownership(size_type dim) const
{ return base::data().geo_element_ownership (dim); }
const geo_size& sizes() const { return base::data().sizes(); }
const geo_size& ios_sizes() const { return base::data().ios_sizes(); }
const_reference get_geo_element (size_type dim, size_type ige) const
{ return base::data().get_geo_element (dim, ige); }
const_reference dis_get_geo_element (size_type dim, size_type dis_ige) const
{ return base::data().dis_get_geo_element (dim, dis_ige); }
const geo_element& bgd2dom_geo_element (const geo_element& bgd_K) const
{ return base::data().bgd2dom_geo_element (bgd_K); }
const geo_element& dom2bgd_geo_element (const geo_element& dom_K) const
{ return base::data().dom2bgd_geo_element (dom_K); }
size_type neighbour (size_type ie, size_type loc_isid) const {
return base::data().neighbour (ie, loc_isid); }
void neighbour_guard() const { base::data().neighbour_guard(); }
distributor geo_element_ios_ownership (size_type dim) const {
return base::data().geo_element_ios_ownership (dim); }
size_type ige2ios_dis_ige (size_type dim, size_type ige) const {
return base::data().ige2ios_dis_ige (dim,ige); }
size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const {
return base::data().dis_ige2ios_dis_ige (dim,dis_ige); }
size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const {
return base::data().ios_ige2dis_ige (dim, ios_ige); }
size_type n_node() const { return base::data().n_node(); }
const node_type& node(size_type inod) const { return base::data().node(inod); }
const node_type& dis_node(size_type dis_inod) const { return base::data().dis_node(dis_inod); }
void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const {
return base::data().dis_inod(K,dis_inod); }
const disarray<node_type,distributed>& get_nodes() const { return base::data().get_nodes(); }
size_type n_domain_indirect () const { return base::data().n_domain_indirect (); }
bool have_domain_indirect (const std::string& name) const { return base::data().have_domain_indirect (name); }
const domain_indirect_basic<distributed>& get_domain_indirect (size_type i) const {
return base::data().get_domain_indirect (i); }
const domain_indirect_basic<distributed>& get_domain_indirect (const std::string& name) const {
return base::data().get_domain_indirect (name); }
void insert_domain_indirect (const domain_indirect_basic<distributed>& dom) const {
base::data().insert_domain_indirect (dom); }
size_type n_domain () const { return base::data().n_domain_indirect (); }
geo_basic<T,distributed> get_domain (size_type i) const;
geo_basic<T,distributed> operator[] (const std::string& name) const;
geo_basic<T,distributed> boundary() const;
geo_basic<T,distributed> internal_sides() const;
geo_basic<T,distributed> sides() const;
size_type seq_locate (
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const
{ return base::data().seq_locate (x, dis_ie_guest); }
size_type dis_locate (
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const
{ return base::data().dis_locate (x, dis_ie_guest); }
void locate (const disarray<point_basic<T>, distributed>& x, disarray<size_type, distributed>& dis_ie) const
{ return base::data().locate (x, dis_ie); }
size_type seq_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const
{ return base::data().seq_trace_move (x,v,y); }
size_type dis_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const
{ return base::data().dis_trace_move (x,v,y); }
void trace_ray_boundary (
const disarray<point_basic<T>,distributed>& x,
const disarray<point_basic<T>,distributed>& v,
disarray<size_type, distributed>& dis_ie,
disarray<point_basic<T>,distributed>& y) const
{ return base::data().trace_ray_boundary (x,v,dis_ie,y); }
void trace_move (
const disarray<point_basic<T>,distributed>& x,
const disarray<point_basic<T>,distributed>& v,
disarray<size_type, distributed>& dis_ie,
disarray<point_basic<T>,distributed>& y) const
{ return base::data().trace_move (x,v,dis_ie,y); }
size_type seq_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const
{ return base::data().seq_nearest (x, x_nearest); }
size_type dis_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const
{ return base::data().dis_nearest (x, x_nearest); }
void nearest (
const disarray<point_basic<T>,distributed>& x,
disarray<point_basic<T>,distributed>& x_nearest,
disarray<size_type, distributed>& dis_ie) const
{ base::data().nearest (x, x_nearest, dis_ie); }
// modifiers:
void set_nodes (const disarray<node_type,distributed>& x);
void reset_order (size_type order);
size_type dis_inod2dis_iv (size_type dis_inod) const { return base::data().dis_inod2dis_iv(dis_inod); }
void set_coordinate_system (coordinate_type sys_coord);
void set_coordinate_system (std::string sys_coord_name) { set_coordinate_system (space_constant::coordinate_system(sys_coord_name)); }
void set_dimension (size_type dim);
void set_serial_number (size_type i);
void set_name (std::string name);
void build_by_subdividing (const geo_basic<T,distributed>& omega, size_type k);
// extended accessors:
size_type size(size_type dim) const { return base::data().geo_element_ownership(dim).size(); }
size_type dis_size(size_type dim) const { return base::data().geo_element_ownership(dim).dis_size(); }
const communicator& comm() const { return geo_element_ownership (0).comm(); }
size_type size() const { return size (map_dimension()); }
size_type dis_size() const { return dis_size (map_dimension()); }
size_type n_vertex() const { return size (0); }
size_type dis_n_vertex() const { return dis_size (0); }
const_reference operator[] (size_type ie) const
{ return get_geo_element (map_dimension(), ie); }
const_iterator begin (size_type dim) const { return base::data().begin(dim); }
const_iterator end (size_type dim) const { return base::data().end (dim); }
const_iterator begin () const { return begin(map_dimension()); }
const_iterator end () const { return end (map_dimension()); }
const_iterator_by_variant begin_by_variant (variant_type variant) const
{ return base::data().begin_by_variant (variant); }
const_iterator_by_variant end_by_variant (variant_type variant) const
{ return base::data(). end_by_variant (variant); }
const geo_element_map_type& get_external_geo_element_map (size_type variant) const
{ return base::data().get_external_geo_element_map(variant); }
const geo_basic<T,distributed>& get_background_geo() const; // code in geo_domain.h
geo_basic<T,distributed> get_background_domain() const;
// comparator:
bool operator== (const geo_basic<T,distributed>& omega2) const { return base::data().operator== (omega2.data()); }
// i/o:
odiststream& put (odiststream& ops) const { return base::data().put (ops); }
idiststream& get (idiststream& ips);
void save (std::string filename = "") const;
bool check (bool verbose = true) const { return base::data().check(verbose); }
// utilities:
void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof) const
{ base::data().set_ios_permutation (idof2ios_dis_idof); }
// used by space_constritution for ios numbering
const std::array<disarray<size_type,distributed>,reference_element::max_variant>&
get_igev2ios_dis_igev() const { return base::data().get_igev2ios_dis_igev(); }
};
#endif // _RHEOLEF_HAVE_MPI
// [verbatim_geo]
typedef geo_basic<Float,rheo_default_memory_model> geo;
// [verbatim_geo]
// ==============================================================================
// inlined: geo<T,distributed>
// ==============================================================================
#ifdef _RHEOLEF_HAVE_MPI
template <class T>
inline
geo_basic<T,distributed>::geo_basic()
: base (new_macro((geo_rep<T,distributed>)))
{
}
template <class T>
inline
geo_basic<T,distributed>::geo_basic (std::string name, const communicator& comm)
: base (0)
{
base::operator= (geo_load<T,distributed>(name));
}
template <class T>
inline
void
geo_basic<T,distributed>::load (std::string name, const communicator& comm)
{
base::operator= (geo_load<T,distributed>(name));
}
template <class T>
inline
idiststream&
geo_basic<T,distributed>::get (idiststream& ips)
{
// allocate a new geo_rep object (TODO: do a dynamic_cast ?)
geo_rep<T,distributed>* ptr = new_macro((geo_rep<T,distributed>));
ptr->get (ips);
base::operator= (ptr);
return ips;
}
template <class T>
inline
geo_basic<T,distributed>
geo_basic<T,distributed>::boundary() const
{
boundary_guard (*this);
return operator[] ("boundary");
}
template <class T>
inline
geo_basic<T,distributed>
geo_basic<T,distributed>::internal_sides() const
{
internal_sides_guard (*this);
return operator[] ("internal_sides");
}
template <class T>
inline
geo_basic<T,distributed>
geo_basic<T,distributed>::sides() const
{
sides_guard (*this);
return operator[] ("sides");
}
#endif // _RHEOLEF_HAVE_MPI
// ==============================================================================
// inlined: geo<T,M>
// ==============================================================================
template <class T, class M>
inline
idiststream&
operator>> (idiststream& ips, geo_basic<T,M>& omega)
{
return omega.get (ips);
}
template <class T, class M>
inline
odiststream&
operator<< (odiststream& ops, const geo_basic<T,M>& omega)
{
return omega.put (ops);
}
} // namespace rheolef
#endif // _RHEOLEF_GEO_H
#ifdef _RHEOLEF_GEO_DEMO_TST_CC
// demo for the geo class documentation
#include "rheolef/environment.h"
using namespace rheolef;
using namespace std;
int main(int argc, char**argv) {
environment rheolef (argc, argv);
geo omega (argv[1]);
// [verbatim_geo_demo_tst]
cout << omega.size() << " " << omega.n_node() << endl;
for (size_t i = 0, n = omega.size(); i < n; ++i) {
const geo_element& K = omega[i];
cout << K.name();
for (size_t j = 0, m = K.size(); j < m; ++j)
cout << " " << K[j];
cout << endl;
}
for (size_t jv = 0, nv = omega.n_node(); jv < nv; ++jv)
cout << omega.node(jv) << endl;
// [verbatim_geo_demo_tst]
}
#endif // _RHEOLEF_GEO_DEMO_TST_CC
size_type
field::size_type size_type
Definition branch.cc:430
geo
see the geo 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::distributor
see the distributor page for the full documentation
Definition distributor.h:69
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::domain_indirect_rep
Definition domain_indirect.h:148
rheolef::environment
see the environment page for the full documentation
Definition environment.h:121
rheolef::geo_abstract_base_rep
abstract base interface class
Definition geo.h:248
rheolef::geo_abstract_base_rep::begin_by_variant
virtual const_iterator_by_variant begin_by_variant(variant_type variant) const =0
rheolef::geo_abstract_base_rep::coordinate_type
space_constant::coordinate_type coordinate_type
Definition geo.h:265
rheolef::geo_abstract_base_rep::familyname
virtual std::string familyname() const =0
rheolef::geo_abstract_base_rep::geo_abstract_base_rep
geo_abstract_base_rep()
Definition geo.h:288
rheolef::geo_abstract_base_rep::xmin
virtual const node_type & xmin() const =0
rheolef::geo_abstract_base_rep::node
virtual const node_type & node(size_type inod) const =0
rheolef::geo_abstract_base_rep::dom2bgd_geo_element
virtual const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition geo.h:312
rheolef::geo_abstract_base_rep::hmax
virtual const T & hmax() const =0
rheolef::geo_abstract_base_rep::const_iterator
geo_iterator< geo_element, const geo_element &, const geo_element *, const_iterator_by_variant > const_iterator
Definition geo.h:284
rheolef::geo_abstract_base_rep::get_piola_basis
virtual const basis_basic< T > & get_piola_basis() const =0
rheolef::geo_abstract_base_rep::geo_element_map_type
std::map< size_type, geo_element_auto<> > geo_element_map_type
Definition geo.h:266
rheolef::geo_abstract_base_rep::seq_trace_move
virtual size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const =0
rheolef::geo_abstract_base_rep::neighbour_guard
virtual void neighbour_guard() const =0
rheolef::geo_abstract_base_rep::n_domain_indirect
virtual size_type n_domain_indirect() const =0
rheolef::geo_abstract_base_rep::dis_trace_move
virtual size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const =0
rheolef::geo_abstract_base_rep::geo_element_ownership
virtual const distributor & geo_element_ownership(size_type dim) const =0
rheolef::geo_abstract_base_rep::check
virtual bool check(bool verbose) const =0
rheolef::geo_abstract_base_rep::end
const_iterator end(size_type dim) const
Definition geo.h:769
rheolef::geo_abstract_base_rep::reset_order
virtual void reset_order(size_type order)=0
rheolef::geo_abstract_base_rep::end_by_variant
virtual const_iterator_by_variant end_by_variant(variant_type variant) const =0
rheolef::geo_abstract_base_rep::seq_locate
virtual size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const =0
rheolef::geo_abstract_base_rep::node_type
point_basic< T > node_type
Definition geo.h:261
rheolef::geo_abstract_base_rep::is_broken
virtual bool is_broken() const =0
rheolef::geo_abstract_base_rep::seq_nearest
virtual size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const =0
rheolef::geo_abstract_base_rep::dis_node
virtual const node_type & dis_node(size_type dis_inod) const =0
rheolef::geo_abstract_base_rep::begin
const_iterator begin(size_type dim) const
Definition geo.h:760
rheolef::geo_abstract_base_rep::variant
virtual size_type variant() const =0
rheolef::geo_abstract_base_rep::geo_rep_variant_type
geo_rep_variant_type
Definition geo.h:253
rheolef::geo_abstract_base_rep::geo_domain_indirect
@ geo_domain_indirect
Definition geo.h:256
rheolef::geo_abstract_base_rep::max_variant
@ max_variant
Definition geo.h:257
rheolef::geo_abstract_base_rep::geo_domain
@ geo_domain
Definition geo.h:255
rheolef::geo_abstract_base_rep::name
virtual std::string name() const =0
rheolef::geo_abstract_base_rep::size_type
geo_element_hack::size_type size_type
Definition geo.h:260
rheolef::geo_abstract_base_rep::dis_inod
virtual void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const =0
rheolef::geo_abstract_base_rep::n_node
virtual size_type n_node() const =0
rheolef::geo_abstract_base_rep::dis_nearest
virtual size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const =0
rheolef::geo_abstract_base_rep::get_geo_element
virtual const_reference get_geo_element(size_type dim, size_type ige) const =0
rheolef::geo_abstract_base_rep::iterator
geo_iterator< geo_element, geo_element &, geo_element *, iterator_by_variant > iterator
Definition geo.h:275
rheolef::geo_abstract_base_rep::have_domain_indirect
virtual bool have_domain_indirect(const std::string &name) const =0
rheolef::geo_abstract_base_rep::const_reference
const geo_element & const_reference
Definition geo.h:264
rheolef::geo_abstract_base_rep::bgd2dom_geo_element
virtual const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition geo.h:311
rheolef::geo_abstract_base_rep::reference
geo_element & reference
Definition geo.h:263
rheolef::geo_abstract_base_rep::sizes
virtual const geo_size & sizes() const =0
rheolef::geo_abstract_base_rep::get_external_geo_element_map
virtual const geo_element_map_type & get_external_geo_element_map(size_type variant) const =0
rheolef::geo_abstract_base_rep::operator==
bool operator==(const geo_abstract_base_rep< T > &omega2) const
Definition geo.h:363
rheolef::geo_abstract_base_rep::dis_inod2dis_iv
virtual size_type dis_inod2dis_iv(size_type dis_inod) const =0
rheolef::geo_abstract_base_rep::put
virtual odiststream & put(odiststream &ops) const =0
rheolef::geo_abstract_base_rep::~geo_abstract_base_rep
virtual ~geo_abstract_base_rep()
Definition geo.h:289
rheolef::geo_abstract_base_rep::map_dimension
virtual size_type map_dimension() const =0
rheolef::geo_abstract_base_rep::xmax
virtual const node_type & xmax() const =0
rheolef::geo_abstract_base_rep::dimension
virtual size_type dimension() const =0
rheolef::geo_abstract_base_rep::ios_sizes
virtual const geo_size & ios_sizes() const =0
rheolef::geo_abstract_base_rep::coordinate_system
virtual coordinate_type coordinate_system() const =0
rheolef::geo_abstract_base_rep::iterator_by_variant
hack_array< geo_element_hack >::iterator iterator_by_variant
Definition geo.h:269
rheolef::geo_abstract_base_rep::hmin
virtual const T & hmin() const =0
rheolef::geo_abstract_base_rep::dis_locate
virtual size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const =0
rheolef::geo_abstract_base_rep::const_iterator_by_variant
hack_array< geo_element_hack >::const_iterator const_iterator_by_variant
Definition geo.h:278
rheolef::geo_abstract_base_rep::neighbour
virtual size_type neighbour(size_type ie, size_type loc_isid) const =0
rheolef::geo_abstract_base_rep::variant_type
reference_element::variant_type variant_type
Definition geo.h:262
rheolef::geo_abstract_base_rep::serial_number
virtual size_type serial_number() const =0
rheolef::geo_abstract_rep< T, distributed >::ios_ige2dis_ige
virtual size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const =0
rheolef::geo_abstract_rep< T, distributed >::geo_abstract_rep
geo_abstract_rep()
Definition geo.h:471
rheolef::geo_abstract_rep< T, distributed >::get_domain_indirect
virtual const domain_indirect_basic< distributed > & get_domain_indirect(size_type i) const =0
rheolef::geo_abstract_rep< T, distributed >::base
geo_abstract_base_rep< T > base
Definition geo.h:462
rheolef::geo_abstract_rep< T, distributed >::clone
virtual geo_abstract_rep< T, distributed > * clone() const =0
rheolef::geo_abstract_rep< T, distributed >::set_ios_permutation
virtual void set_ios_permutation(disarray< size_type, distributed > &idof2ios_dis_idof) const =0
rheolef::geo_abstract_rep< T, distributed >::~geo_abstract_rep
virtual ~geo_abstract_rep()
Definition geo.h:473
rheolef::geo_abstract_rep< T, distributed >::geo_element_ios_ownership
virtual distributor geo_element_ios_ownership(size_type dim) const =0
rheolef::geo_abstract_rep< T, distributed >::trace_ray_boundary
virtual void trace_ray_boundary(const disarray< point_basic< T >, distributed > &x, const disarray< point_basic< T >, distributed > &v, disarray< size_type, distributed > &dis_ie, disarray< point_basic< T >, distributed > &y, bool do_check=false) const =0
rheolef::geo_abstract_rep< T, distributed >::insert_domain_indirect
virtual void insert_domain_indirect(const domain_indirect_basic< distributed > &dom) const =0
rheolef::geo_abstract_rep< T, distributed >::size_type
base::size_type size_type
Definition geo.h:463
rheolef::geo_abstract_rep< T, distributed >::trace_move
virtual void trace_move(const disarray< point_basic< T >, distributed > &x, const disarray< point_basic< T >, distributed > &v, disarray< size_type, distributed > &dis_ie, disarray< point_basic< T >, distributed > &y) const =0
rheolef::geo_abstract_rep< T, distributed >::get_igev2ios_dis_igev
virtual const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() const =0
rheolef::geo_abstract_rep< T, distributed >::const_reference
base::const_reference const_reference
Definition geo.h:465
rheolef::geo_abstract_rep< T, distributed >::get_domain_indirect
virtual const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const =0
rheolef::geo_abstract_rep< T, distributed >::locate
virtual void locate(const disarray< point_basic< T >, distributed > &x, disarray< size_type, distributed > &dis_ie, bool do_check=true) const =0
rheolef::geo_abstract_rep< T, distributed >::ige2ios_dis_ige
virtual size_type ige2ios_dis_ige(size_type dim, size_type ige) const =0
rheolef::geo_abstract_rep< T, distributed >::get_nodes
virtual const disarray< node_type, distributed > & get_nodes() const =0
rheolef::geo_abstract_rep< T, distributed >::dis_ige2ios_dis_ige
virtual size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const =0
rheolef::geo_abstract_rep< T, distributed >::dis_get_geo_element
virtual const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const =0
rheolef::geo_abstract_rep< T, distributed >::node_map_type
std::map< size_type, node_type, std::less< size_type >, heap_allocator< std::pair< size_type, node_type > > > node_map_type
Definition geo.h:467
rheolef::geo_abstract_rep< T, distributed >::set_nodes
virtual void set_nodes(const disarray< node_type, distributed > &)=0
rheolef::geo_abstract_rep< T, distributed >::nearest
virtual void nearest(const disarray< point_basic< T >, distributed > &x, disarray< point_basic< T >, distributed > &x_nearest, disarray< size_type, distributed > &dis_ie) const =0
rheolef::geo_abstract_rep< T, distributed >::node_type
base::node_type node_type
Definition geo.h:464
rheolef::geo_abstract_rep< T, sequential >::get_nodes
virtual const disarray< node_type, sequential > & get_nodes() const =0
rheolef::geo_abstract_rep< T, sequential >::variant_type
base::variant_type variant_type
Definition geo.h:412
rheolef::geo_abstract_rep< T, sequential >::geo_abstract_rep
geo_abstract_rep()
Definition geo.h:422
rheolef::geo_abstract_rep< T, sequential >::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:416
rheolef::geo_abstract_rep< T, sequential >::get_domain_indirect
virtual const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const =0
rheolef::geo_abstract_rep< T, sequential >::clone
virtual geo_abstract_rep< T, sequential > * clone() const =0
rheolef::geo_abstract_rep< T, sequential >::base
geo_abstract_base_rep< T > base
Definition geo.h:409
rheolef::geo_abstract_rep< T, sequential >::get_domain_indirect
virtual const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const =0
rheolef::geo_abstract_rep< T, sequential >::set_nodes
virtual void set_nodes(const disarray< node_type, sequential > &)=0
rheolef::geo_abstract_rep< T, sequential >::~geo_abstract_rep
virtual ~geo_abstract_rep()
Definition geo.h:424
rheolef::geo_abstract_rep< T, sequential >::iterator_by_variant
base::iterator_by_variant iterator_by_variant
Definition geo.h:415
rheolef::geo_abstract_rep< T, sequential >::iterator
base::iterator iterator
Definition geo.h:413
rheolef::geo_abstract_rep< T, sequential >::size_type
base::size_type size_type
Definition geo.h:410
rheolef::geo_abstract_rep< T, sequential >::trace_move
virtual void trace_move(const disarray< point_basic< T >, sequential > &x, const disarray< point_basic< T >, sequential > &v, disarray< size_type, sequential > &dis_ie, disarray< point_basic< T >, sequential > &y) const =0
rheolef::geo_abstract_rep< T, sequential >::const_reference
base::const_reference const_reference
Definition geo.h:418
rheolef::geo_abstract_rep< T, sequential >::locate
virtual void locate(const disarray< point_basic< T >, sequential > &x, disarray< size_type, sequential > &dis_ie, bool do_check=false) const =0
rheolef::geo_abstract_rep< T, sequential >::const_iterator
base::const_iterator const_iterator
Definition geo.h:414
rheolef::geo_abstract_rep< T, sequential >::insert_domain_indirect
virtual void insert_domain_indirect(const domain_indirect_basic< sequential > &dom) const =0
rheolef::geo_abstract_rep< T, sequential >::nearest
virtual void nearest(const disarray< point_basic< T >, sequential > &x, disarray< point_basic< T >, sequential > &x_nearest, disarray< size_type, sequential > &dis_ie) const =0
rheolef::geo_abstract_rep< T, sequential >::trace_ray_boundary
virtual void trace_ray_boundary(const disarray< point_basic< T >, sequential > &x, const disarray< point_basic< T >, sequential > &v, disarray< size_type, sequential > &dis_ie, disarray< point_basic< T >, sequential > &y, bool do_check=false) const =0
rheolef::geo_abstract_rep< T, sequential >::reference
base::reference reference
Definition geo.h:417
rheolef::geo_abstract_rep< T, sequential >::node_type
base::node_type node_type
Definition geo.h:411
rheolef::geo_abstract_rep
abstract interface class
Definition geo.h:401
rheolef::geo_base_rep
base class for M=sequential or distributed meshes representations
Definition geo.h:528
rheolef::geo_base_rep::end
const_iterator end(size_type dim) const
Definition geo.h:655
rheolef::geo_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_locate.cc:413
rheolef::geo_base_rep::get_nodes
const disarray< node_type, M > & get_nodes() const
Definition geo.h:592
rheolef::geo_base_rep::variant_type
base::variant_type variant_type
Definition geo.h:535
rheolef::geo_base_rep::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:539
rheolef::geo_base_rep::node
const node_type & node(size_type inod) const
Definition geo.h:588
rheolef::geo_base_rep::coordinate_system
coordinate_type coordinate_system() const
Definition geo.h:566
rheolef::geo_base_rep::begin_face
const_iterator begin_face() const
Definition geo.h:662
rheolef::geo_base_rep::end_by_variant
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition geo.h:732
rheolef::geo_base_rep::name
std::string name() const
Definition geo.cc:408
rheolef::geo_base_rep::n_vertex
size_type n_vertex() const
Definition geo.h:642
rheolef::geo_base_rep::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition geo.h:579
rheolef::geo_base_rep::begin_by_variant
iterator_by_variant begin_by_variant(variant_type variant)
Definition geo.h:714
rheolef::geo_base_rep::_dimension
size_type _dimension
Definition geo.h:685
rheolef::geo_base_rep::begin
const_iterator begin() const
Definition geo.h:657
rheolef::geo_base_rep::dis_size
size_type dis_size() const
Definition geo.h:645
rheolef::geo_base_rep::node
const node_type & node(const geo_element &K, size_type loc_inod) const
rheolef::geo_base_rep::add_ball_externals
friend void add_ball_externals(const geo_base_rep< U, M > &, const disarray< index_set, M > &)
rheolef::geo_base_rep::dis_inod
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition geo.cc:478
rheolef::geo_base_rep::dis_iv2dis_inod
size_type dis_iv2dis_inod(size_type dis_iv) const
Definition geo.cc:572
rheolef::geo_base_rep::n_node
size_type n_node() const
Definition geo.h:640
rheolef::geo_base_rep::_locator
geo_locate< T, M > _locator
Definition geo.h:692
rheolef::geo_base_rep::dis_n_edge
size_type dis_n_edge() const
Definition geo.h:646
rheolef::geo_base_rep::_serial_number
size_type _serial_number
Definition geo.h:676
rheolef::geo_base_rep::dis_node
const node_type & dis_node(size_type dis_inod) const
Definition geo.h:589
rheolef::geo_base_rep::serial_number
size_type serial_number() const
Definition geo.h:562
rheolef::geo_base_rep::_domains
std::vector< domain_indirect_basic< M > > _domains
Definition geo.h:680
rheolef::geo_base_rep::_nearestor
geo_nearest< T, M > _nearestor
Definition geo.h:694
rheolef::geo_base_rep::set_dimension
void set_dimension(size_type dim)
Definition geo.h:569
rheolef::geo_base_rep::iterator_by_variant
base::iterator_by_variant iterator_by_variant
Definition geo.h:538
rheolef::geo_base_rep::_tracer_ray_boundary
geo_trace_ray_boundary< T, M > _tracer_ray_boundary
Definition geo.h:693
rheolef::geo_base_rep::iterator
base::iterator iterator
Definition geo.h:536
rheolef::geo_base_rep::insert_domain_indirect
void insert_domain_indirect(const domain_indirect_basic< M > &dom) const
Definition geo.cc:440
rheolef::geo_base_rep::get_domain_indirect
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
Definition geo.h:597
rheolef::geo_base_rep::map_dimension
size_type map_dimension() const
Definition geo.h:564
rheolef::geo_base_rep::xmin
const node_type & xmin() const
Definition geo.h:572
rheolef::geo_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_locate.cc:405
rheolef::geo_base_rep::hmin
const T & hmin() const
Definition geo.h:574
rheolef::geo_base_rep::get_piola_basis
const basis_basic< T > & get_piola_basis() const
Definition geo.h:571
rheolef::geo_base_rep::build_from_list
void build_from_list(const geo_basic< T, M > &lambda, const disarray< point_basic< T >, M > &node_list, const std::array< disarray< geo_element_auto< heap_allocator< size_type > >, M >, reference_element::max_variant > &elt_list)
Definition geo_build_from_list.cc:36
rheolef::geo_base_rep::_sys_coord
coordinate_type _sys_coord
Definition geo.h:686
rheolef::geo_base_rep::size
size_type size() const
Definition geo.h:643
rheolef::geo_base_rep::end_face
const_iterator end_face() const
Definition geo.h:663
rheolef::geo_base_rep::ios_sizes
const geo_size & ios_sizes() const
Definition geo.h:577
rheolef::geo_base_rep::_loaded_map
static loaded_map_t _loaded_map
Definition geo.h:701
rheolef::geo_base_rep::familyname
std::string familyname() const
Definition geo.h:560
rheolef::geo_base_rep::size_type
base::size_type size_type
Definition geo.h:533
rheolef::geo_base_rep::begin_by_variant
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition geo.h:720
rheolef::geo_base_rep::set_name
void set_name(std::string name)
Definition geo.h:568
rheolef::geo_base_rep::loaded_map_t
std::unordered_map< std::string, void * > loaded_map_t
Definition geo.h:698
rheolef::geo_base_rep::_piola_basis
basis_basic< T > _piola_basis
Definition geo.h:691
rheolef::geo_base_rep::vertex_ownership
const distributor & vertex_ownership() const
Definition geo.h:636
rheolef::geo_base_rep::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.cc:533
rheolef::geo_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_trace_move.cc:45
rheolef::geo_base_rep::dis_n_face
size_type dis_n_face() const
Definition geo.h:647
rheolef::geo_base_rep::_have_neighbour
bool _have_neighbour
Definition geo.h:682
rheolef::geo_base_rep::begin_edge
const_iterator begin_edge() const
Definition geo.h:660
rheolef::geo_base_rep::_xmax
node_type _xmax
Definition geo.h:688
rheolef::geo_base_rep::init_neighbour
void init_neighbour() const
Definition geo_neighbour.cc:83
rheolef::geo_base_rep::geo_base_rep
geo_base_rep()
Definition geo.cc:36
rheolef::geo_base_rep::const_reference
base::const_reference const_reference
Definition geo.h:541
rheolef::geo_base_rep::_version
size_type _version
Definition geo.h:675
rheolef::geo_base_rep::dimension
size_type dimension() const
Definition geo.h:563
rheolef::geo_base_rep::neighbour
size_type neighbour(size_type ie, size_type loc_isid) const
Definition geo_neighbour.cc:234
rheolef::geo_base_rep::end_edge
const_iterator end_edge() const
Definition geo.h:661
rheolef::geo_base_rep::end
iterator end(size_type dim)
Definition geo.h:750
rheolef::geo_base_rep::_xmin
node_type _xmin
Definition geo.h:687
rheolef::geo_base_rep::_hmax
T _hmax
Definition geo.h:690
rheolef::geo_base_rep::_hmin
T _hmin
Definition geo.h:689
rheolef::geo_base_rep::operator[]
const_reference operator[](size_type ie) const
Definition geo.h:651
rheolef::geo_base_rep::dis_get_geo_element
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition geo.cc:582
rheolef::geo_base_rep::dis_inod2dis_iv
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition geo.cc:565
rheolef::geo_base_rep::n_domain_indirect
size_type n_domain_indirect() const
Definition geo.h:595
rheolef::geo_base_rep::dis_n_vertex
size_type dis_n_vertex() const
Definition geo.h:644
rheolef::geo_base_rep::begin
iterator begin(size_type dim)
iterator by dimension: wraps iterator by geo_element variant
Definition geo.h:740
rheolef::geo_base_rep::loaded_map
static loaded_map_t & loaded_map()
Definition geo.cc:151
rheolef::geo_base_rep::const_iterator
base::const_iterator const_iterator
Definition geo.h:537
rheolef::geo_base_rep::hmax
const T & hmax() const
Definition geo.h:575
rheolef::geo_base_rep::_node
disarray< node_type, M > _node
Definition geo.h:684
rheolef::geo_base_rep::variant
size_type variant() const
Definition geo.h:559
rheolef::geo_base_rep::is_broken
bool is_broken() const
Definition geo.h:565
rheolef::geo_base_rep::_name
std::string _name
Definition geo.h:674
rheolef::geo_base_rep::set_serial_number
void set_serial_number(size_type i)
Definition geo.h:570
rheolef::geo_base_rep::seq_nearest
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition geo_nearest.cc:331
rheolef::geo_base_rep::xmax
const node_type & xmax() const
Definition geo.h:573
rheolef::geo_base_rep::_have_connectivity
bool _have_connectivity
Definition geo.h:681
rheolef::geo_base_rep::coordinate_type
base::coordinate_type coordinate_type
Definition geo.h:542
rheolef::geo_base_rep::end_by_variant
iterator_by_variant end_by_variant(variant_type variant)
Definition geo.h:726
rheolef::geo_base_rep::end
const_iterator end() const
Definition geo.h:658
rheolef::geo_base_rep::~geo_base_rep
~geo_base_rep()
Definition geo.cc:388
rheolef::geo_base_rep::dis_n_node
size_type dis_n_node() const
Definition geo.h:641
rheolef::geo_base_rep::sizes
const geo_size & sizes() const
Definition geo.h:576
rheolef::geo_base_rep::_gs
geo_size _gs
Definition geo.h:679
rheolef::geo_base_rep::_geo_element
std::array< hack_array< geo_element_hack, M >, reference_element::max_variant > _geo_element
Definition geo.h:678
rheolef::geo_base_rep::reference
base::reference reference
Definition geo.h:540
rheolef::geo_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_trace_move.cc:83
rheolef::geo_base_rep::set_coordinate_system
void set_coordinate_system(coordinate_type sys_coord)
Definition geo.h:567
rheolef::geo_base_rep::compute_bbox
void compute_bbox()
Definition geo.cc:486
rheolef::geo_base_rep::have_domain_indirect
bool have_domain_indirect(const std::string &name) const
Definition geo.cc:417
rheolef::geo_base_rep::begin
const_iterator begin(size_type dim) const
Definition geo.h:654
rheolef::geo_base_rep::ownership
const distributor & ownership() const
Definition geo.h:635
rheolef::geo_base_rep::base
geo_abstract_rep< T, M > base
Definition geo.h:532
rheolef::geo_base_rep::dis_nearest
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition geo_nearest.cc:339
rheolef::geo_base_rep::set_nodes
void set_nodes(const disarray< node_type, M > &x)
Definition geo.h:594
rheolef::geo_base_rep::order
size_type order() const
Definition geo.h:638
rheolef::geo_base_rep::neighbour_guard
void neighbour_guard() const
Definition geo.h:706
rheolef::geo_base_rep::comm
const communicator & comm() const
Definition geo.h:637
rheolef::geo_base_rep::node_type
base::node_type node_type
Definition geo.h:534
rheolef::geo_basic< T, distributed >::geo_element_ios_ownership
distributor geo_element_ios_ownership(size_type dim) const
Definition geo.h:1437
rheolef::geo_basic< T, distributed >::end
const_iterator end(size_type dim) const
Definition geo.h:1538
rheolef::geo_basic< T, distributed >::variant_type
rep::variant_type variant_type
Definition geo.h:1378
rheolef::geo_basic< T, distributed >::const_iterator
rep::const_iterator const_iterator
Definition geo.h:1383
rheolef::geo_basic< T, distributed >::nearest
void nearest(const disarray< point_basic< T >, distributed > &x, disarray< point_basic< T >, distributed > &x_nearest, disarray< size_type, distributed > &dis_ie) const
Definition geo.h:1508
rheolef::geo_basic< T, distributed >::save
void save(std::string filename="") const
rheolef::geo_basic< T, distributed >::node
const node_type & node(size_type inod) const
Definition geo.h:1446
rheolef::geo_basic< T, distributed >::seq_nearest
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition geo.h:1500
rheolef::geo_basic< T, distributed >::coordinate_system
coordinate_type coordinate_system() const
Definition geo.h:1414
rheolef::geo_basic< T, distributed >::set_coordinate_system
void set_coordinate_system(std::string sys_coord_name)
Definition geo.h:1519
rheolef::geo_basic< T, distributed >::name
std::string name() const
Definition geo.h:1407
rheolef::geo_basic< T, distributed >::neighbour
size_type neighbour(size_type ie, size_type loc_isid) const
Definition geo.h:1434
rheolef::geo_basic< T, distributed >::n_vertex
size_type n_vertex() const
Definition geo.h:1532
rheolef::geo_basic< T, distributed >::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition geo.h:1422
rheolef::geo_basic< T, distributed >::begin
const_iterator begin() const
Definition geo.h:1539
rheolef::geo_basic< T, distributed >::geo_basic
geo_basic(details::zero_dimension, const communicator &comm=communicator())
rheolef::geo_basic< T, distributed >::set_nodes
void set_nodes(const disarray< node_type, distributed > &x)
rheolef::geo_basic< T, distributed >::dis_size
size_type dis_size() const
Definition geo.h:1531
rheolef::geo_basic< T, distributed >::get_background_geo
const geo_basic< T, distributed > & get_background_geo() const
rheolef::geo_basic< T, distributed >::size
size_type size(size_type dim) const
Definition geo.h:1527
rheolef::geo_basic< T, distributed >::geo_element_map_type
rep::geo_element_map_type geo_element_map_type
Definition geo.h:1387
rheolef::geo_basic< T, distributed >::dis_inod
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition geo.h:1448
rheolef::geo_basic< T, distributed >::geo_basic
geo_basic(const domain_indirect_basic< distributed > &dom, const geo_basic< T, distributed > &omega)
rheolef::geo_basic< T, distributed >::ige2ios_dis_ige
size_type ige2ios_dis_ige(size_type dim, size_type ige) const
Definition geo.h:1439
rheolef::geo_basic< T, distributed >::n_node
size_type n_node() const
Definition geo.h:1445
rheolef::geo_basic< T, distributed >::dom2bgd_geo_element
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition geo.h:1432
rheolef::geo_basic< T, distributed >::dis_node
const node_type & dis_node(size_type dis_inod) const
Definition geo.h:1447
rheolef::geo_basic< T, distributed >::rep
geo_abstract_rep< T, distributed > rep
Definition geo.h:1373
rheolef::geo_basic< T, distributed >::serial_number
size_type serial_number() const
Definition geo.h:1412
rheolef::geo_basic< T, distributed >::set_ios_permutation
void set_ios_permutation(disarray< size_type, distributed > &idof2ios_dis_idof) const
Definition geo.h:1565
rheolef::geo_basic< T, distributed >::set_dimension
void set_dimension(size_type dim)
rheolef::geo_basic< T, distributed >::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.h:1478
rheolef::geo_basic< T, distributed >::map_dimension
size_type map_dimension() const
Definition geo.h:1410
rheolef::geo_basic< T, distributed >::xmin
const node_type & xmin() const
Definition geo.h:1418
rheolef::geo_basic< T, distributed >::get_domain_indirect
const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const
Definition geo.h:1456
rheolef::geo_basic< T, distributed >::hmin
const T & hmin() const
Definition geo.h:1420
rheolef::geo_basic< T, distributed >::get_piola_basis
const basis_basic< T > & get_piola_basis() const
Definition geo.h:1416
rheolef::geo_basic< T, distributed >::locate
void locate(const disarray< point_basic< T >, distributed > &x, disarray< size_type, distributed > &dis_ie) const
Definition geo.h:1476
rheolef::geo_basic< T, distributed >::size
size_type size() const
Definition geo.h:1530
rheolef::geo_basic< T, distributed >::ios_sizes
const geo_size & ios_sizes() const
Definition geo.h:1425
rheolef::geo_basic< T, distributed >::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.h:1468
rheolef::geo_basic< T, distributed >::familyname
std::string familyname() const
Definition geo.h:1408
rheolef::geo_basic< T, distributed >::reference
rep::reference reference
Definition geo.h:1380
rheolef::geo_basic< T, distributed >::put
odiststream & put(odiststream &ops) const
Definition geo.h:1558
rheolef::geo_basic< T, distributed >::get_external_geo_element_map
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition geo.h:1546
rheolef::geo_basic< T, distributed >::set_name
void set_name(std::string name)
rheolef::geo_basic< T, distributed >::n_domain
size_type n_domain() const
Definition geo.h:1461
rheolef::geo_basic< T, distributed >::begin_by_variant
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition geo.h:1542
rheolef::geo_basic< T, distributed >::coordinate_type
rep::coordinate_type coordinate_type
Definition geo.h:1386
rheolef::geo_basic< T, distributed >::trace_ray_boundary
void trace_ray_boundary(const disarray< point_basic< T >, distributed > &x, const disarray< point_basic< T >, distributed > &v, disarray< size_type, distributed > &dis_ie, disarray< point_basic< T >, distributed > &y) const
Definition geo.h:1488
rheolef::geo_basic< T, distributed >::dis_inod2dis_iv
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition geo.h:1517
rheolef::geo_basic< T, distributed >::end_by_variant
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition geo.h:1544
rheolef::geo_basic< T, distributed >::dimension
size_type dimension() const
Definition geo.h:1409
rheolef::geo_basic< T, distributed >::iterator
rep::iterator iterator
Definition geo.h:1382
rheolef::geo_basic< T, distributed >::ios_ige2dis_ige
size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const
Definition geo.h:1443
rheolef::geo_basic< T, distributed >::check
bool check(bool verbose=true) const
Definition geo.h:1561
rheolef::geo_basic< T, distributed >::trace_move
void trace_move(const disarray< point_basic< T >, distributed > &x, const disarray< point_basic< T >, distributed > &v, disarray< size_type, distributed > &dis_ie, disarray< point_basic< T >, distributed > &y) const
Definition geo.h:1494
rheolef::geo_basic< T, distributed >::const_reference
rep::const_reference const_reference
Definition geo.h:1381
rheolef::geo_basic< T, distributed >::n_domain_indirect
size_type n_domain_indirect() const
Definition geo.h:1452
rheolef::geo_basic< T, distributed >::dis_n_vertex
size_type dis_n_vertex() const
Definition geo.h:1533
rheolef::geo_basic< T, distributed >::hmax
const T & hmax() const
Definition geo.h:1421
rheolef::geo_basic< T, distributed >::dis_ige2ios_dis_ige
size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const
Definition geo.h:1441
rheolef::geo_basic< T, distributed >::variant
size_type variant() const
Definition geo.h:1413
rheolef::geo_basic< T, distributed >::is_broken
bool is_broken() const
Definition geo.h:1411
rheolef::geo_basic< T, distributed >::geo_basic
geo_basic(const geo_basic< T, distributed > &lambda, const disarray< point_basic< T >, distributed > &node_list, const std::array< disarray< geo_element_auto< heap_allocator< size_type > >, distributed >, reference_element::max_variant > &elt_list)
Definition geo.h:1398
rheolef::geo_basic< T, distributed >::set_serial_number
void set_serial_number(size_type i)
rheolef::geo_basic< T, distributed >::xmax
const node_type & xmax() const
Definition geo.h:1419
rheolef::geo_basic< T, distributed >::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.h:1472
rheolef::geo_basic< T, distributed >::const_iterator_by_variant
rep::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:1385
rheolef::geo_basic< T, distributed >::bgd2dom_geo_element
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition geo.h:1430
rheolef::geo_basic< T, distributed >::get_nodes
const disarray< node_type, distributed > & get_nodes() const
Definition geo.h:1450
rheolef::geo_basic< T, distributed >::size_type
rep::size_type size_type
Definition geo.h:1376
rheolef::geo_basic< T, distributed >::rep_geo_rep
geo_rep< T, distributed > rep_geo_rep
Definition geo.h:1374
rheolef::geo_basic< T, distributed >::insert_domain_indirect
void insert_domain_indirect(const domain_indirect_basic< distributed > &dom) const
Definition geo.h:1458
rheolef::geo_basic< T, distributed >::end
const_iterator end() const
Definition geo.h:1540
rheolef::geo_basic< T, distributed >::dis_nearest
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition geo.h:1504
rheolef::geo_basic< T, distributed >::get_domain
geo_basic< T, distributed > get_domain(size_type i) const
rheolef::geo_basic< T, distributed >::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.h:1426
rheolef::geo_basic< T, distributed >::get_domain_indirect
const domain_indirect_basic< distributed > & get_domain_indirect(size_type i) const
Definition geo.h:1454
rheolef::geo_basic< T, distributed >::get_background_domain
geo_basic< T, distributed > get_background_domain() const
rheolef::geo_basic< T, distributed >::node_map_type
rep::node_map_type node_map_type
Definition geo.h:1379
rheolef::geo_basic< T, distributed >::sizes
const geo_size & sizes() const
Definition geo.h:1424
rheolef::geo_basic< T, distributed >::get_igev2ios_dis_igev
const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() const
Definition geo.h:1570
rheolef::geo_basic< T, distributed >::node_type
rep::node_type node_type
Definition geo.h:1377
rheolef::geo_basic< T, distributed >::reset_order
void reset_order(size_type order)
rheolef::geo_basic< T, distributed >::iterator_by_variant
rep::iterator_by_variant iterator_by_variant
Definition geo.h:1384
rheolef::geo_basic< T, distributed >::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.h:1483
rheolef::geo_basic< T, distributed >::coordinate_system_name
std::string coordinate_system_name() const
Definition geo.h:1415
rheolef::geo_basic< T, distributed >::set_coordinate_system
void set_coordinate_system(coordinate_type sys_coord)
rheolef::geo_basic< T, distributed >::have_domain_indirect
bool have_domain_indirect(const std::string &name) const
Definition geo.h:1453
rheolef::geo_basic< T, distributed >::begin
const_iterator begin(size_type dim) const
Definition geo.h:1537
rheolef::geo_basic< T, distributed >::base
smart_pointer_clone< rep > base
Definition geo.h:1375
rheolef::geo_basic< T, distributed >::memory_type
distributed memory_type
Definition geo.h:1372
rheolef::geo_basic< T, distributed >::dis_get_geo_element
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition geo.h:1428
rheolef::geo_basic< T, distributed >::build_by_subdividing
void build_by_subdividing(const geo_basic< T, distributed > &omega, size_type k)
rheolef::geo_basic< T, distributed >::dis_size
size_type dis_size(size_type dim) const
Definition geo.h:1528
rheolef::geo_basic< T, distributed >::order
size_type order() const
Definition geo.h:1417
rheolef::geo_basic< T, distributed >::neighbour_guard
void neighbour_guard() const
Definition geo.h:1436
rheolef::geo_basic< T, distributed >::comm
const communicator & comm() const
Definition geo.h:1529
rheolef::geo_basic< T, sequential >::end
const_iterator end(size_type dim) const
Definition geo.h:1217
rheolef::geo_basic< T, sequential >::variant_type
rep::variant_type variant_type
Definition geo.h:1119
rheolef::geo_basic< T, sequential >::const_iterator
rep::const_iterator const_iterator
Definition geo.h:1123
rheolef::geo_basic< T, sequential >::save
void save(std::string filename="") const
rheolef::geo_basic< T, sequential >::node
const node_type & node(size_type inod) const
Definition geo.h:1173
rheolef::geo_basic< T, sequential >::get_nodes
const disarray< node_type, sequential > & get_nodes() const
Definition geo.h:1177
rheolef::geo_basic< T, sequential >::seq_nearest
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition geo.h:1279
rheolef::geo_basic< T, sequential >::coordinate_system
coordinate_type coordinate_system() const
Definition geo.h:1153
rheolef::geo_basic< T, sequential >::set_coordinate_system
void set_coordinate_system(std::string sys_coord_name)
Definition geo.h:1203
rheolef::geo_basic< T, sequential >::name
std::string name() const
Definition geo.h:1146
rheolef::geo_basic< T, sequential >::neighbour
size_type neighbour(size_type ie, size_type loc_isid) const
Definition geo.h:1169
rheolef::geo_basic< T, sequential >::n_vertex
size_type n_vertex() const
Definition geo.h:1213
rheolef::geo_basic< T, sequential >::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition geo.h:1161
rheolef::geo_basic< T, sequential >::get_domain
geo_basic< T, sequential > get_domain(size_type i) const
rheolef::geo_basic< T, sequential >::begin
const_iterator begin() const
Definition geo.h:1218
rheolef::geo_basic< T, sequential >::geo_basic
geo_basic(details::zero_dimension, const communicator &comm=communicator())
rheolef::geo_basic< T, sequential >::dis_size
size_type dis_size() const
Definition geo.h:1212
rheolef::geo_basic< T, sequential >::size
size_type size(size_type dim) const
Definition geo.h:1209
rheolef::geo_basic< T, sequential >::geo_element_map_type
rep::geo_element_map_type geo_element_map_type
Definition geo.h:1127
rheolef::geo_basic< T, sequential >::dis_inod
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition geo.h:1175
rheolef::geo_basic< T, sequential >::ige2ios_dis_ige
size_type ige2ios_dis_ige(size_type dim, size_type ige) const
Definition geo.h:1304
rheolef::geo_basic< T, sequential >::memory_type
sequential memory_type
Definition geo.h:1113
rheolef::geo_basic< T, sequential >::insert_domain_indirect
void insert_domain_indirect(const domain_indirect_basic< sequential > &dom) const
Definition geo.h:1186
rheolef::geo_basic< T, sequential >::n_node
size_type n_node() const
Definition geo.h:1172
rheolef::geo_basic< T, sequential >::dom2bgd_geo_element
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition geo.h:1168
rheolef::geo_basic< T, sequential >::dis_node
const node_type & dis_node(size_type dis_inod) const
Definition geo.h:1174
rheolef::geo_basic< T, sequential >::serial_number
size_type serial_number() const
Definition geo.h:1151
rheolef::geo_basic< T, sequential >::set_dimension
void set_dimension(size_type dim)
rheolef::geo_basic< T, sequential >::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.h:1257
rheolef::geo_basic< T, sequential >::map_dimension
size_type map_dimension() const
Definition geo.h:1149
rheolef::geo_basic< T, sequential >::xmin
const node_type & xmin() const
Definition geo.h:1157
rheolef::geo_basic< T, sequential >::hmin
const T & hmin() const
Definition geo.h:1159
rheolef::geo_basic< T, sequential >::get_piola_basis
const basis_basic< T > & get_piola_basis() const
Definition geo.h:1155
rheolef::geo_basic< T, sequential >::build_from_data
void build_from_data(const geo_header &hdr, const disarray< node_type, sequential > &node, std::array< disarray< geo_element_auto<>, sequential >, reference_element::max_variant > &tmp_geo_element, bool do_upgrade)
rheolef::geo_basic< T, sequential >::nearest
void nearest(const disarray< point_basic< T >, sequential > &x, disarray< point_basic< T >, sequential > &x_nearest, disarray< size_type, sequential > &dis_ie) const
Definition geo.h:1287
rheolef::geo_basic< T, sequential >::size
size_type size() const
Definition geo.h:1211
rheolef::geo_basic< T, sequential >::ios_sizes
const geo_size & ios_sizes() const
Definition geo.h:1163
rheolef::geo_basic< T, sequential >::trace_ray_boundary
void trace_ray_boundary(const disarray< point_basic< T >, sequential > &x, const disarray< point_basic< T >, sequential > &v, disarray< size_type, sequential > &dis_ie, disarray< point_basic< T >, sequential > &y) const
Definition geo.h:1267
rheolef::geo_basic< T, sequential >::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.h:1245
rheolef::geo_basic< T, sequential >::build_by_subdividing
void build_by_subdividing(const geo_basic< T, sequential > &omega, size_type k)
rheolef::geo_basic< T, sequential >::familyname
std::string familyname() const
Definition geo.h:1147
rheolef::geo_basic< T, sequential >::get_background_domain
geo_basic< T, sequential > get_background_domain() const
rheolef::geo_basic< T, sequential >::reference
rep::reference reference
Definition geo.h:1120
rheolef::geo_basic< T, sequential >::get_external_geo_element_map
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition geo.h:1297
rheolef::geo_basic< T, sequential >::set_name
void set_name(std::string name)
rheolef::geo_basic< T, sequential >::n_domain
size_type n_domain() const
Definition geo.h:1189
rheolef::geo_basic< T, sequential >::geo_basic
geo_basic(const domain_indirect_basic< sequential > &dom, const geo_basic< T, sequential > &omega)
rheolef::geo_basic< T, sequential >::begin_by_variant
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition geo.h:1293
rheolef::geo_basic< T, sequential >::coordinate_type
rep::coordinate_type coordinate_type
Definition geo.h:1126
rheolef::geo_basic< T, sequential >::dis_inod2dis_iv
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition geo.h:1178
rheolef::geo_basic< T, sequential >::end_by_variant
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition geo.h:1295
rheolef::geo_basic< T, sequential >::get_domain_indirect
const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const
Definition geo.h:1182
rheolef::geo_basic< T, sequential >::dimension
size_type dimension() const
Definition geo.h:1148
rheolef::geo_basic< T, sequential >::iterator
rep::iterator iterator
Definition geo.h:1122
rheolef::geo_basic< T, sequential >::set_ios_permutation
void set_ios_permutation(disarray< size_type, sequential > &idof2ios_dis_idof) const
Definition geo.h:1307
rheolef::geo_basic< T, sequential >::ios_ige2dis_ige
size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const
Definition geo.h:1306
rheolef::geo_basic< T, sequential >::trace_move
void trace_move(const disarray< point_basic< T >, sequential > &x, const disarray< point_basic< T >, sequential > &v, disarray< size_type, sequential > &dis_ie, disarray< point_basic< T >, sequential > &y) const
Definition geo.h:1273
rheolef::geo_basic< T, sequential >::check
bool check(bool verbose=true) const
Definition geo.h:1232
rheolef::geo_basic< T, sequential >::const_reference
rep::const_reference const_reference
Definition geo.h:1121
rheolef::geo_basic< T, sequential >::n_domain_indirect
size_type n_domain_indirect() const
Definition geo.h:1180
rheolef::geo_basic< T, sequential >::dis_n_vertex
size_type dis_n_vertex() const
Definition geo.h:1214
rheolef::geo_basic< T, sequential >::locate
void locate(const disarray< point_basic< T >, sequential > &x, disarray< size_type, sequential > &dis_ie) const
Definition geo.h:1253
rheolef::geo_basic< T, sequential >::hmax
const T & hmax() const
Definition geo.h:1160
rheolef::geo_basic< T, sequential >::dis_ige2ios_dis_ige
size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const
Definition geo.h:1305
rheolef::geo_basic< T, sequential >::variant
size_type variant() const
Definition geo.h:1152
rheolef::geo_basic< T, sequential >::is_broken
bool is_broken() const
Definition geo.h:1150
rheolef::geo_basic< T, sequential >::set_serial_number
void set_serial_number(size_type i)
rheolef::geo_basic< T, sequential >::xmax
const node_type & xmax() const
Definition geo.h:1158
rheolef::geo_basic< T, sequential >::set_nodes
void set_nodes(const disarray< node_type, sequential > &x)
rheolef::geo_basic< T, sequential >::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.h:1249
rheolef::geo_basic< T, sequential >::get_background_geo
const geo_basic< T, sequential > & get_background_geo() const
rheolef::geo_basic< T, sequential >::const_iterator_by_variant
rep::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:1125
rheolef::geo_basic< T, sequential >::bgd2dom_geo_element
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition geo.h:1167
rheolef::geo_basic< T, sequential >::geo_basic
geo_basic(const geo_basic< T, sequential > &lambda, const disarray< point_basic< T >, sequential > &node_list, const std::array< disarray< geo_element_auto< heap_allocator< size_type > >, sequential >, reference_element::max_variant > &elt_list)
Definition geo.h:1137
rheolef::geo_basic< T, sequential >::size_type
rep::size_type size_type
Definition geo.h:1117
rheolef::geo_basic< T, sequential >::rep
geo_abstract_rep< T, sequential > rep
Definition geo.h:1114
rheolef::geo_basic< T, sequential >::end
const_iterator end() const
Definition geo.h:1219
rheolef::geo_basic< T, sequential >::dis_nearest
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition geo.h:1283
rheolef::geo_basic< T, sequential >::rep_geo_rep
geo_rep< T, sequential > rep_geo_rep
Definition geo.h:1115
rheolef::geo_basic< T, sequential >::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.h:1164
rheolef::geo_basic< T, sequential >::sizes
const geo_size & sizes() const
Definition geo.h:1162
rheolef::geo_basic< T, sequential >::node_type
rep::node_type node_type
Definition geo.h:1118
rheolef::geo_basic< T, sequential >::get_domain_indirect
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
Definition geo.h:1184
rheolef::geo_basic< T, sequential >::reset_order
void reset_order(size_type order)
rheolef::geo_basic< T, sequential >::iterator_by_variant
rep::iterator_by_variant iterator_by_variant
Definition geo.h:1124
rheolef::geo_basic< T, sequential >::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.h:1262
rheolef::geo_basic< T, sequential >::coordinate_system_name
std::string coordinate_system_name() const
Definition geo.h:1154
rheolef::geo_basic< T, sequential >::set_coordinate_system
void set_coordinate_system(coordinate_type sys_coord)
rheolef::geo_basic< T, sequential >::have_domain_indirect
bool have_domain_indirect(const std::string &name) const
Definition geo.h:1181
rheolef::geo_basic< T, sequential >::begin
const_iterator begin(size_type dim) const
Definition geo.h:1216
rheolef::geo_basic< T, sequential >::base
smart_pointer_clone< rep > base
Definition geo.h:1116
rheolef::geo_basic< T, sequential >::dis_get_geo_element
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition geo.h:1165
rheolef::geo_basic< T, sequential >::dis_size
size_type dis_size(size_type dim) const
Definition geo.h:1210
rheolef::geo_basic< T, sequential >::order
size_type order() const
Definition geo.h:1156
rheolef::geo_basic< T, sequential >::neighbour_guard
void neighbour_guard() const
Definition geo.h:1171
rheolef::geo_basic< T, sequential >::comm
const communicator & comm() const
Definition geo.h:1208
rheolef::geo_basic
generic mesh with rerefence counting
Definition geo.h:1089
rheolef::geo_basic::memory_type
M memory_type
Definition geo.h:1091
rheolef::geo_element_auto
Definition geo_element.h:376
rheolef::geo_element_hack::size_type
geo_element::size_type size_type
Definition geo_element.h:466
rheolef::geo_element
see the geo_element page for the full documentation
Definition geo_element.h:102
rheolef::geo_element::size
size_type size() const
Definition geo_element.h:168
rheolef::geo_element::name
char name() const
Definition geo_element.h:169
rheolef::geo_locate
Definition geo_locate.h:40
rheolef::geo_nearest
Definition geo_nearest.h:41
rheolef::geo_rep< T, distributed >
distributed mesh representation
Definition geo.h:929
rheolef::geo_rep< T, distributed >::end
const_iterator end(size_type dim) const
Definition geo.h:1004
rheolef::geo_rep< T, distributed >::variant_type
base::variant_type variant_type
Definition geo.h:936
rheolef::geo_rep< T, distributed >::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:943
rheolef::geo_rep< T, distributed >::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition geo.h:999
rheolef::geo_rep< T, distributed >::size
size_type size(size_type dim) const
Definition geo.h:998
rheolef::geo_rep< T, distributed >::iterator_by_variant
base::iterator_by_variant iterator_by_variant
Definition geo.h:942
rheolef::geo_rep< T, distributed >::iterator
base::iterator iterator
Definition geo.h:940
rheolef::geo_rep< T, distributed >::map_dimension
size_type map_dimension() const
Definition geo.h:996
rheolef::geo_rep< T, distributed >::get_domain_indirect
const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const
Definition geo.h:1011
rheolef::geo_rep< T, distributed >::_ios_igev2dis_igev
std::array< disarray< size_type, distributed >, reference_element::max_variant > _ios_igev2dis_igev
Definition geo.h:1069
rheolef::geo_rep< T, distributed >::base
geo_base_rep< T, distributed > base
Definition geo.h:933
rheolef::geo_rep< T, distributed >::_ios_gs
geo_size _ios_gs
Definition geo.h:1067
rheolef::geo_rep< T, distributed >::size
size_type size() const
Definition geo.h:1015
rheolef::geo_rep< T, distributed >::_ios_ige2dis_ige
std::array< disarray< size_type >, 4 > _ios_ige2dis_ige
Definition geo.h:1066
rheolef::geo_rep< T, distributed >::ios_sizes
const geo_size & ios_sizes() const
Definition geo.h:973
rheolef::geo_rep< T, distributed >::_igev2ios_dis_igev
std::array< disarray< size_type, distributed >, reference_element::max_variant > _igev2ios_dis_igev
Definition geo.h:1068
rheolef::geo_rep< T, distributed >::size_type
base::size_type size_type
Definition geo.h:934
rheolef::geo_rep< T, distributed >::get_external_geo_element_map
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition geo.h:1007
rheolef::geo_rep< T, distributed >::vertex_ownership
const distributor & vertex_ownership() const
Definition geo.h:1016
rheolef::geo_rep< T, distributed >::_ios_inod2dis_inod
disarray< size_type > _ios_inod2dis_inod
Definition geo.h:1065
rheolef::geo_rep< T, distributed >::const_reference
base::const_reference const_reference
Definition geo.h:939
rheolef::geo_rep< T, distributed >::_inod2ios_dis_inod
disarray< size_type > _inod2ios_dis_inod
Definition geo.h:1064
rheolef::geo_rep< T, distributed >::const_iterator
base::const_iterator const_iterator
Definition geo.h:941
rheolef::geo_rep< T, distributed >::end
iterator end(size_type dim)
Definition geo.h:1006
rheolef::geo_rep< T, distributed >::is_broken
bool is_broken() const
Definition geo.h:997
rheolef::geo_rep< T, distributed >::node_map_type
base::node_map_type node_map_type
Definition geo.h:937
rheolef::geo_rep< T, distributed >::coordinate_type
base::coordinate_type coordinate_type
Definition geo.h:944
rheolef::geo_rep< T, distributed >::geo_element_map_type
base::geo_element_map_type geo_element_map_type
Definition geo.h:945
rheolef::geo_rep< T, distributed >::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.h:1000
rheolef::geo_rep< T, distributed >::begin
iterator begin(size_type dim)
Definition geo.h:1005
rheolef::geo_rep< T, distributed >::get_igev2ios_dis_igev
const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() const
Definition geo.h:1074
rheolef::geo_rep< T, distributed >::reset_order
void reset_order(size_type order)
rheolef::geo_rep< T, distributed >::reference
base::reference reference
Definition geo.h:938
rheolef::geo_rep< T, distributed >::get_geo_element
reference get_geo_element(size_type dim, size_type ige)
Definition geo.h:1001
rheolef::geo_rep< T, distributed >::begin
const_iterator begin(size_type dim) const
Definition geo.h:1003
rheolef::geo_rep< T, distributed >::build_by_subdividing
void build_by_subdividing(const geo_basic< T, distributed > &omega, size_type k)
rheolef::geo_rep< T, distributed >::node_type
base::node_type node_type
Definition geo.h:935
rheolef::geo_rep< T, distributed >::get_domain_indirect
const domain_indirect_basic< distributed > & get_domain_indirect(size_type idom) const
Definition geo.h:1010
rheolef::geo_rep< T, sequential >
Definition geo.h:786
rheolef::geo_rep< T, sequential >::end
const_iterator end(size_type dim) const
Definition geo.h:854
rheolef::geo_rep< T, sequential >::variant_type
base::variant_type variant_type
Definition geo.h:793
rheolef::geo_rep< T, sequential >::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:799
rheolef::geo_rep< T, sequential >::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition geo.h:848
rheolef::geo_rep< T, sequential >::iterator_by_variant
base::iterator_by_variant iterator_by_variant
Definition geo.h:798
rheolef::geo_rep< T, sequential >::iterator
base::iterator iterator
Definition geo.h:796
rheolef::geo_rep< T, sequential >::map_dimension
size_type map_dimension() const
Definition geo.h:846
rheolef::geo_rep< T, sequential >::build_by_subdividing
void build_by_subdividing(const geo_basic< T, sequential > &omega, size_type k)
rheolef::geo_rep< T, sequential >::put
odiststream & put(odiststream &ops) const
Definition geo.h:870
rheolef::geo_rep< T, sequential >::size_type
base::size_type size_type
Definition geo.h:791
rheolef::geo_rep< T, sequential >::vertex_ownership
const distributor & vertex_ownership() const
Definition geo.h:862
rheolef::geo_rep< T, sequential >::const_reference
base::const_reference const_reference
Definition geo.h:795
rheolef::geo_rep< T, sequential >::const_iterator
base::const_iterator const_iterator
Definition geo.h:797
rheolef::geo_rep< T, sequential >::end
iterator end(size_type dim)
Definition geo.h:852
rheolef::geo_rep< T, sequential >::is_broken
bool is_broken() const
Definition geo.h:847
rheolef::geo_rep< T, sequential >::coordinate_type
base::coordinate_type coordinate_type
Definition geo.h:800
rheolef::geo_rep< T, sequential >::geo_element_map_type
base::geo_element_map_type geo_element_map_type
Definition geo.h:801
rheolef::geo_rep< T, sequential >::build_external_entities
void build_external_entities()
Definition geo.h:915
rheolef::geo_rep< T, sequential >::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.h:849
rheolef::geo_rep< T, sequential >::begin
iterator begin(size_type dim)
Definition geo.h:851
rheolef::geo_rep< T, sequential >::get_domain_indirect
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
Definition geo.h:858
rheolef::geo_rep< T, sequential >::reset_order
void reset_order(size_type order)
rheolef::geo_rep< T, sequential >::reference
base::reference reference
Definition geo.h:794
rheolef::geo_rep< T, sequential >::get_geo_element
reference get_geo_element(size_type dim, size_type ige)
Definition geo.h:850
rheolef::geo_rep< T, sequential >::begin
const_iterator begin(size_type dim) const
Definition geo.h:853
rheolef::geo_rep< T, sequential >::get_domain_indirect
const domain_indirect_basic< sequential > & get_domain_indirect(size_type idom) const
Definition geo.h:857
rheolef::geo_rep< T, sequential >::base
geo_base_rep< T, sequential > base
Definition geo.h:790
rheolef::geo_rep< T, sequential >::node_type
base::node_type node_type
Definition geo.h:792
rheolef::geo_rep
sequential mesh representation
Definition geo.h:778
rheolef::geo_trace_ray_boundary
Definition geo_trace_ray_boundary.h:41
rheolef::hack_array::iterator
std::vector< T, A >::iterator iterator
Definition hack_array.h:350
rheolef::hack_array::const_iterator
std::vector< T, A >::const_iterator const_iterator
Definition hack_array.h:351
rheolef::heap_allocator
Definition heap_allocator.h:73
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::point_basic
Definition point.h:86
rheolef::point_basic::get
std::istream & get(std::istream &s, int d=3)
Definition point.h:376
rheolef::point_basic::size_type
size_t size_type
Definition point.h:91
rheolef::point_basic::put
std::ostream & put(std::ostream &s, int d=3) const
Definition point.h:388
rheolef::reference_element
see the reference_element page for the full documentation
Definition reference_element.h:66
rheolef::reference_element::max_variant
static const variant_type max_variant
Definition reference_element.h:82
rheolef::reference_element::last_variant_by_dimension
static variant_type last_variant_by_dimension(size_type dim)
Definition reference_element.h:150
rheolef::reference_element::first_variant_by_dimension
static variant_type first_variant_by_dimension(size_type dim)
Definition reference_element.h:148
rheolef::reference_element::variant_type
size_type variant_type
Definition reference_element.h:72
rheolef::smart_pointer_clone
Definition smart_pointer.h:370
rheolef::geo
geo_basic< Float, rheo_default_memory_model > geo
Definition geo.h:1575
main
int main()
Definition field2bb.cc:58
T
Expr1::float_type T
Definition field_expr.h:230
dump
verbose clean transpose logscale grid shrink ball stereo iso volume skipvtk deformation fastfieldload lattice reader_on_stdin color format format format format format format format format format format format format format format format format format format dump
Definition iorheo-members.h:119
mkgeo_ball.n
int n
Definition mkgeo_ball.sh:150
mkgeo_sector.m
m
Definition mkgeo_sector.sh:118
rheolef::space_constant::coordinate_system
coordinate_type coordinate_system(std::string sys_coord)
Definition space_constant.cc:75
rheolef::space_constant::coordinate_system_name
std::string coordinate_system_name(coordinate_type i)
Definition space_constant.cc:69
rheolef::space_constant::coordinate_type
coordinate_type
Definition space_constant.h:119
rheolef
This file is part of Rheolef.
Definition compiler_eigen.h:39
rheolef::geo_build_by_subdividing
void geo_build_by_subdividing(geo_rep< T, M > &new_omega, const geo_basic< T, M > &old_omega, typename geo_rep< T, M >::size_type k)
Definition geo_subdivide.cc:129
rheolef::boundary_guard
void boundary_guard(const geo_basic< T, M > &omega)
Definition geo.cc:600
rheolef::operator==
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition heap_allocator.h:171
rheolef::operator<<
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition catchmark.h:99
rheolef::sides_guard
void sides_guard(const geo_basic< T, M > &omega)
Definition geo.cc:639
rheolef::put
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
Definition tiny_lu.h:155
rheolef::geo_load
geo_basic< T, M > geo_load(const std::string &filename)
sequential mesh with reference counting
Definition geo.cc:177
rheolef::operator>>
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition catchmark.h:88
rheolef::internal_sides_guard
void internal_sides_guard(const geo_basic< T, M > &omega)
Definition geo.cc:619
std
STL namespace.
check
void check(Float p, const field &uh)
Definition p_laplacian_post.cc:49
load
void load(idiststream &in, Float &p, field &uh)
Definition p_laplacian_post.cc:64
lambda
Definition yield_slip_circle.h:34
rheolef::_point_get
point input helper
Definition geo.h:155
rheolef::_point_get::d
size_type d
Definition geo.h:158
rheolef::_point_get::_point_get
_point_get(size_type d1)
Definition geo.h:157
rheolef::_point_get::operator()
std::istream & operator()(std::istream &is, point_basic< T > &x)
Definition geo.h:159
rheolef::_point_get::size_type
point_basic< T >::size_type size_type
Definition geo.h:156
rheolef::_point_put
point output helper
Definition geo.h:163
rheolef::_point_put::d
size_type d
Definition geo.h:166
rheolef::_point_put::size_type
point_basic< T >::size_type size_type
Definition geo.h:164
rheolef::_point_put::_point_put
_point_put(size_type d1)
Definition geo.h:165
rheolef::_point_put::operator()
std::ostream & operator()(std::ostream &os, const point_basic< T > &x)
Definition geo.h:167
rheolef::_round_point_put
point output helper, with rounding feature
Definition geo.h:171
rheolef::_round_point_put::d
size_type d
Definition geo.h:174
rheolef::_round_point_put::round
rounder_type< T > round
Definition geo.h:175
rheolef::_round_point_put::_round_point_put
_round_point_put(size_type d1, const T &eps1)
Definition geo.h:173
rheolef::_round_point_put::size_type
point_basic< T >::size_type size_type
Definition geo.h:172
rheolef::_round_point_put::operator()
std::ostream & operator()(std::ostream &os, const point_basic< T > &x)
Definition geo.h:176
rheolef::details::zero_dimension
Definition geo.h:147
rheolef::distributed
Definition communicator.h:128
rheolef::geo_header
Definition geo_header.h:32
rheolef::geo_iterator
geo iterator
Definition geo.h:193
rheolef::geo_iterator::_reset_to_next_or_last
void _reset_to_next_or_last()
Definition geo.h:223
rheolef::geo_iterator::operator++
_self operator++(int)
Definition geo.h:231
rheolef::geo_iterator::_variant
size_type _variant
Definition geo.h:238
rheolef::geo_iterator::value_type
T value_type
Definition geo.h:201
rheolef::geo_iterator::_first_by_var
IteratorByVariant _first_by_var[reference_element::max_variant]
Definition geo.h:241
rheolef::geo_iterator::_nonconst_iterator
geo_iterator< T, T &, T *, typename hack_array< T >::iterator > _nonconst_iterator
Definition geo.h:195
rheolef::geo_iterator::iterator_category
std::random_access_iterator_tag iterator_category
Definition geo.h:200
rheolef::geo_iterator::pointer
Ptr pointer
Definition geo.h:202
rheolef::geo_iterator::operator==
bool operator==(const _self &y) const
Definition geo.h:233
rheolef::geo_iterator::operator!=
bool operator!=(const _self &y) const
Definition geo.h:234
rheolef::geo_iterator::_variant_max
size_type _variant_max
Definition geo.h:239
rheolef::geo_iterator::operator*
reference operator*() const
Definition geo.h:215
rheolef::geo_iterator::reference
Ref reference
Definition geo.h:203
rheolef::geo_iterator::_iter_by_var
IteratorByVariant _iter_by_var
Definition geo.h:240
rheolef::geo_iterator::geo_iterator
geo_iterator(size_type dim, size_type variant, IteratorByVariant iter, Geo &omega)
Definition geo.h:368
rheolef::geo_iterator::difference_type
ptrdiff_t difference_type
Definition geo.h:205
rheolef::geo_iterator::size_type
T::size_type size_type
Definition geo.h:204
rheolef::geo_iterator::_self
geo_iterator< T, Ref, Ptr, IteratorByVariant > _self
Definition geo.h:194
rheolef::geo_iterator::operator->
pointer operator->() const
Definition geo.h:216
rheolef::geo_iterator::operator++
_self & operator++()
Definition geo.h:218
rheolef::geo_iterator::_last_by_var
IteratorByVariant _last_by_var[reference_element::max_variant]
Definition geo.h:242
rheolef::geo_size
Definition geo_size.h:29
rheolef::geo_size::map_dimension
size_type map_dimension() const
Definition geo_size.h:41
rheolef::geo_size::ownership_by_dimension
distributor ownership_by_dimension[4]
Definition geo_size.h:63
rheolef::rounder_type
Definition rounder.h:29
rheolef::sequential
Definition communicator.h:62
M
Expr1::memory_type M
Definition vec_expr_v2.h:416