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:
 
    using rep  = test_rep<T,M>;
    using base = smart_pointer<rep>;
    using size_type      = typename rep::size_type;
    using memory_type    = typename rep::memory_type;
    using value_type     = typename rep::value_type;
    using scalar_type    = typename rep::scalar_type;
    using float_type     = typename rep::float_type;
    using geo_type       = typename rep::geo_type;
    using space_type     = typename rep::space_type;
    using diff_type      = typename rep::diff_type;
    using is_elementwise = typename rep::is_elementwise;
    using vf_tag_type      = VfTag;
    using vf_dual_tag_type = typename details::dual_vf_tag<VfTag>::type;
    using self_type        = test_basic<T,M,VfTag>;
    using dual_self_type   = test_basic<T,M,vf_dual_tag_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;

};