.\"
.de Id
..
.de Sp
.if n .sp
.if t .sp 0.4
..
.TH space 2rheolef "rheolef-6.7" "rheolef-6.7" "rheolef-6.7"
.\" label: /*Class:space
.SH NAME
\fBspace\fP -- piecewise polynomial finite element space
.\" skip: @clindex space
.SH DESCRIPTION

The \fBspace\fP class contains some numbering
for unknowns and blocked degrees of freedoms
related to a given mesh and polynomial approximation.
.SH SYNOPSIS

.\" begin_example
.Sp
.nf
    space Q (omega, "P1");
    space V (omega, "P2", "vector");
    space T (omega, "P1d", "tensor");
.Sp
.fi
.\" end_example
.SH PRODUCT

.\" begin_example
.Sp
.nf
    space X = T*V*Q;
    space Q2 = pow(Q,2);
.Sp
.fi
.\" end_example
.\" skip start:SEE ALSO:
.\" skip start:AUTHORS:
.\" skip start:DATE:
.\" END
.SH IMPLEMENTATION
.\" begin_example
.Sp
.nf
template <class T>
class space_basic<T,sequential> : public smart_pointer<space_rep<T,sequential> > {
public:

// typedefs:

    typedef space_rep<T,sequential>   rep;
    typedef smart_pointer<rep>        base;
    typedef typename rep::size_type   size_type;
    typedef typename rep::valued_type valued_type;

// allocators:

    space_basic (const geo_basic<T,sequential>& omega = (geo_basic<T,sequential>()),
                  std::string approx = "", std::string valued = "scalar");
    space_basic (const space_mult_list<T,sequential>& expr);
    space_basic (const space_constitution<T,sequential>& constit);

// accessors:

    void block  (std::string dom_name);
    void unblock(std::string dom_name);
    void block  (const domain_indirect_basic<sequential>& dom);
    void unblock(const domain_indirect_basic<sequential>& dom);

    const distributor&  ownership() const;
    const communicator& comm() const;
    size_type           ndof() const;
    size_type           dis_ndof() const;

    const geo_basic<T,sequential>& get_geo() const;
    const numbering<T,sequential>& get_numbering() const;
    size_type size() const;
    valued_type           valued_tag()   const;
    const std::string&    valued()       const;
    space_component<T,sequential>       operator[] (size_type i_comp);
    space_component_const<T,sequential> operator[] (size_type i_comp) const;
    const space_constitution<T,sequential>& get_constitution() const;
    size_type degree() const;
    std::string get_approx() const;
    std::string stamp() const;

    void dis_idof (const geo_element& K, std::vector<size_type>& dis_idof) const;

    const distributor& iu_ownership() const;
    const distributor& ib_ownership() const;

    bool      is_blocked (size_type     idof) const;
    size_type        iub (size_type     idof) const;
    bool  dis_is_blocked (size_type dis_idof) const;
    size_type    dis_iub (size_type dis_idof) const;

    const distributor& ios_ownership() const;
    size_type idof2ios_dis_idof (size_type idof) const;
    size_type ios_idof2dis_idof (size_type ios_idof) const;

    const point_basic<T>& xdof (size_type idof) const;
    const disarray<point_basic<T>,sequential>& get_xdofs() const;

    template <class Function>
    T momentum (const Function& f, size_type idof) const;

    template <class Function>
    point_basic<T> vector_momentum (const Function& f, size_type idof) const;

    template <class Function>
    tensor_basic<T> tensor_momentum (const Function& f, size_type idof) const;

    disarray<size_type, sequential> build_indirect_array (
        const space_basic<T,sequential>& Wh, const std::string& dom_name) const;

    disarray<size_type, sequential> build_indirect_array (
        const space_basic<T,sequential>& Wh, const geo_basic<T,sequential>& bgd_gamma) const;

