geo_element.h
Go to the documentation of this file.
#ifndef _RHEO_GEO_ELEMENT_H
#define _RHEO_GEO_ELEMENT_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: 10 oct 2001, initial: 10 jan 1998
namespace rheolef {
/* not sure that this example still compiles...
Example
--------
geo_element_auto<> K;
K.set_name('t') ;
cout << "n_vertices: " << K.size() << endl
<< "n_edges : " << K.n_edges() << endl
<< "dimension : " << K.dimension() << endl << endl;
for(geo_element::size_type i = 0; i < K.size(); i++)
K[i] = i*10 ;
for(geo_element::size_type i = 0; i < K.n_edges(); i++)
K.set_edge(i, i*10+5) ;
cout << "vertices: local -> global" << endl;
for (geo_element::size_type vloc = 0; vloc < K.size(); vloc++)
cout << vloc << "-> " << K[vloc] << endl;
cout << endl
<< "edges: local -> global" << endl;
for (geo_element::size_type eloc = 0; eloc < K.n_edges(); eloc++) {
geo_element::size_type vloc1 = subgeo_local_vertex(1, eloc, 0);
geo_element::size_type vloc2 = subgeo_local_vertex(1, eloc, 1);
cout << eloc << "-> " << K.edge(eloc) << endl
<< "local_vertex_from_edge(" << eloc
<< ") -> (" << vloc1 << ", " << vloc2 << ")" << endl;
}
*/
} // namespace rheolef
#include "rheolef/reference_element.h"
#include "rheolef/geo_element_indirect.h"
#include "rheolef/heap_allocator.h"
#include "rheolef/reference_element_face_transformation.h"
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/base_object.hpp>
namespace rheolef {
// --------------------------------------------------------------------
// geo_element: abstract class
// --------------------------------------------------------------------
template <class A> class geo_element_auto;
// [verbatim_geo_element]
class geo_element {
public:
// typedefs:
enum {
_variant_offset = 0, // i.e. type, as triangle(t) or tetra(T), etc
_order_offset = 1, // i.e. k, when Pk curved element
_dis_ie_offset = 2, // internal numbering, depend upon partitionand nproc
_ios_dis_ie_offset = 3, // i/o numbering, independent of parition and nproc
_master_offset = 4, // (d-1)-side has one or two master d-element that contains it
_last_offset = 6 // here starts node indexes, face indexes, etc
};
// Implementation note: _master_offset reserve 2 size_type but is used only for sides,
// i.e. tri or quad in 3d mesh, edge in 2d mesh, or point in 1d
// => waste a lot of place
// it would be better with a polymorphic class
// and the geo class would define an array of smart_pointers on this class
// so, we could define edge with or without the 2 size_type for master elements
// then, hack_array will become obsolete (good thing)
// and reference_element could be also polymorphic, avoiding large swich (variant)
// in all internal loops. This change of implementation will be considered
// in the future.
typedef reference_element::size_type size_type;
typedef reference_element::variant_type variant_type;
typedef size_type* iterator;
typedef const size_type* const_iterator;
typedef size_type raw_type;
typedef geo_element generic_type;
typedef geo_element_auto<heap_allocator<size_type> > automatic_type;
typedef geo_element_indirect::orientation_type orientation_type; // for sign (+1,-1)
typedef geo_element_indirect::shift_type shift_type; // for 0..3 face shift
struct parameter_type {
variant_type variant;
size_type order;
parameter_type (variant_type v = reference_element::max_variant, size_type o = 0)
: variant(v), order(o) {}
};
// affectation:
geo_element& operator= (const geo_element& K)
{
reset (K.variant(), K.order()); // resize auto, nothing for hack
std::copy (K._data_begin(), K._data_begin() + _data_size(), _data_begin());
reset (K.variant(), K.order()); // reset order=1 for hack, resize nothing for auto
return *this;
}
virtual ~geo_element() {}
virtual void reset (variant_type variant, size_type order) = 0;
// implicit conversion:
operator reference_element () const { return reference_element(variant()); }
// accessors & modifiers:
variant_type variant() const { return variant_type( *(_data_begin() + _variant_offset)); }
size_type order() const { return *(_data_begin() + _order_offset); }
size_type dis_ie() const { return *(_data_begin() + _dis_ie_offset); }
size_type ios_dis_ie() const { return *(_data_begin() + _ios_dis_ie_offset); }
size_type master (bool i) const { return *(_data_begin() + _master_offset + i); }
size_type dimension() const { return reference_element::dimension (variant()); }
size_type size() const { return reference_element::n_vertex (variant()); }
char name() const { return reference_element::name (variant()); }
size_type n_node() const { return reference_element::n_node (variant(), order()); }
void set_dis_ie (size_type dis_ie) { *(_data_begin() + _dis_ie_offset) = dis_ie; }
void set_ios_dis_ie (size_type ios_dis_ie) { *(_data_begin() + _ios_dis_ie_offset) = ios_dis_ie; }
void set_master (bool i, size_type dis_ie) const {
const_iterator p = _data_begin() + _master_offset + i; // mutable member fct
*(const_cast<iterator>(p)) = dis_ie;
}
iterator begin() { return _data_begin() + _node_offset (variant(), order()); }
const_iterator begin() const { return _data_begin() + _node_offset (variant(), order()); }
iterator end() { return begin() + size(); }
const_iterator end() const { return begin() + size(); }
size_type& operator[] (size_type loc_inod) { return *(begin() + loc_inod); }
size_type operator[] (size_type loc_inod) const { return *(begin() + loc_inod); }
size_type& node (size_type loc_inod) { return operator[] (loc_inod); }
size_type node (size_type loc_inod) const { return operator[] (loc_inod); }
iterator begin(size_type node_subgeo_dim) { return begin() + first_inod (node_subgeo_dim); }
const_iterator begin(size_type node_subgeo_dim) const { return begin() + first_inod (node_subgeo_dim); }
iterator end (size_type node_subgeo_dim) { return begin() + last_inod (node_subgeo_dim); }
const_iterator end (size_type node_subgeo_dim) const { return begin() + last_inod (node_subgeo_dim); }
const geo_element_indirect& edge_indirect (size_type i) const {
const_iterator p = _data_begin() + _edge_offset (variant(), order()) + i;
return *(reinterpret_cast<const geo_element_indirect*>(p));
}
const geo_element_indirect& face_indirect (size_type i) const {
const_iterator p = _data_begin() + _face_offset (variant(), order()) + i;
return *(reinterpret_cast<const geo_element_indirect*>(p));
}
geo_element_indirect& edge_indirect (size_type i) {
iterator p = _data_begin() + _edge_offset (variant(), order()) + i;
return *(reinterpret_cast<geo_element_indirect*>(p));
}
geo_element_indirect& face_indirect (size_type i) {
iterator p = _data_begin() + _face_offset (variant(), order()) + i;
return *(reinterpret_cast<geo_element_indirect*>(p));
}
size_type edge (size_type i) const { return (dimension() <= 1) ? dis_ie() : edge_indirect(i).index(); }
size_type face (size_type i) const { return (dimension() <= 2) ? dis_ie() : face_indirect(i).index(); }
size_type n_subgeo (size_type subgeo_dim) const {
return reference_element::n_subgeo (variant(), subgeo_dim); }
size_type subgeo_dis_index (size_type subgeo_dim, size_type i) const {
return (subgeo_dim == 0) ? operator[](i) : (subgeo_dim == 1) ? edge(i) : (subgeo_dim == 2) ? face(i) : dis_ie(); }
size_type subgeo_n_node (size_type subgeo_dim, size_type loc_isid) const {
return reference_element::subgeo_n_node (variant(), order(), subgeo_dim, loc_isid); }
size_type subgeo_local_node (size_type subgeo_dim, size_type loc_isid, size_type loc_jsidnod) const {
return reference_element::subgeo_local_node (variant(), order(), subgeo_dim, loc_isid, loc_jsidnod); }
size_type subgeo_size (size_type subgeo_dim, size_type loc_isid) const {
return reference_element::subgeo_n_node (variant(), 1, subgeo_dim, loc_isid); }
size_type subgeo_local_vertex(size_type subgeo_dim, size_type i_subgeo, size_type i_subgeo_vertex) const {
return reference_element::subgeo_local_node (variant(), 1, subgeo_dim, i_subgeo, i_subgeo_vertex); }
size_type first_inod (size_type subgeo_dim) const {
return reference_element::first_inod (variant(), order(), subgeo_dim); }
size_type last_inod (size_type subgeo_dim) const {
return reference_element::last_inod (variant(), order(), subgeo_dim); }
size_type n_edge () const { return n_subgeo (1); }
size_type n_face () const { return n_subgeo (2); }
// orientation accessors:
// search S in all sides of K
orientation_type get_side_informations (
const geo_element& S,
size_type& loc_isid,
size_type& shift) const;
void get_side_informations (
const geo_element& S,
side_information_type& sid) const;
orientation_type get_side_orientation (const geo_element& S) const;
// compare two sides: S and *this
bool get_orientation_and_shift (const geo_element& S,
orientation_type& orient, shift_type& shift) const;
orientation_type get_edge_orientation (size_type dis_iv0, size_type dis_iv1) const;
void get_orientation_and_shift (
size_type dis_iv0, size_type dis_iv1, size_type dis_iv2,
orientation_type& orient,
shift_type& shift) const;
void get_orientation_and_shift (
size_type dis_iv0, size_type dis_iv1, size_type dis_iv2, size_type dis_iv3,
orientation_type& orient,
shift_type& shift) const;
// i/o;
void put (std::ostream& is) const;
void get (std::istream& os);
// [verbatim_geo_element]
// internals:
// static: fix orientation & shift helpers, for 2d edges & 3d faces:
static size_type fix_edge_indirect (
const geo_element& K,
size_type loc_iedg,
size_type loc_iedg_j,
size_type order);
static size_type fix_edge_indirect (
orientation_type orient,
size_type order,
size_type loc_iedg_j);
static void loc_tri_inod2lattice (
size_type loc_tri_inod,
size_type order,
point_basic<size_type>& ij_lattice);
static void loc_qua_inod2lattice (
size_type loc_qua_inod,
size_type order,
point_basic<size_type>& ij_lattice);
static size_type fix_triangle_indirect (
const geo_element& K,
size_type loc_itri,
size_type loc_itri_j,
size_type order);
static size_type fix_triangle_indirect (
orientation_type orient,
shift_type shift,
size_type order,
size_type loc_itri_j);
static size_type fix_quadrangle_indirect (
const geo_element& K,
size_type loc_iqua,
size_type loc_iqua_j,
size_type order);
static size_type fix_quadrangle_indirect (
orientation_type orient,
shift_type shift,
size_type order,
size_type loc_iqua_j);
// main call: fix on any element type by switch:
static size_type fix_indirect (
const geo_element& K,
size_type subgeo_variant,
size_type loc_ige,
size_type loc_comp_idof_on_subgeo,
size_type order);
//protected:
static size_type _edge_offset (variant_type variant, size_type order) { return _last_offset; }
static size_type _face_offset (variant_type variant, size_type order) { return _edge_offset(variant,order) + reference_element::n_sub_edge(variant); }
static size_type _node_offset (variant_type variant, size_type order) { return _face_offset(variant,order) + reference_element::n_sub_face(variant); }
static size_type _data_size (variant_type variant, size_type order) { return _node_offset(variant,order) + reference_element::n_node(variant,order); }
static size_type _data_size (const parameter_type& p) { return _data_size (p.variant,p.order); }
size_type _data_size() const { return _data_size (variant(),order()); }
virtual iterator _data_begin() = 0;
virtual iterator _data_end() = 0;
virtual const_iterator _data_begin() const = 0;
virtual const_iterator _data_end() const = 0;
template<class Archive>
void serialize (Archive& ar, const unsigned int version) {
}
#ifdef TO_CLEAN
template<class A = std::allocator<std::vector<int>::size_type> > class geo_element_auto;
#endif // TO_CLEAN
// [verbatim_geo_element_cont]
};
// [verbatim_geo_element_cont]
#ifdef TO_CLEAN
// specialization, from disarray.h (because of a g++ bug when T=float128)
template<>
struct _disarray_put_element_type<geo_element> {
std::ostream& operator() (std::ostream& os, const geo_element& K) const { K.put(os); return os; }
};
template<>
struct _disarray_get_element_type<geo_element> {
std::istream& operator() (std::istream& is, geo_element& K) const { K.get(is); return is; }
};
#endif // TO_CLEAN
inline
std::istream&
operator>> (std::istream& is, geo_element& K)
{
K.get (is);
return is;
}
inline
std::ostream&
operator<< (std::ostream& os, const geo_element& K)
{
K.put (os);
return os;
}
// --------------------------------------------------------------------
// geo_element_auto: generic dynamically allocated class
// --------------------------------------------------------------------
template<class A = std::allocator<std::vector<int>::size_type> >
class geo_element_auto : public geo_element {
public:
// typedefs:
typedef A allocator_type;
typedef reference_element::size_type size_type;
typedef reference_element::variant_type variant_type;
typedef geo_element::iterator iterator;
typedef geo_element::const_iterator const_iterator;
typedef geo_element::parameter_type parameter_type;
typedef geo_element generic_type;
typedef geo_element::automatic_type automatic_type;
// allocators:
explicit geo_element_auto (const A& alloc = A())
: _data (_last_offset, std::numeric_limits<size_type>::max(), alloc)
{
_data [_variant_offset] = reference_element::max_variant;
_data [_order_offset] = 0;
}
explicit geo_element_auto (variant_type variant, size_type order = 1, const A& alloc = A())
: _data (_data_size(variant,order), std::numeric_limits<size_type>::max(), alloc)
{
_data [_variant_offset] = variant;
_data [_order_offset] = order;
}
explicit geo_element_auto (parameter_type p, const A& alloc = A())
: _data (_data_size(p), std::numeric_limits<size_type>::max(), alloc)
{
_data [_variant_offset] = p.variant;
_data [_order_offset] = p.order;
}
geo_element_auto (const geo_element& K)
: _data (K._data_size(), size_type(0), A()) // cree un nouvel allocateur
{ std::copy (K._data_begin(), K._data_end(), _data.begin()); }
geo_element_auto (const geo_element_auto<A>& K)
: _data (K._data.size(), size_type(0), K._data.get_allocator()) // re-utilise l'allocateur precedent
{ std::copy (K._data.begin(), K._data.end(), _data.begin()); }
template <class A2>
geo_element_auto (const geo_element_auto<A2>& K)
: _data (K._data.size(), size_type(0), A()) // cree un nouvel allocateur
{ std::copy (K._data.begin(), K._data.end(), _data.begin()); }
const geo_element_auto<A>& operator= (const geo_element& K)
{
_data.resize(K._data_size());
std::copy (K._data_begin(), K._data_end(), _data.begin());
return *this;
}
void reset (variant_type variant, size_type order) {
_data.resize (_data_size(variant,order), std::numeric_limits<size_type>::max());
_data [_variant_offset] = variant;
_data [_order_offset] = order;
}
void reset (const parameter_type& param) { reset (param.variant, param.order); }
// internals:
template<class Archive>
void serialize (Archive& ar, const unsigned int version) {
ar & boost::serialization::base_object<geo_element>(*this);
ar & _data;
}
//protected:
iterator _data_begin() { return _data.begin().operator->(); }
const_iterator _data_begin() const { return _data.begin().operator->(); }
iterator _data_end() { return _data.end().operator->(); }
const_iterator _data_end() const { return _data.end().operator->(); }
template <class A2> friend class geo_element_auto;
// data:
std::vector<size_type,A> _data;
};
// -------------------------------------------------------------------
// base raw class
// --------------------------------------------------------------------
class geo_element_hack : public geo_element {
public:
// constants & typedefs:
enum {
_vtable_size = 1 /* = sizeof(geo_element_X_hack)/sizeof(size_type) */
};
typedef geo_element::size_type size_type;
typedef geo_element::variant_type variant_type;
typedef geo_element::iterator iterator;
typedef geo_element::const_iterator const_iterator;
typedef geo_element::parameter_type parameter_type;
typedef size_type raw_type;
typedef geo_element generic_type;
typedef geo_element::automatic_type automatic_type;
// allocators:
geo_element_hack () : geo_element() {}
template <class A>
geo_element_hack (const geo_element_auto<A>& K) : geo_element()
{
check_macro (K.variant() == variant(), "incompatible conversion");
#ifdef TO_CLEAN
check_macro (K.order() == order(), "incompatible conversion");
#endif // TO_CLEAN
std::copy (K._data.begin(), K._data.begin() + _data_size(), _data_begin());
}
// accesors & modifiers
void reset (variant_type variant1, size_type order1) {
check_macro (variant1 == variant(), "cannot change variant from "<<variant()<<" to "<<variant1<<" in a raw element");
#ifdef TO_CLEAN
check_macro (order1 == 1, "cannot change order "<<order1<< " > 1 in a raw element");
#endif // TO_CLEAN
_set_data (_order_offset, 1);
}
// internals:
protected:
static size_type _size_of (const parameter_type& p) { return _vtable_size + _data_size(p); }
iterator _data_begin() { return reinterpret_cast<iterator> (this) + _vtable_size; }
const_iterator _data_begin() const { return reinterpret_cast<const_iterator>(this) + _vtable_size; }
iterator _data_end() { return _data_begin() + _data_size(); }
const_iterator _data_end() const { return _data_begin() + _data_size(); }
size_type _get_data (size_type i) const { return *(_data_begin() + i); }
size_type& _get_data_ref(size_type i) { return *(_data_begin() + i); }
void _set_data (size_type i, size_type value) { _get_data_ref(i) = value; }
void _reset (variant_type variant, size_type order) {
check_macro (order == 1, "cannot set order "<<order<< " > 1 in a raw element");
_set_data (_variant_offset, variant);
_set_data (_order_offset, order);
for (size_type i = _order_offset+1, n = _data_size (variant,order); i < n; i++) {
_set_data (i, std::numeric_limits<size_type>::max());
}
}
void _set_parameter (const parameter_type& p) { _reset (p.variant, p.order); }
template <class T, class A> friend class hack_array_seq_rep;
};
// -------------------------------------------------------------------
// permuted io helper
// --------------------------------------------------------------------
struct geo_element_permuted_put {
typedef geo_element::size_type size_type;
geo_element_permuted_put (const std::vector<size_type>& perm1) : perm(perm1) {}
std::ostream& operator() (std::ostream& os, const geo_element& K) {
static const bool do_verbose = true;
if (do_verbose || K.size() > 2 || K.order() > 1) { os << K.name() << "\t"; }
if (K.order() > 1) { os << "p" << K.order() << " "; }
for (geo_element::size_type iloc = 0; iloc < K.n_node(); iloc++) {
os << perm [K[iloc]];
if (iloc < K.n_node() - 1) os << " ";
}
return os;
}
const std::vector<size_type>& perm;
};
}// namespace rheolef
#endif // _RHEO_GEO_ELEMENT_H
rheolef::geo_element_auto::reset
void reset(const parameter_type &param)
Definition: geo_element.h:431
rheolef::geo_element_permuted_put::operator()
std::ostream & operator()(std::ostream &os, const geo_element &K)
Definition: geo_element.h:529
rheolef::_disarray_put_element_type::operator()
std::ostream & operator()(std::ostream &os, const T &x) const
Definition: disarray.h:198
rheolef::geo_element_permuted_put
Definition: geo_element.h:526
rheolef::reference_element::n_sub_face
static size_type n_sub_face(variant_type variant)
Definition: reference_element.cc:99
rheolef::geo_element::serialize
void serialize(Archive &ar, const unsigned int version)
Definition: geo_element.h:338
rheolef::geo_element::fix_indirect
static size_type fix_indirect(const geo_element &K, size_type subgeo_variant, size_type loc_ige, size_type loc_comp_idof_on_subgeo, size_type order)
Definition: geo_element.cc:320
rheolef::geo_element::subgeo_size
size_type subgeo_size(size_type subgeo_dim, size_type loc_isid) const
Definition: geo_element.h:221
rheolef::geo_element::parameter_type::parameter_type
parameter_type(variant_type v=reference_element::max_variant, size_type o=0)
Definition: geo_element.h:139
rheolef::geo_element::get_orientation_and_shift
bool get_orientation_and_shift(const geo_element &S, orientation_type &orient, shift_type &shift) const
return orientation and shift between *this element and S
Definition: geo_element.cc:114
rheolef::reference_element::n_node
static size_type n_node(variant_type variant, size_type order)
Definition: reference_element.cc:201
rheolef::geo_element::fix_edge_indirect
static size_type fix_edge_indirect(const geo_element &K, size_type loc_iedg, size_type loc_iedg_j, size_type order)
Definition: geo_element.cc:253
rheolef::geo_element_hack::_set_parameter
void _set_parameter(const parameter_type &p)
Definition: geo_element.h:519
rheolef::geo_element_hack::_vtable_size
@ _vtable_size
Definition: geo_element.h:463
rheolef::geo_element_auto::geo_element_auto
geo_element_auto(const A &alloc=A())
Definition: geo_element.h:392
rheolef::geo_element_indirect::shift_type
short int shift_type
Definition: geo_element_indirect.h:39
rheolef::geo_element::last_inod
size_type last_inod(size_type subgeo_dim) const
Definition: geo_element.h:227
rheolef::geo_element_auto::parameter_type
geo_element::parameter_type parameter_type
Definition: geo_element.h:386
rheolef::geo_element_hack::_data_end
iterator _data_end()
Definition: geo_element.h:504
rheolef::point_basic
Definition: point.h:87
rheolef::geo_element_auto::_data
std::vector< size_type, A > _data
Definition: geo_element.h:452
rheolef::geo_element_auto::iterator
geo_element::iterator iterator
Definition: geo_element.h:384
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
rheolef::geo_element::master
size_type master(bool i) const
Definition: geo_element.h:165
rheolef::geo_element_hack::raw_type
size_type raw_type
Definition: geo_element.h:471
rheolef::geo_element::n_edge
size_type n_edge() const
Definition: geo_element.h:230
rheolef::geo_element::face_indirect
const geo_element_indirect & face_indirect(size_type i) const
Definition: geo_element.h:197
rheolef::geo_element::end
const_iterator end(size_type node_subgeo_dim) const
Definition: geo_element.h:191
rheolef::geo_element_auto::reset
void reset(variant_type variant, size_type order)
Definition: geo_element.h:426
rheolef::geo_element_permuted_put::size_type
geo_element::size_type size_type
Definition: geo_element.h:527
rheolef::geo_element::get
void get(std::istream &os)
Definition: geo_element.cc:42
rheolef::geo_element_auto::size_type
reference_element::size_type size_type
Definition: geo_element.h:382
rheolef::geo_element::const_iterator
const typedef size_type * const_iterator
Definition: geo_element.h:128
rheolef::geo_element::begin
const_iterator begin(size_type node_subgeo_dim) const
Definition: geo_element.h:189
rheolef::geo_element::variant_type
reference_element::variant_type variant_type
Definition: geo_element.h:126
rheolef::geo_element::fix_quadrangle_indirect
static size_type fix_quadrangle_indirect(const geo_element &K, size_type loc_iqua, size_type loc_iqua_j, size_type order)
Definition: geo_element.cc:311
rheolef::geo_element::order
size_type order() const
Definition: geo_element.h:162
rheolef::geo_element_indirect::index
size_type index() const
Definition: geo_element_indirect.h:51
rheolef::reference_element::n_subgeo
size_type n_subgeo(size_type subgeo_dim) const
Definition: reference_element.h:110
rheolef::geo_element_auto::geo_element_auto
geo_element_auto(variant_type variant, size_type order=1, const A &alloc=A())
Definition: geo_element.h:398
rheolef::geo_element_hack::_reset
void _reset(variant_type variant, size_type order)
Definition: geo_element.h:511
rheolef::geo_element_hack::automatic_type
geo_element::automatic_type automatic_type
Definition: geo_element.h:473
rheolef::geo_element_hack::_data_begin
const_iterator _data_begin() const
Definition: geo_element.h:503
rheolef::geo_element::subgeo_dis_index
size_type subgeo_dis_index(size_type subgeo_dim, size_type i) const
Definition: geo_element.h:214
rheolef::value
rheolef::std value
rheolef::geo_element_hack::variant_type
geo_element::variant_type variant_type
Definition: geo_element.h:467
rheolef::geo_element::_data_size
size_type _data_size() const
Definition: geo_element.h:330
rheolef::geo_element::get_side_informations
orientation_type get_side_informations(const geo_element &S, size_type &loc_isid, size_type &shift) const
Definition: geo_element.cc:185
rheolef::geo_element_hack::size_type
geo_element::size_type size_type
Definition: geo_element.h:466
rheolef::geo_element_auto::variant_type
reference_element::variant_type variant_type
Definition: geo_element.h:383
rheolef::geo_element::_data_begin
virtual iterator _data_begin()=0
mkgeo_ball.order
order
Definition: mkgeo_ball.sh:343
rheolef::geo_element::n_subgeo
size_type n_subgeo(size_type subgeo_dim) const
Definition: geo_element.h:212
rheolef::geo_element::_last_offset
@ _last_offset
Definition: geo_element.h:113
rheolef::geo_element::size
size_type size() const
Definition: geo_element.h:168
rheolef-config.version
version
Definition: rheolef-config.in:126
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::geo_element_hack::iterator
geo_element::iterator iterator
Definition: geo_element.h:468
rheolef::geo_element::subgeo_n_node
size_type subgeo_n_node(size_type subgeo_dim, size_type loc_isid) const
Definition: geo_element.h:217
rheolef::geo_element::shift_type
geo_element_indirect::shift_type shift_type
Definition: geo_element.h:135
rheolef::geo_element::end
iterator end(size_type node_subgeo_dim)
Definition: geo_element.h:190
rheolef::geo_element_auto
Definition: geo_element.h:99
rheolef::geo_element::~geo_element
virtual ~geo_element()
Definition: geo_element.h:152
rheolef::geo_element_hack::_size_of
static size_type _size_of(const parameter_type &p)
Definition: geo_element.h:500
rheolef::geo_element::variant
variant_type variant() const
Definition: geo_element.h:161
rheolef::geo_element::get_side_orientation
orientation_type get_side_orientation(const geo_element &S) const
Definition: geo_element.cc:240
rheolef::geo_element_hack::geo_element_hack
geo_element_hack(const geo_element_auto< A > &K)
Definition: geo_element.h:479
rheolef::reference_element::first_inod
static size_type first_inod(variant_type variant, size_type order, size_type subgeo_dim)
Definition: reference_element.h:156
rheolef::geo_element::dis_ie
size_type dis_ie() const
Definition: geo_element.h:163
rheolef::geo_element_indirect
Definition: geo_element_indirect.h:32
rheolef::geo_element::generic_type
geo_element generic_type
Definition: geo_element.h:131
rheolef::side_information_type
Definition: reference_element_face_transformation.h:37
rheolef::geo_element_auto::geo_element_auto
geo_element_auto(const geo_element_auto< A > &K)
Definition: geo_element.h:413
p
Definition: sphere.icc:25
rheolef::geo_element::set_dis_ie
void set_dis_ie(size_type dis_ie)
Definition: geo_element.h:172
rheolef::reference_element
see the reference_element page for the full documentation
Definition: reference_element.h:66
mkgeo_ball.variant
variant
Definition: mkgeo_ball.sh:149
rheolef::geo_element::_data_end
virtual iterator _data_end()=0
rheolef::geo_element::automatic_type
geo_element_auto< heap_allocator< size_type > > automatic_type
Definition: geo_element.h:132
rheolef::geo_element::node
size_type & node(size_type loc_inod)
Definition: geo_element.h:185
rheolef::geo_element::dimension
size_type dimension() const
Definition: geo_element.h:167
rheolef::geo_element_hack::const_iterator
geo_element::const_iterator const_iterator
Definition: geo_element.h:469
rheolef::geo_element::reset
virtual void reset(variant_type variant, size_type order)=0
rheolef::geo_element::loc_tri_inod2lattice
static void loc_tri_inod2lattice(size_type loc_tri_inod, size_type order, point_basic< size_type > &ij_lattice)
Definition: geo_element.cc:265
rheolef::_disarray_get_element_type::operator()
std::istream & operator()(std::istream &is, T &x) const
Definition: disarray.h:207
rheolef::geo_element::_node_offset
static size_type _node_offset(variant_type variant, size_type order)
Definition: geo_element.h:326
rheolef::geo_element_indirect::orientation_type
short int orientation_type
Definition: geo_element_indirect.h:38
rheolef::geo_element_auto::generic_type
geo_element generic_type
Definition: geo_element.h:387
rheolef::geo_element::operator[]
size_type & operator[](size_type loc_inod)
Definition: geo_element.h:183
rheolef::geo_element::size_type
reference_element::size_type size_type
Definition: geo_element.h:125
rheolef::geo_element::raw_type
size_type raw_type
Definition: geo_element.h:129
rheolef::geo_element::node
size_type node(size_type loc_inod) const
Definition: geo_element.h:186
rheolef::reference_element::variant_type
size_type variant_type
Definition: reference_element.h:72
rheolef::geo_element::end
iterator end()
Definition: geo_element.h:181
rheolef::geo_element::face_indirect
geo_element_indirect & face_indirect(size_type i)
Definition: geo_element.h:205
rheolef::geo_element::subgeo_local_vertex
size_type subgeo_local_vertex(size_type subgeo_dim, size_type i_subgeo, size_type i_subgeo_vertex) const
Definition: geo_element.h:223
rheolef::reference_element::name
char name() const
Definition: reference_element.h:100
rheolef::geo_element_auto::_data_end
const_iterator _data_end() const
Definition: geo_element.h:446
rheolef::geo_element::n_node
size_type n_node() const
Definition: geo_element.h:170
rheolef::geo_element_hack::_get_data_ref
size_type & _get_data_ref(size_type i)
Definition: geo_element.h:508
rheolef::geo_element_auto::const_iterator
geo_element::const_iterator const_iterator
Definition: geo_element.h:385
rheolef::geo_element::_edge_offset
static size_type _edge_offset(variant_type variant, size_type order)
Definition: geo_element.h:324
rheolef::geo_element_auto::automatic_type
geo_element::automatic_type automatic_type
Definition: geo_element.h:388
rheolef::geo_element_hack::_set_data
void _set_data(size_type i, size_type value)
Definition: geo_element.h:509
rheolef::geo_element::_face_offset
static size_type _face_offset(variant_type variant, size_type order)
Definition: geo_element.h:325
rheolef::geo_element_auto::allocator_type
A allocator_type
Definition: geo_element.h:381
rheolef::geo_element_hack::_data_end
const_iterator _data_end() const
Definition: geo_element.h:505
rheolef::geo_element_auto::_data_begin
const_iterator _data_begin() const
Definition: geo_element.h:444
rheolef::geo_element::edge_indirect
const geo_element_indirect & edge_indirect(size_type i) const
Definition: geo_element.h:193
rheolef::geo_element_hack::_get_data
size_type _get_data(size_type i) const
Definition: geo_element.h:507
rheolef::geo_element::orientation_type
geo_element_indirect::orientation_type orientation_type
Definition: geo_element.h:134
rheolef::operator>>
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition: catchmark.h:88
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::geo_element::set_master
void set_master(bool i, size_type dis_ie) const
Definition: geo_element.h:174
rheolef::geo_element_auto::operator=
const geo_element_auto< A > & operator=(const geo_element &K)
Definition: geo_element.h:420
rheolef::reference_element::subgeo_local_node
static size_type subgeo_local_node(variant_type variant, size_type order, size_type subgeo_dim, size_type loc_isid, size_type loc_jsidnod)
Definition: reference_element.cc:155
rheolef::geo_element_auto::geo_element_auto
geo_element_auto(const geo_element &K)
Definition: geo_element.h:410
rheolef::geo_element::_data_size
static size_type _data_size(const parameter_type &p)
Definition: geo_element.h:328
rheolef::geo_element::begin
const_iterator begin() const
Definition: geo_element.h:180
rheolef::geo_element_auto::serialize
void serialize(Archive &ar, const unsigned int version)
Definition: geo_element.h:436
rheolef::geo_element::parameter_type
Definition: geo_element.h:136
rheolef::geo_element::iterator
size_type * iterator
Definition: geo_element.h:127
rheolef::geo_element_auto::_data_end
iterator _data_end()
Definition: geo_element.h:445
rheolef::reference_element::max_variant
static const variant_type max_variant
Definition: reference_element.h:82
rheolef::geo_element_auto::geo_element_auto
geo_element_auto(const geo_element_auto< A2 > &K)
Definition: geo_element.h:417
rheolef::geo_element::begin
iterator begin()
Definition: geo_element.h:179
rheolef::geo_element::first_inod
size_type first_inod(size_type subgeo_dim) const
Definition: geo_element.h:225
rheolef::reference_element::dimension
size_type dimension() const
Definition: reference_element.h:101
rheolef::reference_element::last_inod
static size_type last_inod(variant_type variant, size_type order, size_type subgeo_dim)
Definition: reference_element.h:158
rheolef::geo_element::get_edge_orientation
orientation_type get_edge_orientation(size_type dis_iv0, size_type dis_iv1) const
Definition: geo_element.cc:155
rheolef::geo_element::n_face
size_type n_face() const
Definition: geo_element.h:231
rheolef::geo_element::edge_indirect
geo_element_indirect & edge_indirect(size_type i)
Definition: geo_element.h:201
rheolef::geo_element::_dis_ie_offset
@ _dis_ie_offset
Definition: geo_element.h:110
rheolef::geo_element_hack::reset
void reset(variant_type variant1, size_type order1)
Definition: geo_element.h:490
rheolef::const_iterator
Definition: field_expr_recursive.h:552
rheolef::geo_element_hack::_data_begin
iterator _data_begin()
Definition: geo_element.h:502
rheolef::geo_element_permuted_put::geo_element_permuted_put
geo_element_permuted_put(const std::vector< size_type > &perm1)
Definition: geo_element.h:528
mkgeo_ball.n
n
Definition: mkgeo_ball.sh:150
rheolef::geo_element::_variant_offset
@ _variant_offset
Definition: geo_element.h:108
rheolef::geo_element::parameter_type::variant
variant_type variant
Definition: geo_element.h:137
rheolef::geo_element::_order_offset
@ _order_offset
Definition: geo_element.h:109
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::geo_element::operator=
geo_element & operator=(const geo_element &K)
Definition: geo_element.h:145
rheolef::geo_element_auto::geo_element_auto
geo_element_auto(parameter_type p, const A &alloc=A())
Definition: geo_element.h:404
rheolef::geo_element::name
char name() const
Definition: geo_element.h:169
rheolef::geo_element::_ios_dis_ie_offset
@ _ios_dis_ie_offset
Definition: geo_element.h:111
rheolef::geo_element::subgeo_local_node
size_type subgeo_local_node(size_type subgeo_dim, size_type loc_isid, size_type loc_jsidnod) const
Definition: geo_element.h:219
rheolef::geo_element::end
const_iterator end() const
Definition: geo_element.h:182
rheolef::geo_element::begin
iterator begin(size_type node_subgeo_dim)
Definition: geo_element.h:188
rheolef::geo_element_hack::parameter_type
geo_element::parameter_type parameter_type
Definition: geo_element.h:470
rheolef::geo_element::face
size_type face(size_type i) const
Definition: geo_element.h:210
rheolef::geo_element::_data_size
static size_type _data_size(variant_type variant, size_type order)
Definition: geo_element.h:327
rheolef::geo_element_hack::geo_element_hack
geo_element_hack()
Definition: geo_element.h:477
rheolef::operator<<
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition: catchmark.h:99
rheolef::geo_element::loc_qua_inod2lattice
static void loc_qua_inod2lattice(size_type loc_qua_inod, size_type order, point_basic< size_type > &ij_lattice)
Definition: geo_element.cc:294
rheolef::reference_element::size_type
std::vector< int >::size_type size_type
Definition: reference_element.h:71
rheolef::reference_element::n_sub_edge
static size_type n_sub_edge(variant_type variant)
Definition: reference_element.cc:85
rheolef::geo_element_permuted_put::perm
const std::vector< size_type > & perm
Definition: geo_element.h:539
rheolef::geo_element::edge
size_type edge(size_type i) const
Definition: geo_element.h:209
rheolef::reference_element::subgeo_n_node
static size_type subgeo_n_node(variant_type variant, size_type order, size_type subgeo_dim, size_type loc_isid)
Definition: reference_element.cc:132
rheolef::std
Definition: vec_expr_v2.h:391
rheolef::hack_array_seq_rep
Definition: hack_array.h:78
rheolef::geo_element::parameter_type::order
size_type order
Definition: geo_element.h:138
rheolef::reference_element::n_vertex
size_type n_vertex() const
Definition: reference_element.h:103
rheolef::geo_element_hack
Definition: geo_element.h:457
rheolef::geo_element_auto::_data_begin
iterator _data_begin()
Definition: geo_element.h:443
rheolef::geo_element::_master_offset
@ _master_offset
Definition: geo_element.h:112
rheolef::geo_element::ios_dis_ie
size_type ios_dis_ie() const
Definition: geo_element.h:164
rheolef::geo_element_hack::generic_type
geo_element generic_type
Definition: geo_element.h:472
rheolef::geo_element::put
void put(std::ostream &is) const
Definition: geo_element.cc:93
rheolef::geo_element::set_ios_dis_ie
void set_ios_dis_ie(size_type ios_dis_ie)
Definition: geo_element.h:173
rheolef::geo_element::fix_triangle_indirect
static size_type fix_triangle_indirect(const geo_element &K, size_type loc_itri, size_type loc_itri_j, size_type order)
Definition: geo_element.cc:282