libMesh
composite_function_test.C
Go to the documentation of this file.
1 // libmesh includes
2 #include <libmesh/composite_function.h>
3 #include <libmesh/const_function.h>
4 #include <libmesh/dense_vector.h>
5 #include <libmesh/parsed_function.h>
6 #include <libmesh/zero_function.h>
7 #include <libmesh/analytic_function.h>
8 
9 #include "libmesh_cppunit.h"
10 
11 
12 using namespace libMesh;
13 
14 class CompositeFunctionTest : public CppUnit::TestCase
15 {
16 public:
17  void setUp() {}
18 
19  void tearDown() {}
20 
21  CPPUNIT_TEST_SUITE(CompositeFunctionTest);
22 
23  CPPUNIT_TEST(testRemap);
24 #if LIBMESH_DIM > 2
25  CPPUNIT_TEST(testTimeDependence);
26 #endif
27 
28  CPPUNIT_TEST_SUITE_END();
29 
30 
31 private:
32  void testRemap()
33  {
34  std::vector<std::vector<unsigned int>> index_sets(4);
35  index_sets[0].resize(2);
36  index_sets[0][0] = 3;
37  index_sets[0][1] = 4;
38  index_sets[1].resize(3);
39  index_sets[1][0] = 0;
40  index_sets[1][1] = 1;
41  index_sets[1][2] = 2;
42  index_sets[2].resize(3);
43  index_sets[2][0] = 0;
44  index_sets[2][1] = 2;
45  index_sets[2][2] = 4;
46  index_sets[3].resize(5);
47  index_sets[3][0] = 5;
48  index_sets[3][1] = 1;
49  index_sets[3][2] = 3;
50  index_sets[3][3] = 6;
51  index_sets[3][4] = 7;
52 
53  CompositeFunction<Real> composite_outer;
54 
55  {
56  CompositeFunction<Real> composite_inner;
57 
58  // Test that ConstFunction copy construction works.
59  ConstFunction<Real> cf_one(1);
60  ConstFunction<Real> cf_one_copy(cf_one);
61  composite_inner.attach_subfunction (cf_one_copy, index_sets[0]);
62 
63  // Test that ConstFunction move construction works.
64  ConstFunction<Real> cf_two(2);
65  ConstFunction<Real> cf_two_move(std::move(cf_two));
66  composite_inner.attach_subfunction (cf_two_move, index_sets[1]);
67 
68  composite_outer.attach_subfunction
69  (composite_inner, index_sets[3]);
70 
71  DenseVector<Real> test_one(5);
72 
73  composite_inner(Point(0), 0, test_one);
74 
75  LIBMESH_ASSERT_FP_EQUAL(test_one(0), 2, 1.e-12);
76  LIBMESH_ASSERT_FP_EQUAL(test_one(1), 2, 1.e-12);
77  LIBMESH_ASSERT_FP_EQUAL(test_one(2), 2, 1.e-12);
78  LIBMESH_ASSERT_FP_EQUAL(test_one(3), 1, 1.e-12);
79  LIBMESH_ASSERT_FP_EQUAL(test_one(4), 1, 1.e-12);
80  }
81  // Test that ConstFunction copy- and move-assignment works.
82  ConstFunction<Real> cf_three(3);
83  ConstFunction<Real> cf_three_copy_assign(0);
84  ConstFunction<Real> cf_three_move_assign(0);
85  cf_three_copy_assign = cf_three;
86  cf_three_move_assign = std::move(cf_three_copy_assign);
87  composite_outer.attach_subfunction(cf_three_move_assign, index_sets[2]);
88 
89  // Test that move ctor works. Note that composite_outer should not
90  // be used for anything once it has been moved from!
91  CompositeFunction<Real> composite_outer_copy1(std::move(composite_outer));
92 
93  // Test that move assignment also works. The first copy should not be
94  // used again after being move assigned.
95  CompositeFunction<Real> composite_outer_copy2;
96  composite_outer_copy2 = std::move(composite_outer_copy1);
97 
98  DenseVector<Real> test_two(8);
99  composite_outer_copy2(Point(0), 0, test_two);
100 
101  LIBMESH_ASSERT_FP_EQUAL(test_two(0), 3, 1.e-12);
102  LIBMESH_ASSERT_FP_EQUAL(test_two(2), 3, 1.e-12);
103  LIBMESH_ASSERT_FP_EQUAL(test_two(4), 3, 1.e-12);
104  LIBMESH_ASSERT_FP_EQUAL(test_two(5), 2, 1.e-12);
105  LIBMESH_ASSERT_FP_EQUAL(test_two(1), 2, 1.e-12);
106  LIBMESH_ASSERT_FP_EQUAL(test_two(3), 2, 1.e-12);
107  LIBMESH_ASSERT_FP_EQUAL(test_two(6), 1, 1.e-12);
108  LIBMESH_ASSERT_FP_EQUAL(test_two(7), 1, 1.e-12);
109  }
110 
111  void testTimeDependence()
112  {
113 #ifdef LIBMESH_HAVE_FPARSER
114  // We'll test the order of adding these functions to
115  // make sure time dependence gets detected/updated correctly
116  // for each
117  ParsedFunction<Real> no_t("x*2+y^2-tanh(z)+atan(x-y)");
118  ParsedFunction<Real> no_t2("x*2+y^2+z^2");
119 
120  ZeroFunction<Real> zero;
121 
122  ParsedFunction<Real> xyt("x+y+t");
123 
124  // Test constructing AnalyticFunction with lambda.
125  auto af_lambda =
126  [](const Point & p, const Real t) -> Real
127  { return p(0)*p(0) + p(1)*p(1) + t*t; };
128  AnalyticFunction<Real> x2y2t2(af_lambda);
129 
130  std::vector<unsigned int> index_set(1,0);
131 
132  {
133  // composite should not be time dependent since this is the first subfunction
134  // added and it's not time-dependent
135  CompositeFunction<Real> composite;
136  composite.attach_subfunction(no_t, index_set);
137  CPPUNIT_ASSERT(!composite.is_time_dependent());
138 
139  // Now composite should be time-dependent since we've now added a time dependent function
140  index_set[0] = 1;
141  composite.attach_subfunction(xyt, index_set);
142  CPPUNIT_ASSERT(composite.is_time_dependent());
143 
144  // Composite should still be time-dependent
145  index_set[0] = 2;
146 
147  // Test AnalyticFunction copy ctor and copy assignment
148  AnalyticFunction<Real> x2y2t2_copy1(x2y2t2);
149  AnalyticFunction<Real> x2y2t2_copy2([](const Point &, const Real) -> Real { return 0; });
150  x2y2t2_copy2 = x2y2t2_copy1;
151  composite.attach_subfunction(x2y2t2_copy2, index_set);
152  CPPUNIT_ASSERT(composite.is_time_dependent());
153  }
154 
155 
156  {
157  CompositeFunction<Real> composite;
158 
159  // composite should be time-dependent since we've added a time dependent function
160  index_set[0] = 0;
161  composite.attach_subfunction(xyt, index_set);
162  CPPUNIT_ASSERT(composite.is_time_dependent());
163 
164  // composite should still be time-dependent since the previous function was time-dependent
165  index_set[0] = 1;
166  composite.attach_subfunction(no_t, index_set);
167  CPPUNIT_ASSERT(composite.is_time_dependent());
168 
169  // Composite should still be time-dependent
170  index_set[0] = 2;
171 
172  // Test AnalyticFunction move ctor and move assignment. Note: we
173  // first copy and then steal the copy's resources to avoid
174  // messing with any later tests of "x2y2t2".
175  AnalyticFunction<Real> x2y2t2_copy(x2y2t2);
176  AnalyticFunction<Real> x2y2t2_move1(std::move(x2y2t2_copy));
177  AnalyticFunction<Real> x2y2t2_move2([](const Point &, const Real) -> Real { return 0; });
178  x2y2t2_move2 = std::move(x2y2t2_move1);
179  composite.attach_subfunction(x2y2t2_move2, index_set);
180  CPPUNIT_ASSERT(composite.is_time_dependent());
181  }
182 
183  {
184  CompositeFunction<Real> composite;
185 
186  // composite should not be time-dependent since we've added a time independent function
187  index_set[0] = 0;
188  composite.attach_subfunction(no_t, index_set);
189  CPPUNIT_ASSERT(!composite.is_time_dependent());
190 
191  // composite should still be time-independent
192  index_set[0] = 1;
193  composite.attach_subfunction(no_t2, index_set);
194  CPPUNIT_ASSERT(!composite.is_time_dependent());
195 
196  // Composite should still be time-independent
197  index_set[0] = 2;
198  composite.attach_subfunction(zero, index_set);
199  CPPUNIT_ASSERT(!composite.is_time_dependent());
200  }
201 #endif // #ifdef LIBMESH_HAVE_FPARSER
202  }
203 };
204 
205 CPPUNIT_TEST_SUITE_REGISTRATION(CompositeFunctionTest);
libMesh::ParsedFunction
A Function generated (via FParser) by parsing a mathematical expression.
Definition: parsed_function.h:60
libMesh::CompositeFunction
A function that returns a vector whose components are defined by multiple functions.
Definition: composite_function.h:49
libMesh::FunctionBase::is_time_dependent
bool is_time_dependent() const
Definition: function_base.h:219
libMesh
The libMesh namespace provides an interface to certain functionality in the library.
Definition: factoryfunction.C:55
CompositeFunctionTest::testTimeDependence
void testTimeDependence()
Definition: composite_function_test.C:111
libMesh::zero
const Number zero
.
Definition: libmesh.h:243
CompositeFunctionTest::setUp
void setUp()
Definition: composite_function_test.C:17
libMesh::AnalyticFunction
Wraps a function pointer into a FunctionBase object.
Definition: analytic_function.h:48
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:38
CompositeFunctionTest
Definition: composite_function_test.C:14
CompositeFunctionTest::tearDown
void tearDown()
Definition: composite_function_test.C:19
libMesh::ZeroFunction
ConstFunction that simply returns 0.
Definition: zero_function.h:36
CompositeFunctionTest::testRemap
void testRemap()
Definition: composite_function_test.C:32
libMesh::CompositeFunction::attach_subfunction
void attach_subfunction(const FunctionBase< Output > &f, const std::vector< unsigned int > &index_map)
Attach a new subfunction, along with a map from the indices of the attached subfunction to the indice...
Definition: composite_function.h:82
libmesh_cppunit.h
CPPUNIT_TEST_SUITE_REGISTRATION
CPPUNIT_TEST_SUITE_REGISTRATION(CompositeFunctionTest)
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition: libmesh_common.h:121
libMesh::ConstFunction
Function that returns a single value that never changes.
Definition: const_function.h:43
libMesh::DenseVector
Defines a dense vector for use in Finite Element-type computations.
Definition: meshless_interpolation_function.h:39
Generated on Sat Jan 25 2020 12:07:06 for libMesh by   doxygen 1.8.16