Skip to content

Commit ef403aa

Browse files
thelferthelfer
committed
add the UniformEvalutor class
1 parent 68625d9 commit ef403aa

8 files changed

Lines changed: 334 additions & 8 deletions

File tree

‎include/MGIS/Function/EvaluatorConcept.hxx‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -114,17 +114,17 @@ namespace mgis::function {
114114
(ElementSpaceConcept<Space> && hasElementWorkspace<Space>));
115115
static constexpr bool b3 =
116116
((requires(const EvaluatorType& e) {
117-
e(std::declval<cell_workspace<Space>>(),
118-
std::declval<cell_index<Space>>());
117+
e(std::declval<cell_index<Space>>(),
118+
std::declval<quadrature_point_index<Space>>());
119119
}) &&
120-
(QuadratureSpaceConcept<Space> && hasCellWorkspace<Space>));
120+
(QuadratureSpaceConcept<Space>));
121121
static constexpr bool b4 =
122122
((requires(const EvaluatorType& e) {
123123
e(std::declval<cell_workspace<Space>>(),
124124
std::declval<cell_index<Space>>(),
125125
std::declval<quadrature_point_index<Space>>());
126126
}) &&
127-
(QuadratureSpaceConcept<Space>));
127+
(QuadratureSpaceConcept<Space> && hasCellWorkspace<Space>));
128128
using ResultType1 =
129129
typename EvaluatorResultQueryImplementation1<b1, EvaluatorType>::type;
130130
using ResultType2 =

‎include/MGIS/Function/FunctionConcept.hxx‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -167,11 +167,11 @@ namespace mgis::function {
167167
static constexpr bool b3 =
168168
((requires(FunctionType & e) {
169169
{
170-
e(std::declval<cell_workspace<Space>>(),
171-
std::declval<cell_index<Space>>())
170+
e(std::declval<cell_index<Space>>(),
171+
std::declval<quadrature_point_index<Space>>())
172172
} -> mutable_return_value;
173173
}) &&
174-
(QuadratureSpaceConcept<Space> && hasCellWorkspace<Space>));
174+
(QuadratureSpaceConcept<Space>));
175175
static constexpr bool b4 =
176176
((requires(FunctionType & e) {
177177
{
@@ -180,7 +180,7 @@ namespace mgis::function {
180180
std::declval<quadrature_point_index<Space>>())
181181
} -> mutable_return_value;
182182
}) &&
183-
(QuadratureSpaceConcept<Space>));
183+
(QuadratureSpaceConcept<Space> && hasCellWorkspace<Space>));
184184
using result_type1 =
185185
typename FunctionResultQueryImplementation1<b1, FunctionType>::
186186
result_type;

‎include/MGIS/Function/UniformEvaluator.hxx‎

