libMesh
Public Member Functions | Private Member Functions | List of all members
CompositeFunctionTest Class Reference
Inheritance diagram for CompositeFunctionTest:
[legend]

Public Member Functions

void setUp ()
 
void tearDown ()
 
 LIBMESH_CPPUNIT_TEST_SUITE (CompositeFunctionTest)
 
 CPPUNIT_TEST (testRemap)
 
 CPPUNIT_TEST (testTimeDependence)
 
 CPPUNIT_TEST_SUITE_END ()
 

Private Member Functions

void testRemap ()
 
void testTimeDependence ()
 

Detailed Description

Definition at line 14 of file composite_function_test.C.

Member Function Documentation

◆ CPPUNIT_TEST() [1/2]

CompositeFunctionTest::CPPUNIT_TEST ( testRemap  )

◆ CPPUNIT_TEST() [2/2]

CompositeFunctionTest::CPPUNIT_TEST ( testTimeDependence  )

◆ CPPUNIT_TEST_SUITE_END()

CompositeFunctionTest::CPPUNIT_TEST_SUITE_END ( )

◆ LIBMESH_CPPUNIT_TEST_SUITE()

CompositeFunctionTest::LIBMESH_CPPUNIT_TEST_SUITE ( CompositeFunctionTest  )

◆ setUp()

void CompositeFunctionTest::setUp ( )
inline

Definition at line 17 of file composite_function_test.C.

17 {}

◆ tearDown()

void CompositeFunctionTest::tearDown ( )
inline

Definition at line 19 of file composite_function_test.C.

19 {}

◆ testRemap()

void CompositeFunctionTest::testRemap ( )
inlineprivate

Definition at line 32 of file composite_function_test.C.

References libMesh::CompositeFunction< Output >::attach_subfunction().

