NAME

       domain_indirect - a named part of a finite element mesh

DESCRIPTION

       The  domain_indirect  class defines a container for a part of a finite element mesh.  This
       describes the connectivity of  edges  or  faces.   This  class  is  usefull  for  boundary
       condition setting.

IMPLEMENTATION NOTE

       The  domain class is splitted into two parts.  The first one is the domain_indirect class,
       that contains the main renumbering features: it acts as a  indirect  on  a  geo  class(see
       geo(2)).  The second one is the domain class, that simply contains two smart_pointers: one
       on a domain_indirect and the second on the geo where renumbering  is  acting.   Thus,  the
       domain class develops a complete geo-like interface, via the geo_abstract_rep pure virtual
       class derivation, and can be used by the space class (see space(2)).   The  split  between
       domain_indirect  and  domain  is  necessary,  because  the  geo  class  contains a list of
       domain_indirect.  It cannot contains a list of domain classes,  that  refers  to  the  geo
       class  itself: a loop in reference counting leads to a blocking situation in the automatic
       deallocation.

IMPLEMENTATION

       template <>
       class domain_indirect_basic<sequential> : public smart_pointer<domain_indirect_rep<sequential> > {
       public:

       // typedefs:

           typedef domain_indirect_rep<sequential> rep;
           typedef smart_pointer<rep>        base;
           typedef rep::size_type            size_type;
           typedef rep::iterator_ioige       iterator_ioige;
           typedef rep::const_iterator_ioige const_iterator_ioige;

       // allocators:

           domain_indirect_basic ();

           template <class T>
           domain_indirect_basic (
               const geo_basic<T,sequential>&  omega,
               const std::string&              name,
               size_type                       map_dim,
               const communicator&             comm,
               const std::vector<size_type>&   ie_list);

           template <class U>
           domain_indirect_basic (
               array<geo_element_auto<heap_allocator<size_type> >,sequential, heap_allocator<size_type> >&
                                               d_tmp,
               const geo_basic<U, sequential>& omega,
               std::vector<index_set>*         ball);

           void resize (size_type n);

       // accessors:

           size_type size()     const;
           size_type dis_size() const;
           const distributor& ownership() const;

           const_iterator_ioige ioige_begin() const;
           const_iterator_ioige ioige_end()   const;
                 iterator_ioige ioige_begin();
                 iterator_ioige ioige_end();

           const geo_element_indirect& oige (size_type ioige) const;

           void set_name (std::string name);
           void set_map_dimension (size_type map_dim);
           std::string name ()    const;
           size_type map_dimension () const;

       // i/o:

           odiststream& put (odiststream&) const;
           template <class T>
           idiststream& get (idiststream& ips, const geo_rep<T,sequential>& omega, std::vector<index_set> *ball);
       };

IMPLEMENTATION

       template <>
       class domain_indirect_basic<distributed> : public smart_pointer<domain_indirect_rep<distributed> > {
       public:

       // typedefs:

           typedef domain_indirect_rep<distributed>  rep;
           typedef smart_pointer<rep>            base;
           typedef rep::size_type                size_type;

       // allocators:

           domain_indirect_basic ();
           template<class T>
           domain_indirect_basic (
               const geo_basic<T,distributed>& omega,
               const std::string&            name,
               size_type                     map_dim,
               const communicator&           comm,
               const std::vector<size_type>& ie_list);

       // accessors/modifiers:

           size_type size()     const;
           size_type dis_size() const;
           const distributor& ownership() const;

           const geo_element_indirect& oige (size_type ioige) const;

           void set_name (std::string name);
           void set_map_dimension (size_type map_dim);
           std::string name () const;
           size_type map_dimension () const;

       // distributed specific acessors:

           const distributor& ini_ownership() const;
           size_type ioige2ini_dis_ioige (size_type ioige) const;
           size_type ini_ioige2dis_ioige (size_type ini_ioige) const;

       // i/o:

           template <class T>
           idiststream& get (idiststream& ips, const geo_rep<T,distributed>& omega);
           template <class T>
           odiststream& put (odiststream& ops, const geo_rep<T,distributed>& omega) const;
       };

SEE ALSO

       geo(2), space(2)