Lines changed: 123 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
1+
/*!
2+
* \file MGIS/Function/UniformEvaluator.hxx
3+
* \brief
4+
* \author Thomas Helfer
5+
* \date 06/10/2025
6+
*/
7+
8+
#ifndef LIB_MGIS_FUNCTION_UNIFORMEVALUATOR_HXX
9+
#define LIB_MGIS_FUNCTION_UNIFORMEVALUATOR_HXX
10+
11+
#include <span>
12+
#include <array>
13+
#include <type_traits>
14+
#include "MGIS/Config.hxx"
15+
#include "MGIS/Function/SpaceConcept.hxx"
16+
#include "MGIS/Function/EvaluatorConcept.hxx"
17+
18+
namespace mgis::function {
19+
20+
/*!
21+
* \brief class describing a uniform evaluator
22+
*/
23+
template <SpaceConcept Space, std::size_t N>
24+
struct UniformEvaluator {
25+
//! \brief type passed to construct the uniform value
26+
using ValueType =
27+
std::conditional_t<N == 1, real, std::span<const real, N>>;
28+
/*!
29+
* \brief constructor
30+
* \param[in] s: space
31+
* \param[in] v: value
32+
*/
33+
constexpr UniformEvaluator(const Space&, const ValueType&) noexcept;
34+
//! \brief move constructor
35+
constexpr UniformEvaluator(UniformEvaluator&&) noexcept;
36+
//! \brief copy constructor
37+
constexpr UniformEvaluator(const UniformEvaluator&) noexcept;
38+
//! \brief return the underlying space
39+
constexpr const Space& getSpace() const noexcept;
40+
/*!
41+
* \brief call operator
42+
* \param[in] i: integration point index
43+
*/
44+
constexpr ValueType operator()(const element_index<Space>&) const noexcept
45+
requires(ElementSpaceConcept<Space>);
46+
/*!
47+
* \brief call operator
48+
* \param[in] i: integration point index
49+
*/
50+
constexpr ValueType operator()(const element_workspace<Space>&,
51+
const element_index<Space>&) const noexcept
52+
requires(ElementSpaceConcept<Space>&& hasElementWorkspace<Space>);
53+
/*!
54+
* \brief call operator
55+
* \param[in] e: cell index
56+
* \param[in] i: integration point index
57+
*/
58+
constexpr ValueType operator()(const cell_index<Space>&,
59+
const quadrature_point_index<Space>&)
60+
const noexcept requires(QuadratureSpaceConcept<Space>);
61+
/*!
62+
* \brief call operator
63+
* \param[in] e: cell index
64+
* \param[in] i: integration point index
65+
*/
66+
constexpr ValueType operator()(
67+
const cell_workspace<Space>&,
68+
const cell_index<Space>&,
69+
const quadrature_point_index<Space>&) const noexcept
70+
requires(QuadratureSpaceConcept<Space>&& hasCellWorkspace<Space>);
71+
//! \brief destructor
72+
constexpr ~UniformEvaluator() noexcept;
73+
74+
protected:
75+
//
76+
static_assert(N > 0);
77+
//
78+
static constexpr real buildValues(const real) noexcept;
79+
//
80+
static constexpr std::array<real, N> buildValues(
81+
const std::span<const real>&) noexcept;
82+
//! \brief underlying discretization space
83+
const Space space;
84+
//! \brief values
85+
const std::conditional_t<N == 1, real, std::array<real, N>> values;
86+
}; // end of struct UniformEvaluator
87+
88+
// class template deduction guide
89+
90+
template <SpaceConcept SpaceType>
91+
UniformEvaluator(const SpaceType&, real) -> UniformEvaluator<SpaceType, 1>;
92+
93+
template <SpaceConcept SpaceType, std::size_t N>
94+
UniformEvaluator(const SpaceType&, const real (&)[N])
95+
->UniformEvaluator<SpaceType, N>
96+
requires(N > 1);
97+
98+
template <SpaceConcept SpaceType, std::size_t N>
99+
UniformEvaluator(const SpaceType&, std::array<real, N>)
100+
->UniformEvaluator<SpaceType, N>
101+
requires(N > 1);
102+
103+
template <SpaceConcept SpaceType, std::size_t N>
104+
UniformEvaluator(const SpaceType&, std::span<real, N>)
105+
->UniformEvaluator<SpaceType, N>
106+
requires(N > 1);
107+
108+
template <SpaceConcept Space, std::size_t N>
109+
constexpr bool check(AbstractErrorHandler&,
110+
const UniformEvaluator<Space, N>&) noexcept;
111+
112+
template <SpaceConcept Space, std::size_t N>
113+
constexpr const Space& getSpace(const UniformEvaluator<Space, N>&) noexcept;
114+
115+
template <SpaceConcept Space, std::size_t N>
116+
constexpr mgis::size_type getNumberOfComponents(
117+
const UniformEvaluator<Space, N>&) noexcept;
118+
119+
} // end of namespace mgis::function
120+
121+
#include "MGIS/Function/UniformEvaluator.ixx"
122+
123+
#endif /* LIB_MGIS_FUNCTION_UNIFORMEVALUATOR_HXX */

