test

test-function in variational formulation

Description

This class, and its associated trial one, is used for test and trial functions involved in variational formulations. Variational formulations are specified by expressions of the C++ language.

A test function is the formal argument involved in the expression for the integrate function:

    geo omega ("circle");
    space Xh (omega, "P1");
    test v (Xh);
    field lh = integrate (omega, 2*v);

For a bilinear form, the test function represents its second formal argument, while its first one is referred to as the trial one:

    trial u (Xh);
    test  v (Xh);
    form a = integrate (omega, dot(grad(u),grad(v)));

Implementation

This documentation has been generated from file main/lib/test.h

The test and trial classes are simply aliases to the test_basic class:

typedef test_basic<Float,rheo_default_memory_model,details::vf_tag_01> test;
typedef test_basic<Float,rheo_default_memory_model,details::vf_tag_10> trial;

The test_basic class provides an interface, via the smart_pointer class family, to a data container:

template <class T, class M, class VfTag>
class test_basic : public smart_pointer<test_rep<T,M> > {
public :
// typedefs:
 
    typedef test_rep<T,M>                    rep;
    typedef smart_pointer<rep>               base;
    typedef typename rep::size_type          size_type;
    typedef typename rep::memory_type        memory_type;
    typedef typename rep::value_type         value_type;
    typedef typename rep::scalar_type        scalar_type;
    typedef typename rep::float_type         float_type;
    typedef typename rep::geo_type           geo_type;
    typedef typename rep::space_type         space_type;
    typedef typename rep::diff_type          diff_type;
    typedef VfTag                            vf_tag_type;
    typedef typename details::dual_vf_tag<VfTag>::type
                                             vf_dual_tag_type;
    typedef test_basic<T,M,VfTag>            self_type;
    typedef test_basic<T,M,vf_dual_tag_type> dual_self_type;
 
// allocator/deallocator:
  
    explicit test_basic (const space_type& V) : base(new_macro(rep(V))) {}
 
// accessors:
 
    const space_type&  get_vf_space()  const { return base::data().get_vf_space(); }
    static const space_constant::valued_type valued_hint = rep::valued_hint;
    space_constant::valued_type valued_tag() const { return base::data().valued_tag(); }
    size_type n_derivative() const { return base::data().n_derivative(); }
 
    size_type size() const { return get_vf_space().size(); }
    details::test_component<T,M,VfTag> operator[] (size_type i_comp) const;

};