branch(2rheolef) [debian man page]

branch(2rheolef)						    rheolef-6.1 						  branch(2rheolef)

NAME

       branch - a parameter-dependent sequence of field

DESCRIPTION

       Stores a field sequence together with its associated parameter value: a branch variable represents a pair (t,uh(t)) for a specific value of
       the parameter t.  Applications concern time-dependent problems and continuation methods.

       This class is convenient for file inputs/outputs and building graphical animations.

EXAMPLES

       Coming soon...

LIMITATIONS

       This class is under development.

       The branch class store pointers on field class without reference counting. Thus, branch automatic variables cannot  be  returned  by  func-
       tions. branch variable are limited to local variables.

IMPLEMENTATION

       template <class T, class M = rheo_default_memory_model>
       class branch_basic : public std::vector<std::pair<std::string,field_basic<T,M> > > {
       public :
       // typedefs:

	 typedef std::vector<std::pair<std::string,field_basic<T,M> > >     base;
	 typedef typename base::size_type				    size_type;

       // allocators:

	 branch_basic ();
	 branch_basic (const std::string& parameter_name, const std::string& u0);
	 branch_basic (const std::string& parameter_name, const std::string& u0, const std::string& u1);
	 ~branch_basic();

       // accessors:

	 const T&  parameter () const;
	 const std::string& parameter_name () const;
	 size_type     n_value () const;
	 size_type     n_field () const;

       // modifiers:

	 void set_parameter (const T& value);
	 void set_range (const std::pair<T,T>& u_range);

       // input/output:

	 // get/set current value
	 __obranch<T,M> operator()  (const T& t, const field_basic<T,M>& u0);
	 __obranch<T,M> operator()  (const T& t, const field_basic<T,M>& u0, const field_basic<T,M>& u1);

	 __iobranch<T,M> operator() (T& t, field_basic<T,M>& u0);
	 __iobranch<T,M> operator() (T& t, field_basic<T,M>& u0, field_basic<T,M>& u1);

	 __branch_header<T,M>	      header ();
	 __const_branch_header<T,M>   header () const;
	 __const_branch_finalize<T,M> finalize () const;

rheolef-6.1							    rheolef-6.1 						  branch(2rheolef)

numbering(7rheolef)						    rheolef-6.1 					       numbering(7rheolef)

NAME

       numbering - global degree of freedom numbering

SYNOPSYS

       The  numbering  class defines methods that furnish global numbering of degrees of freedom. This numbering depends upon the degrees of poly-
       noms on elements and upon the continuity requirement at inter-element boundary. For instance the "P1" continuous finite element	approxima-
       tion  has one degree of freedom per vertice of the mesh, while its discontinuous counterpart has dim(basis) times the number of elements of
       the mesh, where dim(basis) is the size of the local finite element basis.

IMPLEMENTATION

       template <class T, class M = rheo_default_memory_model>
       class numbering : public smart_pointer<numbering_rep<T,M> > {
       public:

       // typedefs:

	 typedef numbering_rep<T,M> rep;
	 typedef smart_pointer<rep> base;
	 typedef size_t 	    size_type;

       // allocators:

	 numbering (std::string name = "");
	 numbering (numbering_rep<T,M>* ptr);
	 ~numbering() {}

       // accessors & modifiers:

	 bool is_initialized() const { return base::operator->() != 0; }
	 std::string name() const;
	 size_type degree () const;
	 void set_degree (size_type degree) const;
	 bool is_continuous()	 const;
	 bool is_discontinuous() const { return !is_continuous(); }
	 const basis_basic<T>& get_basis() const { return base::data().get_basis(); }

	 size_type     ndof   (const geo_size& gs, size_type map_dim) const;
	 size_type dis_ndof   (const geo_size& gs, size_type map_dim) const;
	 void	   dis_idof   (const geo_size& gs, const geo_element& K, std::vector<size_type>& dis_idof) const;
	 void set_ios_permutations (const class geo_basic<T,M>& omega,
		       array<size_type,M>&   idof2ios_dis_idof,
		       array<size_type,M>&   ios_idof2dis_idof) const;

       // comparator:

	 bool operator== (const numbering<T,M>& y) const {
	       if (! is_initialized() && ! y.is_initialized()) return true;
	       if (! is_initialized() || ! y.is_initialized()) return false;
	       return name() == y.name();
	 }
       // i/o:

	 void dump(std::ostream& out = std::cerr) const;
       };

rheolef-6.1							    rheolef-6.1 					       numbering(7rheolef)