‎include/MGIS/Function/UniformEvaluator.ixx‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,105 @@
1+
/*!
2+
* \file MGIS/Function/UniformEvaluator.ixx
3+
* \brief
4+
* \author Thomas Helfer
5+
* \date 06/10/2025
6+
*/
7+
8+
#ifndef LIB_MGIS_FUNCTION_UNIFORMEVALUATOR_IXX
9+
#define LIB_MGIS_FUNCTION_UNIFORMEVALUATOR_IXX
10+
11+
#include <utility>
12+
13+
namespace mgis::function {
14+
15+
template <SpaceConcept Space, std::size_t N>
16+
constexpr real UniformEvaluator<Space, N>::buildValues(
17+
const real v) noexcept {
18+
return v;
19+
} // end of buildValues
20+
21+
template <SpaceConcept Space, std::size_t N>
22+
constexpr std::array<real, N> UniformEvaluator<Space, N>::buildValues(
23+
const std::span<const real>& v) noexcept {
24+
return [&v]<std::size_t... Is>(std::index_sequence<Is...>) {
25+
return std::array<real, N>{{v[Is]...}};
26+
}
27+
(std::make_index_sequence<N>());
28+
} // end of buildValues
29+
30+
template <SpaceConcept Space, std::size_t N>
31+
constexpr UniformEvaluator<Space, N>::UniformEvaluator(
32+
const Space& s, const ValueType& v) noexcept
33+
: space(s), values(buildValues(v)) {} // end of UniformEvaluator
34+
35+
template <SpaceConcept Space, std::size_t N>
36+
constexpr UniformEvaluator<Space, N>::UniformEvaluator(
37+
UniformEvaluator&&) noexcept = default;
38+
39+
template <SpaceConcept Space, std::size_t N>
40+
constexpr UniformEvaluator<Space, N>::UniformEvaluator(
41+
const UniformEvaluator&) noexcept = default;
42+
43+
template <SpaceConcept Space, std::size_t N>
44+
constexpr const Space& UniformEvaluator<Space, N>::getSpace() const noexcept {
45+
return this->space;
46+
} // end of space
47+
48+
template <SpaceConcept Space, std::size_t N>
49+
constexpr typename UniformEvaluator<Space, N>::ValueType
50+
UniformEvaluator<Space, N>::operator()(const element_index<Space>&)
51+
const noexcept requires(ElementSpaceConcept<Space>) {
52+
return this->values;
53+
} // end of operator()
54+
55+
template <SpaceConcept Space, std::size_t N>
56+
constexpr typename UniformEvaluator<Space, N>::ValueType
57+
UniformEvaluator<Space, N>::operator()(
58+
const element_workspace<Space>&,
59+
const element_index<Space>&) const noexcept
60+
requires(ElementSpaceConcept<Space>&& hasElementWorkspace<Space>) {
61+
return this->values;
62+
} // end of operator()
63+
64+
template <SpaceConcept Space, std::size_t N>
65+
constexpr typename UniformEvaluator<Space, N>::ValueType
66+
UniformEvaluator<Space, N>::operator()(const cell_index<Space>&,
67+
const quadrature_point_index<Space>&)
68+
const noexcept requires(QuadratureSpaceConcept<Space>) {
69+
return this->values;
70+
} // end of operator()
71+
72+
template <SpaceConcept Space, std::size_t N>
73+
constexpr typename UniformEvaluator<Space, N>::ValueType
74+
UniformEvaluator<Space, N>::operator()(
75+
const cell_workspace<Space>&,
76+
const cell_index<Space>&,
77+
const quadrature_point_index<Space>&) const noexcept
78+
requires(QuadratureSpaceConcept<Space>&& hasCellWorkspace<Space>) {
79+
return this->values;
80+
} // end of operator()
81+
82+
template <SpaceConcept Space, std::size_t N>
83+
constexpr UniformEvaluator<Space, N>::~UniformEvaluator() noexcept = default;
84+
85+
template <SpaceConcept Space, std::size_t N>
86+
constexpr bool check(AbstractErrorHandler&,
87+
const UniformEvaluator<Space, N>&) noexcept {
88+
return true;
89+
} // end of check
90+
91+
template <SpaceConcept Space, std::size_t N>
92+
constexpr const Space& getSpace(
93+
const UniformEvaluator<Space, N>& e) noexcept {
94+
return e.getSpace();
95+
} // end of getSpace
96+
97+
template <SpaceConcept Space, std::size_t N>
98+
constexpr mgis::size_type getNumberOfComponents(
99+
const UniformEvaluator<Space, N>&) noexcept {
100+
return static_cast<mgis::size_type>(N);
101+
} // end of getSpace
102+
103+
} // end of namespace mgis::function
104+
105+
#endif /* LIB_MGIS_FUNCTION_UNIFORMEVALUATOR_IXX */

‎src/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,7 @@ if(enable-mgis-function)
3030
FixedSizeView.cxx
3131
Function.cxx
3232
Evaluator.cxx
33+
UniformEvaluator.cxx
3334
MaterialFunctionManager.cxx)
3435
if(MGIS_HAVE_TFEL)
3536
list(APPEND MFrontGenericInterface_SOURCES

‎src/UniformEvaluator.cxx‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
/*!
2+
* \file UniformEvaluator.cxx
3+
* \brief
4+
* \author Thomas Helfer
5+
* \date 06/10/2025
6+
*/
7+
8+
#include "MGIS/Function/BasicLinearSpace.hxx"
9+
#include "MGIS/Function/UniformEvaluator.hxx"
10+
11+
namespace mgis::function {
12+
13+
static_assert(EvaluatorConcept<UniformEvaluator<BasicLinearSpace, 1>>);
14+
static_assert(EvaluatorConcept<UniformEvaluator<BasicLinearSpace, 6>>);
15+
16+
} // end of namespace mgis::function

‎tests/CMakeLists.txt‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -466,6 +466,27 @@ if((CMAKE_HOST_WIN32) AND (NOT MSYS))
466466
PROPERTY ENVIRONMENT "PATH=$<TARGET_FILE_DIR:MFrontGenericInterface>\;${MGIS_PATH_STRING}")
467467
endif((CMAKE_HOST_WIN32) AND (NOT MSYS))
468468

