This class is a container for distributed finite element meshes. It is mainly a table of geo_element
. Let omega
be a geo
: then, its i
-th element is K = omega[i]
.
The following code lists all elements and nodes of the mesh.
template <class T>
class geo_basic<
T,sequential> :
public smart_pointer_clone<geo_abstract_rep<T,sequential> > {
public:
typedef geo_abstract_rep<T,sequential> rep;
typedef geo_rep<T,sequential> rep_geo_rep;
typedef smart_pointer_clone<rep> base;
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;
geo_basic ();
geo_basic (const domain_indirect_basic<sequential>& dom, const geo_basic<T,sequential>& omega);
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>,
: base (new_macro(rep_geo_rep(
lambda,node_list,elt_list))) {}
std::string name() const { return base::data().name(); }
std::string familyname() const { return base::data().familyname(); }
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(); }
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); }
{ 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); }
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;
void set_name (std::string name);
void set_coordinate_system (coordinate_type sys_coord);
void set_nodes (const disarray<node_type,sequential>& x);
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 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()); }
bool operator== (
const geo_basic<T,sequential>& omega2)
const {
return base::data().operator== (omega2.data()); }
void save (std::string filename = "") const;
field::size_type size_type
see the communicator page for the full documentation
static const variant_type max_variant
coordinate_type coordinate_system(std::string sys_coord)
std::string coordinate_system_name(coordinate_type i)
void dis_inod(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_inod_tab)
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
void load(idiststream &in, Float &p, field &uh)