geo - finite element mesh (rheolef-7.2)

Pierre Saramito <Pierre.Saramito@imag.fr>

Copyright (C) 2000-2018 Pierre Saramito <Pierre.Saramito@imag.fr> GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>. This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. rheolef Version 7.2 geo(2rheolef)

This class is a container for distributed finite element meshes. It is mainly a table of geo_element(6). Let omega be a geo: then, its i-th element is K = omega[i]. In addition, the geo class provides accessors to nodes. Let jv = K[j] be the vertex index of the j-th vertex of the geo_element(6) K. Then, the physical coordinates of this vertex are given by omega.node(jv). Finally, the geo class provides a list of domains, e.g. some parts of the boundary. A domain named 'left' obtain via omega['left'] and this accessor returns the domain as a geo object, i.e. a table of geo_element(6). Lower dimension geo_element(6) could be acceded via omega.get_geo_element (subdim, i). E.g. when subdim=1 we obtain the i-th edge of the mesh.

In a distributed environment, the accessors are similar to those of the disarray(4) class. Let dis_i be the index of an element in the global mesh. Then omega.dis_get_geo_element (dim, dis_i) returns the corresponding geo_element(6). Elements at the neighbour of partition boundaries are available for such a global access. For others elements, that belong to others partitions, communications should be organized as for the disarray(4) class.

The following code lists all elements and nodes of the mesh. 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;

This documentation has been generated from file main/lib/geo.h The geo class is an alias to the geo_basicclass typedef geo_basic<Float,rheo_default_memory_model> geo; The geo_basic class provides an interface, via the smart_pointer(7) class family, to a mesh container: 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; }; 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);

geo - finite element mesh (rheolef-7.2)