469+
add_executable(UniformEvaluatorsTest
470+
EXCLUDE_FROM_ALL
471+
UniformEvaluatorsTest.cxx)
472+
target_link_libraries(UniformEvaluatorsTest
473+
PRIVATE MFrontGenericInterface tfel::TFELTests)
474+
add_test(NAME UniformEvaluatorsTest COMMAND UniformEvaluatorsTest)
475+
add_dependencies(check UniformEvaluatorsTest)
476+
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
477+
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14.2.0)
478+
target_compile_definitions(UniformEvaluatorsTest
479+
PRIVATE MGIS_DISABLE_CONSTEXPR_FUNCTION_TESTS)
480+
endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14.2.0)
481+
endif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
482+
if(CMAKE_CXX_COMPILER_ID STREQUAL "NVHPC")
483+
target_compile_definitions(UniformEvaluatorsTest
484+
PRIVATE MGIS_DISABLE_CONSTEXPR_FUNCTION_TESTS)
485+
endif()
486+
if((CMAKE_HOST_WIN32) AND (NOT MSYS))
487+
set_property(TEST UniformEvaluatorsTest
488+
PROPERTY ENVIRONMENT "PATH=$<TARGET_FILE_DIR:MFrontGenericInterface>\;${MGIS_PATH_STRING}")
489+
endif((CMAKE_HOST_WIN32) AND (NOT MSYS))
469490

470491
add_executable(MechanicalEvaluatorsTest
471492
EXCLUDE_FROM_ALL

‎tests/UniformEvaluatorsTest.cxx‎

Lines changed: 60 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,60 @@
1+
/*!
2+
* \file UniformEvaluatorsTest.cxx
3+
* \brief
4+
* \author Thomas Helfer
5+
* \date 02/05/2025
6+
*/
7+
8+
#ifdef NDEBUG
9+
#undef NDEBUG
10+
#endif
11+
12+
#include <cmath>
13+
#include <memory>
14+
#include <limits>
15+
#include <cstdlib>
16+
#include <iostream>
17+
#include <stdexcept>
18+
#include "TFEL/Tests/TestCase.hxx"
19+
#include "TFEL/Tests/TestProxy.hxx"
20+
#include "TFEL/Tests/TestManager.hxx"
21+
#include "MGIS/Function/BasicLinearSpace.hxx"
22+
#include "MGIS/Function/UniformEvaluator.hxx"
23+
24+
struct UniformEvaluatorsTest final : public tfel::tests::TestCase {
25+
UniformEvaluatorsTest()
26+
: tfel::tests::TestCase("MGIS/Function", "UniformEvaluatorsTests") {
27+
} // end of UniformEvaluatorsTest
28+
tfel::tests::TestResult execute() override {
29+
this->test1();
30+
return this->result;
31+
}
32+
33+
private:
34+
void test1() {
35+
using namespace mgis;
36+
using namespace mgis::function;
37+
auto local_abs = [](const mgis::real r) constexpr {
38+
return r > 0 ? r : -r;
39+
};
40+
constexpr auto eps = real{1e-14};
41+
constexpr auto space = BasicLinearSpace{3};
42+
constexpr auto e = UniformEvaluator(space, 12.);
43+
TFEL_TESTS_STATIC_ASSERT(local_abs(e(1) - 12) < eps);
44+
constexpr real values[3] = {12, -2, 6};
45+
constexpr auto e2 = UniformEvaluator(space, values);
46+
TFEL_TESTS_STATIC_ASSERT(local_abs(e2(1)[0] - 12) < eps);
47+
TFEL_TESTS_STATIC_ASSERT(local_abs(e2(1)[1] + 2) < eps);
48+
TFEL_TESTS_STATIC_ASSERT(local_abs(e2(1)[2] - 6) < eps);
49+
}
50+
};
51+
52+
TFEL_TESTS_GENERATE_PROXY(UniformEvaluatorsTest, "UniformEvaluatorsTest");
53+
54+
/* coverity [UNCAUGHT_EXCEPT]*/
55+
int main() {
56+
auto& m = tfel::tests::TestManager::getTestManager();
57+
m.addTestOutput(std::cout);
58+
m.addXMLTestOutput("UniformEvaluatorsTest.xml");
59+
return m.execute().success() ? EXIT_SUCCESS : EXIT_FAILURE;
60+
}

0 commit comments

Comments
 (0)