    const std::set<size_type>& ext_iu_set() const { return base::data().ext_iu_set(); }
    const std::set<size_type>& ext_ib_set() const { return base::data().ext_ib_set(); }

// comparator:

    bool operator== (const space_basic<T,sequential>& V2) const { return base::data().operator==(V2.data()); }
    bool operator!= (const space_basic<T,sequential>& V2) const { return ! operator== (V2); }
    friend bool are_compatible (const space_basic<T,sequential>& V1, const space_basic<T,sequential>& V2) {
        return are_compatible (V1.data(), V2.data()); }
};
.Sp
.fi
.\" end_example
.SH IMPLEMENTATION
.\" begin_example
.Sp
.nf
template <class T>
class space_basic<T,distributed> : public smart_pointer<space_rep<T,distributed> > {
public:

// typedefs:

    typedef space_rep<T,distributed>  rep;
    typedef smart_pointer<rep>        base;
    typedef typename rep::size_type   size_type;
    typedef typename rep::valued_type valued_type;

// allocators:

    space_basic (const geo_basic<T,distributed>& omega = (geo_basic<T,distributed>()),
                  std::string approx = "", std::string valued = "scalar");
    space_basic (const space_mult_list<T,distributed>&);
    space_basic (const space_constitution<T,distributed>& constit);

// accessors:

    void block  (std::string dom_name);
    void unblock(std::string dom_name);
    void block  (const domain_indirect_basic<distributed>& dom);
    void unblock(const domain_indirect_basic<distributed>& dom);

    const distributor&  ownership() const;
    const communicator& comm() const;
    size_type           ndof() const;
    size_type           dis_ndof() const;

    const geo_basic<T,distributed>& get_geo() const;
    const numbering<T,distributed>& get_numbering() const;
    size_type size() const;
    valued_type           valued_tag()   const;
    const std::string&    valued()       const;
    space_component<T,distributed>       operator[] (size_type i_comp);
    space_component_const<T,distributed> operator[] (size_type i_comp) const;
    const space_constitution<T,distributed>& get_constitution() const;
    size_type degree() const;
    std::string get_approx() const;
    std::string stamp() const;

    void dis_idof (const geo_element& K, std::vector<size_type>& dis_idof) const;

    const distributor& iu_ownership() const;
    const distributor& ib_ownership() const;

    bool      is_blocked (size_type     idof) const;
    size_type        iub (size_type     idof) const;

    bool  dis_is_blocked (size_type dis_idof) const;
    size_type    dis_iub (size_type dis_idof) const;

    const distributor& ios_ownership() const;
    size_type idof2ios_dis_idof (size_type idof) const;
    size_type ios_idof2dis_idof (size_type ios_idof) const;

    const point_basic<T>& xdof (size_type idof) const;
    const disarray<point_basic<T>,distributed>& get_xdofs() const;

    template <class Function>
    T momentum (const Function& f, size_type idof) const;

    template <class Function>
    point_basic<T> vector_momentum (const Function& f, size_type idof) const;

    template <class Function>
    tensor_basic<T> tensor_momentum (const Function& f, size_type idof) const;

    disarray<size_type, distributed> build_indirect_array (
        const space_basic<T,distributed>& Wh, const std::string& dom_name) const;

    disarray<size_type, distributed> build_indirect_array (
        const space_basic<T,distributed>& Wh, const geo_basic<T,distributed>& bgd_gamma) const;

    const std::set<size_type>& ext_iu_set() const { return base::data().ext_iu_set(); }
    const std::set<size_type>& ext_ib_set() const { return base::data().ext_ib_set(); }

// comparator:

    bool operator== (const space_basic<T,distributed>& V2) const { return base::data().operator==(V2.data()); }
    bool operator!= (const space_basic<T,distributed>& V2) const { return ! operator== (V2); }
    friend bool are_compatible (const space_basic<T,distributed>& V1, const space_basic<T,distributed>& V2) {
        return are_compatible (V1.data(), V2.data()); }
};
.Sp
.fi
.\" end_example