33  {
34  LOG_UNIT_TEST;
35 
36  std::vector<std::vector<unsigned int>> index_sets(4);
37  index_sets[0].resize(2);
38  index_sets[0][0] = 3;
39  index_sets[0][1] = 4;
40  index_sets[1].resize(3);
41  index_sets[1][0] = 0;
42  index_sets[1][1] = 1;
43  index_sets[1][2] = 2;
44  index_sets[2].resize(3);
45  index_sets[2][0] = 0;
46  index_sets[2][1] = 2;
47  index_sets[2][2] = 4;
48  index_sets[3].resize(5);
49  index_sets[3][0] = 5;
50  index_sets[3][1] = 1;
51  index_sets[3][2] = 3;
52  index_sets[3][3] = 6;
53  index_sets[3][4] = 7;
54 
55  CompositeFunction<Real> composite_outer;
56 
57  {
58  CompositeFunction<Real> composite_inner;
59 
60  // Test that ConstFunction copy construction works.
61  ConstFunction<Real> cf_one(1);
62  ConstFunction<Real> cf_one_copy(cf_one);
63  composite_inner.attach_subfunction (cf_one_copy, index_sets[0]);
64 
65  // Test that ConstFunction move construction works.
66  ConstFunction<Real> cf_two(2);
67  ConstFunction<Real> cf_two_move(std::move(cf_two));
68  composite_inner.attach_subfunction (cf_two_move, index_sets[1]);
69 
70  composite_outer.attach_subfunction
71  (composite_inner, index_sets[3]);
72 
73  DenseVector<Real> test_one(5);
74 
75  composite_inner(Point(0), 0, test_one);
76 
77  LIBMESH_ASSERT_FP_EQUAL(2, test_one(0), 1.e-12);
78  LIBMESH_ASSERT_FP_EQUAL(2, test_one(1), 1.e-12);
79  LIBMESH_ASSERT_FP_EQUAL(2, test_one(2), 1.e-12);
80  LIBMESH_ASSERT_FP_EQUAL(1, test_one(3), 1.e-12);
81  LIBMESH_ASSERT_FP_EQUAL(1, test_one(4), 1.e-12);
82  }
83  // Test that ConstFunction copy- and move-assignment works.
84  ConstFunction<Real> cf_three(3);
85  ConstFunction<Real> cf_three_copy_assign(0);
86  ConstFunction<Real> cf_three_move_assign(0);
87  cf_three_copy_assign = cf_three;
88  cf_three_move_assign = std::move(cf_three_copy_assign);
89  composite_outer.attach_subfunction(cf_three_move_assign, index_sets[2]);
90 
91  // Test that move ctor works. Note that composite_outer should not
92  // be used for anything once it has been moved from!
93  CompositeFunction<Real> composite_outer_copy1(std::move(composite_outer));
94 
95  // Test that move assignment also works. The first copy should not be
96  // used again after being move assigned.
97  CompositeFunction<Real> composite_outer_copy2;
98  composite_outer_copy2 = std::move(composite_outer_copy1);
99 
100  DenseVector<Real> test_two(8);
101  composite_outer_copy2(Point(0), 0, test_two);
102 
103  LIBMESH_ASSERT_FP_EQUAL(3, test_two(0), 1.e-12);
104  LIBMESH_ASSERT_FP_EQUAL(3, test_two(2), 1.e-12);
105  LIBMESH_ASSERT_FP_EQUAL(3, test_two(4), 1.e-12);
106  LIBMESH_ASSERT_FP_EQUAL(2, test_two(5), 1.e-12);
107  LIBMESH_ASSERT_FP_EQUAL(2, test_two(1), 1.e-12);
108  LIBMESH_ASSERT_FP_EQUAL(2, test_two(3), 1.e-12);
109  LIBMESH_ASSERT_FP_EQUAL(1, test_two(6), 1.e-12);
110  LIBMESH_ASSERT_FP_EQUAL(1, test_two(7), 1.e-12);
111  }
libMesh::CompositeFunction
A function that returns a vector whose components are defined by multiple functions.
Definition: composite_function.h:49
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: dof_map.h:74
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:39
libMesh::CompositeFunction::attach_subfunction
void attach_subfunction(const FunctionBase< Output > &f, 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

◆ testTimeDependence()

void CompositeFunctionTest::testTimeDependence ( )
inlineprivate

Definition at line 113 of file composite_function_test.C.

References libMesh::CompositeFunction< Output >::attach_subfunction(), libMesh::FunctionBase< Output >::is_time_dependent(), libMesh::Real, and libMesh::zero.

114  {
115 #ifdef LIBMESH_HAVE_FPARSER
116  LOG_UNIT_TEST;
117 
118  // We'll test the order of adding these functions to
119  // make sure time dependence gets detected/updated correctly
120  // for each
121  ParsedFunction<Real> no_t("x*2+y^2-tanh(z)+atan(x-y)");
122  ParsedFunction<Real> no_t2("x*2+y^2+z^2");
123 
124  ZeroFunction<Real> zero;
125 
126  ParsedFunction<Real> xyt("x+y+t");
127 
128  // Test constructing AnalyticFunction with lambda.
129  auto af_lambda =
130  [](const Point & p, const Real t) -> Real
131  { return p(0)*p(0) + p(1)*p(1) + t*t; };
132  AnalyticFunction<Real> x2y2t2(af_lambda);
133 
134  std::vector<unsigned int> index_set(1,0);
135 
136  {
137  // composite should not be time dependent since this is the first subfunction
138  // added and it's not time-dependent
139  CompositeFunction<Real> composite;
140  composite.attach_subfunction(no_t, index_set);
141  CPPUNIT_ASSERT(!composite.is_time_dependent());
142 
143  // Now composite should be time-dependent since we've now added a time dependent function
144  index_set[0] = 1;
145  composite.attach_subfunction(xyt, index_set);
146  CPPUNIT_ASSERT(composite.is_time_dependent());
147 
148  // Composite should still be time-dependent
149  index_set[0] = 2;
150 
151  // Test AnalyticFunction copy ctor and copy assignment
152  AnalyticFunction<Real> x2y2t2_copy1(x2y2t2);
153  AnalyticFunction<Real> x2y2t2_copy2([](const Point &, const Real) -> Real { return 0; });
154  x2y2t2_copy2 = x2y2t2_copy1;
155  composite.attach_subfunction(x2y2t2_copy2, index_set);
156  CPPUNIT_ASSERT(composite.is_time_dependent());
157  }
158 
159 
160  {
161  CompositeFunction<Real> composite;
162 
163  // composite should be time-dependent since we've added a time dependent function
164  index_set[0] = 0;
165  composite.attach_subfunction(xyt, index_set);
166  CPPUNIT_ASSERT(composite.is_time_dependent());
167 
168  // composite should still be time-dependent since the previous function was time-dependent
169  index_set[0] = 1;
170  composite.attach_subfunction(no_t, index_set);
171  CPPUNIT_ASSERT(composite.is_time_dependent());
172 
173  // Composite should still be time-dependent
174  index_set[0] = 2;
175 
176  // Test AnalyticFunction move ctor and move assignment. Note: we
177  // first copy and then steal the copy's resources to avoid
178  // messing with any later tests of "x2y2t2".
179  AnalyticFunction<Real> x2y2t2_copy(x2y2t2);
180  AnalyticFunction<Real> x2y2t2_move1(std::move(x2y2t2_copy));
181  AnalyticFunction<Real> x2y2t2_move2([](const Point &, const Real) -> Real { return 0; });
182  x2y2t2_move2 = std::move(x2y2t2_move1);
183  composite.attach_subfunction(x2y2t2_move2, index_set);
184  CPPUNIT_ASSERT(composite.is_time_dependent());
185  }
186 
187  {
188  CompositeFunction<Real> composite;
189 
190  // composite should not be time-dependent since we've added a time independent function
191  index_set[0] = 0;
192  composite.attach_subfunction(no_t, index_set);
193  CPPUNIT_ASSERT(!composite.is_time_dependent());
194 
195  // composite should still be time-independent
196  index_set[0] = 1;
197  composite.attach_subfunction(no_t2, index_set);
198  CPPUNIT_ASSERT(!composite.is_time_dependent());
199 
200  // Composite should still be time-independent
201  index_set[0] = 2;
202  composite.attach_subfunction(zero, index_set);
203  CPPUNIT_ASSERT(!composite.is_time_dependent());
204  }
205 #endif // #ifdef LIBMESH_HAVE_FPARSER
206  }
libMesh::ZeroFunction
ConstFunction that simply returns 0.
Definition: zero_function.h:38
libMesh::ParsedFunction
A Function generated (via FParser) by parsing a mathematical expression.
Definition: parsed_function.h:60
libMesh::zero
const Number zero
.
Definition: libmesh.h:304
libMesh::AnalyticFunction
Wraps a function pointer into a FunctionBase object.
Definition: analytic_function.h:48
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:224
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition: libmesh_common.h:144
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:39
libMesh::CompositeFunction::attach_subfunction
void attach_subfunction(const FunctionBase< Output > &f, 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
The documentation for this class was generated from the following file:
Generated on Thu Oct 30 2025 20:01:57 for libMesh by   doxygen 1.8.14