diff --git a/CMakeLists.txt b/CMakeLists.txt
index 560dd74c04bf5f76dee000a9a8883276ff99bdfd..0676fb79a931c8622b0182eb6cb03011f4e681ad 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -92,7 +92,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DKokkos=InlineKokkos")
#------------------------------------------------------
# Pugs default compiler flags
-set(PUGS_CXX_FLAGS "${PUGS_CXX_FLAGS} -Wall -Wextra -pedantic")
+set(PUGS_CXX_FLAGS "${PUGS_CXX_FLAGS} -Wall -Wextra -pedantic -Wshadow")
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "${GNU_CXX_MIN_VERSION}")
diff --git a/src/language/ast/ASTNodeDataTypeBuilder.cpp b/src/language/ast/ASTNodeDataTypeBuilder.cpp
index b67d81af335e3de1d3c02b0307351f03e75f8089..8a934ee2504c1e38872c8cf25b4d35b9c2f89d14 100644
--- a/src/language/ast/ASTNodeDataTypeBuilder.cpp
+++ b/src/language/ast/ASTNodeDataTypeBuilder.cpp
@@ -154,13 +154,13 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
ASTNode& parameters_name_node = *function_descriptor.definitionNode().children[0];
{ // Function data type
- const std::string& symbol = n.children[0]->string();
+ const std::string& function_symbol = n.children[0]->string();
std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table;
- auto [i_symbol, found] = symbol_table->find(symbol, n.children[0]->begin());
+ auto [i_function_symbol, found] = symbol_table->find(function_symbol, n.children[0]->begin());
Assert(found);
- i_symbol->attributes().setDataType(n.children[0]->m_data_type);
+ i_function_symbol->attributes().setDataType(n.children[0]->m_data_type);
}
const size_t nb_parameter_domains =
@@ -209,14 +209,14 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
}
}();
- symbol_node.m_data_type = data_type;
- const std::string& symbol = symbol_node.string();
+ symbol_node.m_data_type = data_type;
+ const std::string& symbol_node_name = symbol_node.string();
std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table;
- auto [i_symbol, found] = symbol_table->find(symbol, symbol_node.begin());
+ auto [i_symbol_node_name, found] = symbol_table->find(symbol_node_name, symbol_node.begin());
Assert(found);
- i_symbol->attributes().setDataType(data_type);
+ i_symbol_node_name->attributes().setDataType(data_type);
};
if (parameters_domain_node.is_type<language::empty_set>() or
diff --git a/src/language/utils/BuiltinFunctionEmbedderUtils.cpp b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
index f4259526fb10a7d1977eec7c575e69c0837a4a26..1ceb09b0dd622251eb0f4a4e71390c897809f2bc 100644
--- a/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
+++ b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
@@ -177,7 +177,7 @@ getBuiltinFunctionEmbedder(ASTNode& n)
}
}
- uint64_t builtin_function_id = [&] {
+ const uint64_t builtin_function_id = [&] {
switch (size(callable_id_list)) {
case 0: {
std::ostringstream error_msg;
@@ -186,14 +186,15 @@ getBuiltinFunctionEmbedder(ASTNode& n)
<< rang::style::reset << rang::style::bold << "\nnote: candidates are";
for (auto candidate : builtin_function_candidate_list) {
- uint64_t builtin_function_id = std::get<uint64_t>(candidate.attributes().value());
+ uint64_t candidate_builtin_function_id = std::get<uint64_t>(candidate.attributes().value());
- auto& builtin_function_embedder_table = n.m_symbol_table->builtinFunctionEmbedderTable();
- std::shared_ptr builtin_function_embedder = builtin_function_embedder_table[builtin_function_id];
+ auto& builtin_function_embedder_table = n.m_symbol_table->builtinFunctionEmbedderTable();
+ std::shared_ptr candidate_builtin_function_embedder =
+ builtin_function_embedder_table[candidate_builtin_function_id];
error_msg << "\n " << builtin_function_name << ": "
- << dataTypeName(builtin_function_embedder->getParameterDataTypes()) << " -> "
- << dataTypeName(builtin_function_embedder->getReturnDataType());
+ << dataTypeName(candidate_builtin_function_embedder->getParameterDataTypes()) << " -> "
+ << dataTypeName(candidate_builtin_function_embedder->getReturnDataType());
}
throw ParseError(error_msg.str(), n.begin());
diff --git a/src/language/utils/DataVariant.cpp b/src/language/utils/DataVariant.cpp
index 005dda6f17f9d38cb2c9a7a63322244657f89e50..2525d999791204f0d2b2ed7466354bd6719c1e6a 100644
--- a/src/language/utils/DataVariant.cpp
+++ b/src/language/utils/DataVariant.cpp
@@ -4,7 +4,7 @@
#include <utils/PugsTraits.hpp>
std::ostream&
-operator<<(std::ostream& os, const DataVariant& v)
+operator<<(std::ostream& os, const DataVariant& data_variant)
{
std::visit(
[&](auto&& v) {
@@ -29,7 +29,7 @@ operator<<(std::ostream& os, const DataVariant& v)
os << v;
}
},
- v);
+ data_variant);
return os;
}
diff --git a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
index ea842f84c24276323f8aa61865e8d1de470ef10d..0f9224fed185541ca8da8cdaaa10ffa777c978ad 100644
--- a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
+++ b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
@@ -10,63 +10,63 @@
#include <utils/Demangle.hpp>
-#define DISCRETE_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG) \
- return std::visit( \
- [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> { \
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; \
- if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or \
- std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or \
- std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) { \
- return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function)); \
- } else { \
- throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG)); \
- } \
- }, \
+#define DISCRETE_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG) \
+ return std::visit( \
+ [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> { \
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; \
+ if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \
+ std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \
+ std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \
+ return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function)); \
+ } else { \
+ throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG)); \
+ } \
+ }, \
ARG->discreteFunction());
-#define DISCRETE_VH_TO_R_CALL(FUNCTION, ARG) \
- return std::visit( \
- [&](auto&& discrete_function) -> double { \
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; \
- if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or \
- std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or \
- std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) { \
- return FUNCTION(discrete_function); \
- } else { \
- throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG)); \
- } \
- }, \
+#define DISCRETE_VH_TO_R_CALL(FUNCTION, ARG) \
+ return std::visit( \
+ [&](auto&& discrete_function) -> double { \
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; \
+ if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \
+ std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \
+ std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \
+ return FUNCTION(discrete_function); \
+ } else { \
+ throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG)); \
+ } \
+ }, \
ARG->discreteFunction());
-#define DISCRETE_VH_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1) \
- if (not hasSameMesh({ARG0, ARG1})) { \
- throw NormalError("operands are defined on different meshes"); \
- } \
- return std::visit( \
- [&](auto&& f, auto&& g) -> std::shared_ptr<DiscreteFunctionVariant> { \
- using TypeOfF = std::decay_t<decltype(f)>; \
- using TypeOfG = std::decay_t<decltype(g)>; \
- if constexpr (std::is_same_v<TypeOfF, DiscreteFunctionP0<1, const double>> or \
- std::is_same_v<TypeOfF, DiscreteFunctionP0<2, const double>> or \
- std::is_same_v<TypeOfF, DiscreteFunctionP0<3, const double>>) { \
- if constexpr (std::is_same_v<TypeOfF, TypeOfG>) { \
- return std::make_shared<DiscreteFunctionVariant>(FUNCTION(f, g)); \
- } else { \
- throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g)); \
- } \
- } else { \
- throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g)); \
- } \
- }, \
+#define DISCRETE_VH_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1) \
+ if (not hasSameMesh({ARG0, ARG1})) { \
+ throw NormalError("operands are defined on different meshes"); \
+ } \
+ return std::visit( \
+ [&](auto&& arg_f, auto&& arg_g) -> std::shared_ptr<DiscreteFunctionVariant> { \
+ using TypeOfF = std::decay_t<decltype(arg_f)>; \
+ using TypeOfG = std::decay_t<decltype(arg_g)>; \
+ if constexpr (std::is_same_v<TypeOfF, DiscreteFunctionP0<1, const double>> or \
+ std::is_same_v<TypeOfF, DiscreteFunctionP0<2, const double>> or \
+ std::is_same_v<TypeOfF, DiscreteFunctionP0<3, const double>>) { \
+ if constexpr (std::is_same_v<TypeOfF, TypeOfG>) { \
+ return std::make_shared<DiscreteFunctionVariant>(FUNCTION(arg_f, arg_g)); \
+ } else { \
+ throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(arg_f, arg_g)); \
+ } \
+ } else { \
+ throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(arg_f, arg_g)); \
+ } \
+ }, \
ARG0->discreteFunction(), ARG1->discreteFunction());
#define DISCRETE_R_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1) \
return std::visit( \
[&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> { \
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; \
- if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or \
- std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or \
- std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) { \
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; \
+ if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \
+ std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \
+ std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \
return std::make_shared<DiscreteFunctionVariant>(FUNCTION(ARG0, discrete_function)); \
} else { \
throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(ARG0, discrete_function)); \
@@ -77,10 +77,10 @@
#define DISCRETE_VH_R_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1) \
return std::visit( \
[&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> { \
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>; \
- if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or \
- std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or \
- std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) { \
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>; \
+ if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \
+ std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \
+ std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \
return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function, ARG1)); \
} else { \
throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(discrete_function, ARG1)); \
@@ -330,11 +330,10 @@ det(const std::shared_ptr<const DiscreteFunctionVariant>& A)
{
return std::visit(
[&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
- if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
- if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) {
- if constexpr (DiscreteFunctionType::data_type::NumberOfRows ==
- DiscreteFunctionType::data_type::NumberOfColumns) {
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+ if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+ if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) {
+ if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) {
return std::make_shared<DiscreteFunctionVariant>(det(discrete_function));
} else {
throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
@@ -354,11 +353,10 @@ trace(const std::shared_ptr<const DiscreteFunctionVariant>& A)
{
return std::visit(
[&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
- if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
- if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) {
- if constexpr (DiscreteFunctionType::data_type::NumberOfRows ==
- DiscreteFunctionType::data_type::NumberOfColumns) {
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+ if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+ if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) {
+ if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) {
return std::make_shared<DiscreteFunctionVariant>(trace(discrete_function));
} else {
throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
@@ -378,11 +376,10 @@ inverse(const std::shared_ptr<const DiscreteFunctionVariant>& A)
{
return std::visit(
[&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
- if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
- if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) {
- if constexpr (DiscreteFunctionType::data_type::NumberOfRows ==
- DiscreteFunctionType::data_type::NumberOfColumns) {
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+ if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+ if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) {
+ if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) {
return std::make_shared<DiscreteFunctionVariant>(inverse(discrete_function));
} else {
throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
@@ -402,11 +399,10 @@ transpose(const std::shared_ptr<const DiscreteFunctionVariant>& A)
{
return std::visit(
[&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
- if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
- if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) {
- if constexpr (DiscreteFunctionType::data_type::NumberOfRows ==
- DiscreteFunctionType::data_type::NumberOfColumns) {
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+ if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+ if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) {
+ if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) {
return std::make_shared<DiscreteFunctionVariant>(transpose(discrete_function));
} else {
throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
@@ -476,9 +472,9 @@ sum_of(const std::shared_ptr<const DiscreteFunctionVariant>& f)
ValueT value;
std::visit(
[&](auto&& discrete_function) {
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
- if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
- using DataType = std::decay_t<typename DiscreteFunctionType::data_type>;
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+ if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+ using DataType = std::decay_t<typename DiscreteFunctionT::data_type>;
if constexpr (std::is_same_v<ValueT, DataType>) {
value = sum(discrete_function);
} else {
@@ -498,9 +494,9 @@ sum_of_Vh_components(const std::shared_ptr<const DiscreteFunctionVariant>& f)
{
return std::visit(
[&](auto&& discrete_function) -> std::shared_ptr<const DiscreteFunctionVariant> {
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
- if constexpr (is_discrete_function_P0_vector_v<DiscreteFunctionType>) {
- using DataType = std::decay_t<typename DiscreteFunctionType::data_type>;
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+ if constexpr (is_discrete_function_P0_vector_v<DiscreteFunctionT>) {
+ using DataType = std::decay_t<typename DiscreteFunctionT::data_type>;
static_assert(std::is_same_v<DataType, double>);
return std::make_shared<DiscreteFunctionVariant>(sumOfComponents(discrete_function));
} else {
@@ -520,11 +516,10 @@ vectorize_to(const std::vector<std::shared_ptr<const DiscreteFunctionVariant>>&
for (size_t i_discrete_function = 0; i_discrete_function < discrete_function_list.size(); ++i_discrete_function) {
std::visit(
[&](auto&& discrete_function) {
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
- if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
- using DataType = std::remove_const_t<typename DiscreteFunctionType::data_type>;
- if constexpr (std::is_same_v<DataType, double> and
- (Dimension == DiscreteFunctionType::MeshType::Dimension)) {
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+ if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+ using DataType = std::remove_const_t<typename DiscreteFunctionT::data_type>;
+ if constexpr (std::is_same_v<DataType, double> and (Dimension == DiscreteFunctionT::MeshType::Dimension)) {
const auto& connectivity = mesh.connectivity();
parallel_for(
connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
@@ -619,9 +614,9 @@ integral_of(const std::shared_ptr<const DiscreteFunctionVariant>& f)
{
return std::visit(
[&](auto&& discrete_function) -> ValueT {
- using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
- if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
- using DataType = std::decay_t<typename DiscreteFunctionType::data_type>;
+ using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+ if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+ using DataType = std::decay_t<typename DiscreteFunctionT::data_type>;
if constexpr (std::is_same_v<ValueT, DataType>) {
return integrate(discrete_function);
} else {
diff --git a/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp b/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp
index 48b51efba5aa8a9a9905247629e9e398a70ab17a..2ed94cbff4c8ee846e04674fd3e421f718577bfc 100644
--- a/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp
+++ b/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp
@@ -58,17 +58,18 @@ ItemArrayVariantFunctionInterpoler::_interpolate() const
Assert(function0_descriptor.domainMappingNode().children[1]->m_data_type == ASTNodeDataType::typename_t or
function0_descriptor.domainMappingNode().children[1]->m_data_type == ASTNodeDataType::tuple_t);
- ASTNodeDataType data_type = function0_descriptor.domainMappingNode().children[1]->m_data_type.contentType();
+ ASTNodeDataType data_type_candidate =
+ function0_descriptor.domainMappingNode().children[1]->m_data_type.contentType();
for (size_t i = 1; i < m_function_id_list.size(); ++i) {
const auto& function_descriptor = m_function_id_list[i].descriptor();
Assert(function_descriptor.domainMappingNode().children[1]->m_data_type == ASTNodeDataType::typename_t);
- if (data_type != function_descriptor.domainMappingNode().children[1]->m_data_type.contentType()) {
+ if (data_type_candidate != function_descriptor.domainMappingNode().children[1]->m_data_type.contentType()) {
throw NormalError("functions must have the same type");
}
}
- return data_type;
+ return data_type_candidate;
}();
switch (data_type) {
diff --git a/src/mesh/CartesianMeshBuilder.cpp b/src/mesh/CartesianMeshBuilder.cpp
index 9f6ea50cab88390669e3471ad3c70f25e870e390..226ff751fdf0b3316d66e2cb0c6e5366a9852d73 100644
--- a/src/mesh/CartesianMeshBuilder.cpp
+++ b/src/mesh/CartesianMeshBuilder.cpp
@@ -68,11 +68,11 @@ CartesianMeshBuilder::_getNodeCoordinates(const TinyVector<3>& a,
const IConnectivity& connectivity) const
{
const TinyVector<3, uint64_t> node_size = [&] {
- TinyVector node_size{cell_size};
+ TinyVector sizes_of_nodes{cell_size};
for (size_t i = 0; i < 3; ++i) {
- node_size[i] += 1;
+ sizes_of_nodes[i] += 1;
}
- return node_size;
+ return sizes_of_nodes;
}();
const auto node_logic_id = [&](size_t r) {
diff --git a/src/mesh/ConnectivityBuilderBase.cpp b/src/mesh/ConnectivityBuilderBase.cpp
index e7eb95fc6ed064805d12b5a8ece6e2844c37b9e9..f90e506d9edfdeb6242141e08ab9d46892aa6fca 100644
--- a/src/mesh/ConnectivityBuilderBase.cpp
+++ b/src/mesh/ConnectivityBuilderBase.cpp
@@ -100,7 +100,7 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
Array<unsigned int> dup_faces_to_node_list(total_number_of_face_by_node);
Array<unsigned int> dup_face_to_node_row(total_number_of_faces + 1);
- size_t i_face = 0;
+ size_t face_couter = 0;
dup_face_to_node_row[0] = 0;
Array<unsigned short> cell_nb_faces(cell_to_node_matrix.numberOfRows());
@@ -119,12 +119,12 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
- i_face++;
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
- i_face++;
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+ face_couter++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+ face_couter++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+ face_couter++;
cell_nb_faces[j] = 3;
break;
}
@@ -138,14 +138,14 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
- i_face++;
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
- i_face++;
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
- i_face++;
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+ face_couter++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+ face_couter++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+ face_couter++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+ face_couter++;
cell_nb_faces[j] = 4;
break;
}
@@ -156,8 +156,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node] = cell_nodes[(i + 1) % cell_nodes.size()];
i_face_node++;
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+ face_couter++;
}
cell_nb_faces[j] = cell_nodes.size();
@@ -177,48 +177,48 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
dup_faces_to_node_list[i_face_node++] = cell_nodes[6];
dup_faces_to_node_list[i_face_node++] = cell_nodes[7];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
dup_faces_to_node_list[i_face_node++] = cell_nodes[7];
dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
dup_faces_to_node_list[i_face_node++] = cell_nodes[6];
dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
dup_faces_to_node_list[i_face_node++] = cell_nodes[7];
dup_faces_to_node_list[i_face_node++] = cell_nodes[6];
dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+ face_couter++;
cell_nb_faces[j] = 6;
break;
@@ -228,29 +228,29 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+ face_couter++;
cell_nb_faces[j] = 4;
break;
@@ -260,39 +260,39 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+ face_couter++;
dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+ face_couter++;
cell_nb_faces[j] = 5;
break;
@@ -308,8 +308,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node++] = base_nodes[i];
}
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + base_nodes.size();
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + base_nodes.size();
+ face_couter++;
// side faces
const auto pyramid_vertex = cell_nodes[cell_nodes.size() - 1];
@@ -318,8 +318,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node++] = base_nodes[i_node];
dup_faces_to_node_list[i_face_node++] = pyramid_vertex;
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+ face_couter++;
}
break;
}
@@ -333,8 +333,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node++] = base_nodes((i_node + 1) % (cell_nodes.size() - 2));
dup_faces_to_node_list[i_face_node++] = top_vertex;
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+ face_couter++;
}
}
@@ -345,8 +345,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
dup_faces_to_node_list[i_face_node++] = base_nodes(i_node);
dup_faces_to_node_list[i_face_node++] = bottom_vertex;
- dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
- i_face++;
+ dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+ face_couter++;
}
}
cell_nb_faces[j] = 2 * (cell_nodes.size() - 2);
diff --git a/src/mesh/ConnectivityDispatcher.cpp b/src/mesh/ConnectivityDispatcher.cpp
index dde1f930d26d31faa21d06bf2b8d94568ccb93f1..65326b56bd49c1ce155dbf07fe32da8622c2e66c 100644
--- a/src/mesh/ConnectivityDispatcher.cpp
+++ b/src/mesh/ConnectivityDispatcher.cpp
@@ -294,7 +294,7 @@ ConnectivityDispatcher<Dimension>::_buildSubItemNumbersToRecvByProc()
using ItemId = ItemIdT<SubItemOfItemT::item_type>;
using SubItemId = ItemIdT<SubItemOfItemT::sub_item_type>;
- std::vector<Array<const int>> sub_item_numbers_to_send_by_proc(parallel::size());
+ std::vector<Array<const int>> mutable_sub_item_numbers_to_send_by_proc(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
const auto& item_list_to_send_by_proc = this->_dispatchedInfo<SubItemOfItemT::item_type>().m_list_to_send_by_proc;
@@ -307,9 +307,9 @@ ConnectivityDispatcher<Dimension>::_buildSubItemNumbersToRecvByProc()
sub_item_numbers_by_item_vector.push_back(sub_item_number[sub_item_id]);
}
}
- sub_item_numbers_to_send_by_proc[i_rank] = convert_to_array(sub_item_numbers_by_item_vector);
+ mutable_sub_item_numbers_to_send_by_proc[i_rank] = convert_to_array(sub_item_numbers_by_item_vector);
}
- return sub_item_numbers_to_send_by_proc;
+ return mutable_sub_item_numbers_to_send_by_proc;
}();
const auto& number_of_sub_item_per_item_to_recv_by_proc =
@@ -416,8 +416,8 @@ ConnectivityDispatcher<Dimension>::_buildRecvItemIdCorrespondanceByProc()
for (size_t i_rank = 0; i_rank < item_list_to_recv_size_by_proc.size(); ++i_rank) {
Array<ItemId> item_id_correspondance(item_list_to_recv_size_by_proc[i_rank]);
for (size_t l = 0; l < item_list_to_recv_size_by_proc[i_rank]; ++l) {
- const int& item_number = recv_item_number_by_proc[i_rank][l];
- const auto& searched_item_id = item_number_to_id_map.find(item_number);
+ const int& recv_item_number = recv_item_number_by_proc[i_rank][l];
+ const auto& searched_item_id = item_number_to_id_map.find(recv_item_number);
Assert(searched_item_id != item_number_to_id_map.end());
item_id_correspondance[l] = searched_item_id->second;
}
@@ -438,11 +438,11 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
parallel::allGather(m_connectivity.template numberOfRefItemList<item_type>());
const size_t number_of_item_list_sender = [&]() {
- size_t number_of_item_list_sender = 0;
+ size_t mutable_number_of_item_list_sender = 0;
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- number_of_item_list_sender += (number_of_item_ref_list_per_proc[i_rank] > 0);
+ mutable_number_of_item_list_sender += (number_of_item_ref_list_per_proc[i_rank] > 0);
}
- return number_of_item_list_sender;
+ return mutable_number_of_item_list_sender;
}();
if (number_of_item_list_sender > 0) {
@@ -512,15 +512,15 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
parallel::broadcast(ref_name_cat, sender_rank);
std::vector<RefId> ref_id_list = [&]() {
- std::vector<RefId> ref_id_list;
- ref_id_list.reserve(ref_name_size_list.size());
+ std::vector<RefId> mutable_ref_id_list;
+ mutable_ref_id_list.reserve(ref_name_size_list.size());
size_t begining = 0;
for (size_t i_ref = 0; i_ref < ref_name_size_list.size(); ++i_ref) {
const size_t size = ref_name_size_list[i_ref];
- ref_id_list.emplace_back(ref_tag_list[i_ref], std::string{&(ref_name_cat[begining]), size});
+ mutable_ref_id_list.emplace_back(ref_tag_list[i_ref], std::string{&(ref_name_cat[begining]), size});
begining += size;
}
- return ref_id_list;
+ return mutable_ref_id_list;
}();
using block_type = int32_t;
diff --git a/src/mesh/DiamondDualConnectivityBuilder.cpp b/src/mesh/DiamondDualConnectivityBuilder.cpp
index 2cc1f47cd3be15c1012dda01c0c1c5b84ae66355..d170212a38d96628887ebb43ef154923990a5f04 100644
--- a/src/mesh/DiamondDualConnectivityBuilder.cpp
+++ b/src/mesh/DiamondDualConnectivityBuilder.cpp
@@ -216,11 +216,11 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
const auto& node_number_vector = diamond_descriptor.nodeNumberVector();
{
const std::unordered_map<unsigned int, NodeId> node_to_id_map = [&] {
- std::unordered_map<unsigned int, NodeId> node_to_id_map;
+ std::unordered_map<unsigned int, NodeId> mutable_node_to_id_map;
for (size_t i_node = 0; i_node < node_number_vector.size(); ++i_node) {
- node_to_id_map[node_number_vector[i_node]] = i_node;
+ mutable_node_to_id_map[node_number_vector[i_node]] = i_node;
}
- return node_to_id_map;
+ return mutable_node_to_id_map;
}();
for (size_t i_node_list = 0; i_node_list < primal_connectivity.template numberOfRefItemList<ItemType::node>();
@@ -229,17 +229,17 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
const auto& primal_node_list = primal_ref_node_list.list();
const std::vector<NodeId> diamond_node_list = [&]() {
- std::vector<NodeId> diamond_node_list;
+ std::vector<NodeId> mutable_diamond_node_list;
for (size_t i_primal_node = 0; i_primal_node < primal_node_list.size(); ++i_primal_node) {
auto primal_node_id = primal_node_list[i_primal_node];
const auto i_diamond_node = node_to_id_map.find(primal_connectivity.nodeNumber()[primal_node_id]);
if (i_diamond_node != node_to_id_map.end()) {
- diamond_node_list.push_back(i_diamond_node->second);
+ mutable_diamond_node_list.push_back(i_diamond_node->second);
}
}
- return diamond_node_list;
+ return mutable_diamond_node_list;
}();
if (parallel::allReduceOr(diamond_node_list.size() > 0)) {
@@ -286,31 +286,31 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
const auto& primal_face_list = primal_ref_face_list.list();
const std::vector<FaceId> diamond_face_list = [&]() {
- std::vector<FaceId> diamond_face_list;
- diamond_face_list.reserve(primal_face_list.size());
- for (size_t i = 0; i < primal_face_list.size(); ++i) {
- FaceId primal_face_id = primal_face_list[i];
+ std::vector<FaceId> mutablt_diamond_face_list;
+ mutablt_diamond_face_list.reserve(primal_face_list.size());
+ for (size_t i_primal_face = 0; i_primal_face < primal_face_list.size(); ++i_primal_face) {
+ FaceId primal_face_id = primal_face_list[i_primal_face];
const auto& primal_face_node_list = primal_face_to_node_matrix[primal_face_id];
face_node_list.clear();
- for (size_t i = 0; i < primal_face_node_list.size(); ++i) {
- face_node_list.push_back(primal_face_node_list[i]);
+ for (size_t i_primal_face_noe = 0; i_primal_face_noe < primal_face_node_list.size(); ++i_primal_face_noe) {
+ face_node_list.push_back(primal_face_node_list[i_primal_face_noe]);
}
auto face_id = find_face(face_node_list);
if (face_id.has_value()) {
- diamond_face_list.push_back(face_id.value());
+ mutablt_diamond_face_list.push_back(face_id.value());
}
}
- return diamond_face_list;
+ return mutablt_diamond_face_list;
}();
if (parallel::allReduceOr(diamond_face_list.size() > 0)) {
Array<FaceId> face_array(diamond_face_list.size());
- for (size_t i = 0; i < diamond_face_list.size(); ++i) {
- face_array[i] = diamond_face_list[i];
+ for (size_t i_diamond_face = 0; i_diamond_face < diamond_face_list.size(); ++i_diamond_face) {
+ face_array[i_diamond_face] = diamond_face_list[i_diamond_face];
}
diamond_descriptor.addRefItemList(
RefFaceList{primal_ref_face_list.refId(), face_array, primal_ref_face_list.type()});
@@ -361,8 +361,8 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
const auto& primal_edge_list = primal_ref_edge_list.list();
const std::vector<EdgeId> diamond_edge_list = [&]() {
- std::vector<EdgeId> diamond_edge_list;
- diamond_edge_list.reserve(primal_edge_list.size());
+ std::vector<EdgeId> mutable_diamond_edge_list;
+ mutable_diamond_edge_list.reserve(primal_edge_list.size());
for (size_t i = 0; i < primal_edge_list.size(); ++i) {
EdgeId primal_edge_id = primal_edge_list[i];
@@ -371,10 +371,10 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
const auto diamond_edge_id = find_edge(primal_edge_node_list[0], primal_edge_node_list[1]);
if (diamond_edge_id.has_value()) {
- diamond_edge_list.push_back(diamond_edge_id.value());
+ mutable_diamond_edge_list.push_back(diamond_edge_id.value());
}
}
- return diamond_edge_list;
+ return mutable_diamond_edge_list;
}();
if (parallel::allReduceOr(diamond_edge_list.size() > 0)) {
diff --git a/src/mesh/Dual1DConnectivityBuilder.cpp b/src/mesh/Dual1DConnectivityBuilder.cpp
index 9dd1c743edc0a07f578a4d7fd646ab96cfff490d..bc4f4bccc4b9055b65be7e9b103e124ef4d18eb2 100644
--- a/src/mesh/Dual1DConnectivityBuilder.cpp
+++ b/src/mesh/Dual1DConnectivityBuilder.cpp
@@ -74,14 +74,14 @@ Dual1DConnectivityBuilder::_buildConnectivityDescriptor(const Connectivity<1>& p
Array<unsigned int> cell_to_node_list(cell_to_node_row[cell_to_node_row.size() - 1]);
{
- size_t next_kept_node_id = 0;
- size_t i_cell_node = 0;
+ size_t i_kept_node_id = 0;
+ size_t i_cell_node = 0;
for (NodeId i_node = 0; i_node < primal_connectivity.numberOfNodes(); ++i_node) {
const auto& primal_node_cell_list = primal_node_to_cell_matrix[i_node];
if (primal_node_cell_list.size() == 1) {
const auto i_node_in_cell = primal_node_local_number_in_their_cells(i_node, 0);
- cell_to_node_list[i_cell_node + i_node_in_cell] = next_kept_node_id++;
+ cell_to_node_list[i_cell_node + i_node_in_cell] = i_kept_node_id++;
cell_to_node_list[i_cell_node + 1 - i_node_in_cell] = number_of_kept_nodes + primal_node_cell_list[0];
i_cell_node += 2;
@@ -113,11 +113,11 @@ Dual1DConnectivityBuilder::_buildConnectivityFrom(const IConnectivity& i_primal_
const auto& dual_node_number_vector = dual_descriptor.nodeNumberVector();
const std::unordered_map<unsigned int, NodeId> node_to_id_map = [&] {
- std::unordered_map<unsigned int, NodeId> node_to_id_map;
+ std::unordered_map<unsigned int, NodeId> mutable_node_to_id_map;
for (size_t i_node = 0; i_node < dual_node_number_vector.size(); ++i_node) {
- node_to_id_map[dual_node_number_vector[i_node]] = i_node;
+ mutable_node_to_id_map[dual_node_number_vector[i_node]] = i_node;
}
- return node_to_id_map;
+ return mutable_node_to_id_map;
}();
for (size_t i_node_list = 0; i_node_list < primal_connectivity.template numberOfRefItemList<ItemType::node>();
@@ -126,17 +126,17 @@ Dual1DConnectivityBuilder::_buildConnectivityFrom(const IConnectivity& i_primal_
const auto& primal_node_list = primal_ref_node_list.list();
const std::vector<NodeId> dual_node_list = [&]() {
- std::vector<NodeId> dual_node_list;
+ std::vector<NodeId> mutable_dual_node_list;
for (size_t i_primal_node = 0; i_primal_node < primal_node_list.size(); ++i_primal_node) {
auto primal_node_id = primal_node_list[i_primal_node];
const auto i_dual_node = node_to_id_map.find(primal_connectivity.nodeNumber()[primal_node_id]);
if (i_dual_node != node_to_id_map.end()) {
- dual_node_list.push_back(i_dual_node->second);
+ mutable_dual_node_list.push_back(i_dual_node->second);
}
}
- return dual_node_list;
+ return mutable_dual_node_list;
}();
if (parallel::allReduceOr(dual_node_list.size() > 0)) {
diff --git a/src/mesh/GmshReader.cpp b/src/mesh/GmshReader.cpp
index 73de0466d156f53a114494a1419b9ca506bfea26..e05dcaae592bcd4871f11de760ea1f17ee5221dd 100644
--- a/src/mesh/GmshReader.cpp
+++ b/src/mesh/GmshReader.cpp
@@ -251,12 +251,12 @@ GmshConnectivityBuilder<2>::GmshConnectivityBuilder(const GmshReader::GmshData&
std::unordered_map<int, FaceId> face_number_id_map = [&] {
const auto& face_number_vector = descriptor.faceNumberVector();
- std::unordered_map<int, FaceId> face_number_id_map;
+ std::unordered_map<int, FaceId> mutable_face_number_id_map;
for (size_t l = 0; l < face_number_vector.size(); ++l) {
- face_number_id_map[face_number_vector[l]] = l;
+ mutable_face_number_id_map[face_number_vector[l]] = l;
}
- Assert(face_number_id_map.size() == face_number_vector.size());
- return face_number_id_map;
+ Assert(mutable_face_number_id_map.size() == face_number_vector.size());
+ return mutable_face_number_id_map;
}();
const auto& node_number_vector = descriptor.nodeNumberVector();
@@ -593,15 +593,15 @@ GmshConnectivityBuilder<3>::GmshConnectivityBuilder(const GmshReader::GmshData&
}
}
- const auto& face_number_vector = descriptor.faceNumberVector();
+ const auto& descriptor_face_number_vector = descriptor.faceNumberVector();
{
std::unordered_map<int, FaceId> face_number_id_map = [&] {
- std::unordered_map<int, FaceId> face_number_id_map;
- for (size_t l = 0; l < face_number_vector.size(); ++l) {
- face_number_id_map[face_number_vector[l]] = l;
+ std::unordered_map<int, FaceId> mutable_face_number_id_map;
+ for (size_t l = 0; l < descriptor_face_number_vector.size(); ++l) {
+ mutable_face_number_id_map[descriptor_face_number_vector[l]] = l;
}
- Assert(face_number_id_map.size() == face_number_vector.size());
- return face_number_id_map;
+ Assert(mutable_face_number_id_map.size() == descriptor_face_number_vector.size());
+ return mutable_face_number_id_map;
}();
const auto& node_to_face_matrix = descriptor.nodeToFaceMatrix();
@@ -799,12 +799,12 @@ GmshConnectivityBuilder<3>::GmshConnectivityBuilder(const GmshReader::GmshData&
std::unordered_map<int, EdgeId> edge_number_id_map = [&] {
const auto& edge_number_vector = descriptor.edgeNumberVector();
- std::unordered_map<int, EdgeId> edge_number_id_map;
+ std::unordered_map<int, EdgeId> mutable_edge_number_id_map;
for (size_t l = 0; l < edge_number_vector.size(); ++l) {
- edge_number_id_map[edge_number_vector[l]] = l;
+ mutable_edge_number_id_map[edge_number_vector[l]] = l;
}
- Assert(edge_number_id_map.size() == edge_number_vector.size());
- return edge_number_id_map;
+ Assert(mutable_edge_number_id_map.size() == edge_number_vector.size());
+ return mutable_edge_number_id_map;
}();
Array<int> edge_number_vector = copy(descriptor.edgeNumberVector());
@@ -1063,12 +1063,12 @@ GmshReader::GmshReader(const std::string& filename) : m_filename(filename)
std::cout << "Sequential mesh read! Need to be dispatched\n" << std::flush;
const int mesh_dimension = [&]() {
- int mesh_dimension = -1; // unknown mesh dimension
+ int mutable_mesh_dimension = -1; // unknown mesh dimension
if (m_mesh) {
- mesh_dimension = m_mesh->dimension();
+ mutable_mesh_dimension = m_mesh->dimension();
}
- Array<int> dimensions = parallel::allGather(mesh_dimension);
+ Array<int> dimensions = parallel::allGather(mutable_mesh_dimension);
std::set<int> dimension_set;
for (size_t i = 0; i < dimensions.size(); ++i) {
const int i_dimension = dimensions[i];
@@ -1196,8 +1196,8 @@ GmshReader::__readPeriodic2_2()
[[maybe_unused]] const int master_id = this->_getInteger();
[[maybe_unused]] const int nb_corresponding_nodes = this->_getInteger();
for (int i_node = 0; i_node < nb_corresponding_nodes; ++i_node) {
- [[maybe_unused]] const int node_id = this->_getInteger();
- [[maybe_unused]] const int master_id = this->_getInteger();
+ [[maybe_unused]] const int node_id = this->_getInteger();
+ [[maybe_unused]] const int node_master_id = this->_getInteger();
}
}
}
diff --git a/src/mesh/LogicalConnectivityBuilder.cpp b/src/mesh/LogicalConnectivityBuilder.cpp
index 0fcbe6752f74f34adcec1d3a2a698ccbe253987a..df205e577a12edf19f4e4a3705ba58b1e89d2cdf 100644
--- a/src/mesh/LogicalConnectivityBuilder.cpp
+++ b/src/mesh/LogicalConnectivityBuilder.cpp
@@ -574,11 +574,11 @@ LogicalConnectivityBuilder::_buildConnectivity(const TinyVector<3, uint64_t>& ce
constexpr size_t Dimension = 3;
const TinyVector<Dimension, uint64_t> node_size = [&] {
- TinyVector node_size{cell_size};
+ TinyVector mutable_node_size{cell_size};
for (size_t i = 0; i < Dimension; ++i) {
- node_size[i] += 1;
+ mutable_node_size[i] += 1;
}
- return node_size;
+ return mutable_node_size;
}();
auto count_items = [](auto&& v) {
diff --git a/src/mesh/MedianDualConnectivityBuilder.cpp b/src/mesh/MedianDualConnectivityBuilder.cpp
index ef4b260e4ce695a9386cac4f62396a129738a242..5f608943e2a5a7370b111bdabb842e6e52b48f27 100644
--- a/src/mesh/MedianDualConnectivityBuilder.cpp
+++ b/src/mesh/MedianDualConnectivityBuilder.cpp
@@ -33,9 +33,8 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit
parallel_reduce(
primal_number_of_faces,
- PUGS_LAMBDA(const FaceId face_id, size_t& number_of_boundary_faces) {
- number_of_boundary_faces +=
- (primal_face_is_owned[face_id] and (primal_face_to_cell_matrix[face_id].size() == 1));
+ PUGS_LAMBDA(const FaceId face_id, size_t& nb_of_boundary_faces) {
+ nb_of_boundary_faces += (primal_face_is_owned[face_id] and (primal_face_to_cell_matrix[face_id].size() == 1));
},
number_of_boundary_faces);
return number_of_boundary_faces;
@@ -206,16 +205,17 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit
auto [face_id, cell_id] = [&]() -> std::pair<FaceId, CellId> {
for (size_t i_face = 0; i_face < primal_node_to_face_list.size(); ++i_face) {
- const FaceId face_id = primal_node_to_face_list[i_face];
- if (primal_face_to_cell_matrix[face_id].size() > 1) {
+ const FaceId primal_face_id = primal_node_to_face_list[i_face];
+ if (primal_face_to_cell_matrix[primal_face_id].size() > 1) {
continue;
}
- const CellId cell_id = primal_face_to_cell_matrix[face_id][0];
- const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(face_id, 0);
+ const CellId primal_cell_id = primal_face_to_cell_matrix[primal_face_id][0];
+ const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(primal_face_id, 0);
- if (primal_face_to_node_matrix[face_id][primal_cell_face_is_reversed(cell_id, i_face_in_cell)] == node_id) {
- return std::make_pair(face_id, cell_id);
+ if (primal_face_to_node_matrix[primal_face_id]
+ [primal_cell_face_is_reversed(primal_cell_id, i_face_in_cell)] == node_id) {
+ return std::make_pair(primal_face_id, primal_cell_id);
}
}
// LCOV_EXCL_START
@@ -243,14 +243,15 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit
// inner cell
auto [face_id, cell_id] = [&]() -> std::pair<FaceId, CellId> {
- const FaceId face_id = primal_node_to_face_list[0];
+ const FaceId primal_face_id = primal_node_to_face_list[0];
- for (size_t i_face_cell = 0; i_face_cell < primal_face_to_cell_matrix[face_id].size(); ++i_face_cell) {
- const CellId cell_id = primal_face_to_cell_matrix[face_id][i_face_cell];
- const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(face_id, i_face_cell);
+ for (size_t i_face_cell = 0; i_face_cell < primal_face_to_cell_matrix[primal_face_id].size(); ++i_face_cell) {
+ const CellId primal_cell_id = primal_face_to_cell_matrix[primal_face_id][i_face_cell];
+ const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(primal_face_id, i_face_cell);
- if (primal_face_to_node_matrix[face_id][primal_cell_face_is_reversed(cell_id, i_face_in_cell)] == node_id) {
- return std::make_pair(face_id, cell_id);
+ if (primal_face_to_node_matrix[primal_face_id]
+ [primal_cell_face_is_reversed(primal_cell_id, i_face_in_cell)] == node_id) {
+ return std::make_pair(primal_face_id, primal_cell_id);
}
}
// LCOV_EXCL_START
diff --git a/src/mesh/MeshBuilderBase.cpp b/src/mesh/MeshBuilderBase.cpp
index 973a6099afb49595d02403c697bbb927d2a7ba63..d2b27cd14c6680a99c4d6aba3281d36bcae1071b 100644
--- a/src/mesh/MeshBuilderBase.cpp
+++ b/src/mesh/MeshBuilderBase.cpp
@@ -91,8 +91,9 @@ MeshBuilderBase::_checkMesh() const
if (intersection.size() > 1) {
std::ostringstream error_msg;
error_msg << "invalid mesh.\n\tFollowing edges\n";
- for (EdgeId edge_id : intersection) {
- error_msg << "\t - id=" << edge_id << " number=" << connectivity.edgeNumber()[edge_id] << '\n';
+ for (EdgeId duplicated_edge_id : intersection) {
+ error_msg << "\t - id=" << duplicated_edge_id << " number=" << connectivity.edgeNumber()[duplicated_edge_id]
+ << '\n';
}
error_msg << "\tare duplicated";
throw NormalError(error_msg.str());
@@ -179,8 +180,9 @@ MeshBuilderBase::_checkMesh() const
if (intersection.size() > 1) {
std::ostringstream error_msg;
error_msg << "invalid mesh.\n\tFollowing cells\n";
- for (CellId cell_id : intersection) {
- error_msg << "\t - id=" << cell_id << " number=" << connectivity.cellNumber()[cell_id] << '\n';
+ for (CellId duplicated_cell_id : intersection) {
+ error_msg << "\t - id=" << duplicated_cell_id << " number=" << connectivity.cellNumber()[duplicated_cell_id]
+ << '\n';
}
error_msg << "\tare duplicated";
throw NormalError(error_msg.str());
diff --git a/src/mesh/MeshFlatNodeBoundary.cpp b/src/mesh/MeshFlatNodeBoundary.cpp
index 459a827c84ead76ed23acdf28cbd8525923694da..f5e60af046b49903304762aec86a237d7b2a868a 100644
--- a/src/mesh/MeshFlatNodeBoundary.cpp
+++ b/src/mesh/MeshFlatNodeBoundary.cpp
@@ -38,13 +38,13 @@ MeshFlatNodeBoundary<1>::_getNormal(const Mesh<Connectivity<1>>& mesh)
using R = TinyVector<1, double>;
const size_t number_of_bc_nodes = [&]() {
- size_t number_of_bc_nodes = 0;
- auto node_is_owned = mesh.connectivity().nodeIsOwned();
- auto node_list = m_ref_node_list.list();
+ size_t nb_bc_nodes = 0;
+ auto node_is_owned = mesh.connectivity().nodeIsOwned();
+ auto node_list = m_ref_node_list.list();
for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
- number_of_bc_nodes += (node_is_owned[node_list[i_node]]);
+ nb_bc_nodes += (node_is_owned[node_list[i_node]]);
}
- return parallel::allReduceMax(number_of_bc_nodes);
+ return parallel::allReduceMax(nb_bc_nodes);
}();
if (number_of_bc_nodes != 1) {
diff --git a/src/mesh/MeshNodeBoundary.cpp b/src/mesh/MeshNodeBoundary.cpp
index d97ee08bff9e38a7945490a2441b8e6348c84150..e883aa4eeb80b40962218208fc044f964a7d4a8d 100644
--- a/src/mesh/MeshNodeBoundary.cpp
+++ b/src/mesh/MeshNodeBoundary.cpp
@@ -20,15 +20,15 @@ MeshNodeBoundary<2>::_getBounds(const Mesh<Connectivity<2>>& mesh) const
xmin = R2{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()};
xmax = R2{-std::numeric_limits<double>::max(), -std::numeric_limits<double>::max()};
- auto update_xmin = [](const R2& x, R2& xmin) {
- if ((x[0] < xmin[0]) or ((x[0] == xmin[0]) and (x[1] < xmin[1]))) {
- xmin = x;
+ auto update_xmin = [](const R2& x, R2& x_min) {
+ if ((x[0] < x_min[0]) or ((x[0] == x_min[0]) and (x[1] < x_min[1]))) {
+ x_min = x;
}
};
- auto update_xmax = [](const R2& x, R2& xmax) {
- if ((x[0] > xmax[0]) or ((x[0] == xmax[0]) and (x[1] > xmax[1]))) {
- xmax = x;
+ auto update_xmax = [](const R2& x, R2& x_max) {
+ if ((x[0] > x_max[0]) or ((x[0] == x_max[0]) and (x[1] > x_max[1]))) {
+ x_max = x;
}
};
diff --git a/src/output/GnuplotWriter1D.cpp b/src/output/GnuplotWriter1D.cpp
index 3e0740446e961505eb01e36eee5ba168e0f47dcc..6b8da7a7e063caeac4cbcd64e577ba75d913fe13 100644
--- a/src/output/GnuplotWriter1D.cpp
+++ b/src/output/GnuplotWriter1D.cpp
@@ -148,12 +148,12 @@ GnuplotWriter1D::_writeItemDatas(const MeshType& mesh,
{
using ItemId = ItemIdT<item_type>;
- const size_t& number_of_columns = [&] {
- size_t number_of_columns = 1;
+ const size_t number_of_columns = [&] {
+ size_t nb_columns = 1;
for (const auto& [name, item_data] : output_named_item_data_set) {
- std::visit([&](auto&& value) { number_of_columns += _itemDataNbRow(value); }, item_data);
+ std::visit([&](auto&& value) { nb_columns += _itemDataNbRow(value); }, item_data);
}
- return number_of_columns;
+ return nb_columns;
}();
auto is_owned = mesh.connectivity().template isOwned<item_type>();
diff --git a/src/utils/Partitioner.cpp b/src/utils/Partitioner.cpp
index e63a4b48ccfdd57952d77797bbbee3344187352e..85e13c22d80f449c211f4c37ee20f3107556d6ba 100644
--- a/src/utils/Partitioner.cpp
+++ b/src/utils/Partitioner.cpp
@@ -37,14 +37,14 @@ Partitioner::partition(const CRSGraph& graph)
MPI_Group mesh_group;
std::vector<int> group_ranks = [&]() {
Array<int> graph_node_owners = parallel::allGather(static_cast<int>(graph.numberOfNodes()));
- std::vector<int> group_ranks;
- group_ranks.reserve(graph_node_owners.size());
+ std::vector<int> grp_ranks;
+ grp_ranks.reserve(graph_node_owners.size());
for (size_t i = 0; i < graph_node_owners.size(); ++i) {
if (graph_node_owners[i] > 0) {
- group_ranks.push_back(i);
+ grp_ranks.push_back(i);
}
}
- return group_ranks;
+ return grp_ranks;
}();
MPI_Group_incl(world_group, group_ranks.size(), &(group_ranks[0]), &mesh_group);
diff --git a/tests/mpi_test_main.cpp b/tests/mpi_test_main.cpp
index fb0da8569382769cf495dedceb42a91528076dd9..ef3fdfcc00569ea3042de6724171fbd24e2ed680 100644
--- a/tests/mpi_test_main.cpp
+++ b/tests/mpi_test_main.cpp
@@ -81,11 +81,11 @@ main(int argc, char* argv[])
<< '\n';
for (size_t i_rank = 1; i_rank < parallel::size(); ++i_rank) {
- std::filesystem::path parallel_output = std::filesystem::path{PUGS_BINARY_DIR}.append("tests");
- parallel_output /= output_base_name + stringify(i_rank);
- std::cout << " - " << rang::fg::green << parallel_output.parent_path().string()
- << parallel_output.preferred_separator << rang::style::reset << rang::fgB::green
- << parallel_output.filename().string() << rang::style::reset << '\n';
+ std::filesystem::path other_rank_output = std::filesystem::path{PUGS_BINARY_DIR}.append("tests");
+ other_rank_output /= output_base_name + stringify(i_rank);
+ std::cout << " - " << rang::fg::green << other_rank_output.parent_path().string()
+ << other_rank_output.preferred_separator << rang::style::reset << rang::fgB::green
+ << other_rank_output.filename().string() << rang::style::reset << '\n';
}
}
}
diff --git a/tests/test_Array.cpp b/tests/test_Array.cpp
index 2651ecf43287fed07345f7fdbfef63e7d6f770a8..4a447f70a9e99151027266602763b712d00525cf 100644
--- a/tests/test_Array.cpp
+++ b/tests/test_Array.cpp
@@ -260,67 +260,67 @@ TEST_CASE("Array", "[utils]")
SECTION("checking for Array reductions")
{
- Array<int> a(10);
- a[0] = 13;
- a[1] = 1;
- a[2] = 8;
- a[3] = -3;
- a[4] = 23;
- a[5] = -1;
- a[6] = 13;
- a[7] = 0;
- a[8] = 12;
- a[9] = 9;
+ Array<int> b(10);
+ b[0] = 13;
+ b[1] = 1;
+ b[2] = 8;
+ b[3] = -3;
+ b[4] = 23;
+ b[5] = -1;
+ b[6] = 13;
+ b[7] = 0;
+ b[8] = 12;
+ b[9] = 9;
SECTION("Min")
{
- REQUIRE(min(a) == -3);
+ REQUIRE(min(b) == -3);
}
SECTION("Max")
{
- REQUIRE(max(a) == 23);
+ REQUIRE(max(b) == 23);
}
SECTION("Sum")
{
- REQUIRE((sum(a) == 75));
+ REQUIRE((sum(b) == 75));
}
SECTION("TinyVector Sum")
{
using N2 = TinyVector<2, int>;
- Array<N2> b(10);
- b[0] = N2{13, 2};
- b[1] = N2{1, 3};
- b[2] = N2{8, -2};
- b[3] = N2{-3, 2};
- b[4] = N2{23, 4};
- b[5] = N2{-1, -3};
- b[6] = N2{13, 17};
- b[7] = N2{0, 9};
- b[8] = N2{12, 13};
- b[9] = N2{9, -17};
-
- REQUIRE((sum(b) == N2{75, 28}));
+ Array<N2> c(10);
+ c[0] = N2{13, 2};
+ c[1] = N2{1, 3};
+ c[2] = N2{8, -2};
+ c[3] = N2{-3, 2};
+ c[4] = N2{23, 4};
+ c[5] = N2{-1, -3};
+ c[6] = N2{13, 17};
+ c[7] = N2{0, 9};
+ c[8] = N2{12, 13};
+ c[9] = N2{9, -17};
+
+ REQUIRE((sum(c) == N2{75, 28}));
}
SECTION("TinyMatrix Sum")
{
using N22 = TinyMatrix<2, 2, int>;
- Array<N22> b(10);
- b[0] = N22{13, 2, 0, 1};
- b[1] = N22{1, 3, 6, 3};
- b[2] = N22{8, -2, -1, 21};
- b[3] = N22{-3, 2, 5, 12};
- b[4] = N22{23, 4, 7, 1};
- b[5] = N22{-1, -3, 33, 11};
- b[6] = N22{13, 17, 12, 13};
- b[7] = N22{0, 9, 1, 14};
- b[8] = N22{12, 13, -3, -71};
- b[9] = N22{9, -17, 0, 16};
-
- REQUIRE((sum(b) == N22{75, 28, 60, 21}));
+ Array<N22> d(10);
+ d[0] = N22{13, 2, 0, 1};
+ d[1] = N22{1, 3, 6, 3};
+ d[2] = N22{8, -2, -1, 21};
+ d[3] = N22{-3, 2, 5, 12};
+ d[4] = N22{23, 4, 7, 1};
+ d[5] = N22{-1, -3, 33, 11};
+ d[6] = N22{13, 17, 12, 13};
+ d[7] = N22{0, 9, 1, 14};
+ d[8] = N22{12, 13, -3, -71};
+ d[9] = N22{9, -17, 0, 16};
+
+ REQUIRE((sum(d) == N22{75, 28, 60, 21}));
}
}
diff --git a/tests/test_BuiltinFunctionEmbedder.cpp b/tests/test_BuiltinFunctionEmbedder.cpp
index 31cde714627687bb0aee8f62ff122cf2e5ae0a1b..be28e7d75a42240f2f2e248e8cade2261e5ef5e5 100644
--- a/tests/test_BuiltinFunctionEmbedder.cpp
+++ b/tests/test_BuiltinFunctionEmbedder.cpp
@@ -204,11 +204,11 @@ TEST_CASE("BuiltinFunctionEmbedder", "[language]")
SECTION("uint64_t(std::vector<uint64_t>) BuiltinFunctionEmbedder")
{
std::function sum = [&](const std::vector<uint64_t>& x) -> uint64_t {
- uint64_t sum = 0;
+ uint64_t s = 0;
for (size_t i = 0; i < x.size(); ++i) {
- sum += x[i];
+ s += x[i];
}
- return sum;
+ return s;
};
std::unique_ptr<IBuiltinFunctionEmbedder> i_embedded_c =
@@ -234,11 +234,11 @@ TEST_CASE("BuiltinFunctionEmbedder", "[language]")
SECTION("uint64_t(std::vector<EmbeddedData>) BuiltinFunctionEmbedder")
{
std::function sum = [&](const std::vector<std::shared_ptr<const uint64_t>>& x) -> uint64_t {
- uint64_t sum = 0;
+ uint64_t s = 0;
for (size_t i = 0; i < x.size(); ++i) {
- sum += *x[i];
+ s += *x[i];
}
- return sum;
+ return s;
};
std::unique_ptr<IBuiltinFunctionEmbedder> i_embedded_c =
diff --git a/tests/test_BuiltinFunctionProcessor.cpp b/tests/test_BuiltinFunctionProcessor.cpp
index de04b76016ad02a78130574129b74d95ca38ba94..b678612fe2c338b641b1e66c6ccce9ae65454b8f 100644
--- a/tests/test_BuiltinFunctionProcessor.cpp
+++ b/tests/test_BuiltinFunctionProcessor.cpp
@@ -42,7 +42,7 @@
position use_position{10000, 1000, 10, "fixture"}; \
auto [symbol, found] = symbol_table->find(variable_name, use_position); \
\
- REQUIRE_THAT(found, Catch::Matchers::Predicate<bool>([](bool found) -> bool { return found; }, \
+ REQUIRE_THAT(found, Catch::Matchers::Predicate<bool>([](bool is_found) -> bool { return is_found; }, \
std::string{"Cannot find symbol '"} + variable_name + "'")); \
\
auto attributes = symbol->attributes(); \
diff --git a/tests/test_CellIntegrator.cpp b/tests/test_CellIntegrator.cpp
index 7c70d19fd2a538f831507d7eeb41392b0686f158..9b286a44508726c5a286964a89e8acec80ef12ec 100644
--- a/tests/test_CellIntegrator.cpp
+++ b/tests/test_CellIntegrator.cpp
@@ -1156,8 +1156,6 @@ TEST_CASE("CellIntegrator", "[scheme]")
SECTION("2D")
{
- using R2 = TinyVector<2>;
-
const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh();
auto f = [](const R2& X) -> R2 {
diff --git a/tests/test_CubeTransformation.cpp b/tests/test_CubeTransformation.cpp
index 346dd3c4e9b1f3412bb53503c6880ea07a1508e6..e719ea5aaa5c99f659fdad31ca3b3d844b3623ac 100644
--- a/tests/test_CubeTransformation.cpp
+++ b/tests/test_CubeTransformation.cpp
@@ -151,8 +151,6 @@ TEST_CASE("CubeTransformation", "[geometry]")
SECTION("degenerate to tetrahedron")
{
- using R3 = TinyVector<3>;
-
const R3 a{1, 2, 1};
const R3 b{3, 1, 3};
const R3 c{2, 5, 2};
diff --git a/tests/test_DiscreteFunctionP0.cpp b/tests/test_DiscreteFunctionP0.cpp
index d0f71e984d516ec243de289f399d882663c9c499..d7d4dff52124e734b1d0d5f6bce1d402fa0f680d 100644
--- a/tests/test_DiscreteFunctionP0.cpp
+++ b/tests/test_DiscreteFunctionP0.cpp
@@ -47,14 +47,14 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
CellValue<TinyVector<Dimension>> h_values{mesh->connectivity()};
h_values.fill(ZeroType{});
- DiscreteFunctionP0 zero{mesh, [&] {
- CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
- cell_value.fill(ZeroType{});
- return cell_value;
- }()};
+ DiscreteFunctionP0 zero_function{mesh, [&] {
+ CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
+ cell_value.fill(ZeroType{});
+ return cell_value;
+ }()};
DiscreteFunctionP0 h{mesh, h_values};
- REQUIRE(same_values(h, zero));
+ REQUIRE(same_values(h, zero_function));
REQUIRE(same_values(h, h_values));
DiscreteFunctionP0<Dimension, TinyVector<Dimension>> shallow_h{mesh};
@@ -64,7 +64,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
REQUIRE(same_values(shallow_h, h_values));
REQUIRE(same_values(h, h_values));
- REQUIRE(not same_values(h, zero));
+ REQUIRE(not same_values(h, zero_function));
DiscreteFunctionP0 moved_h{std::move(h)};
REQUIRE(same_values(moved_h, h_values));
@@ -95,14 +95,14 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
CellValue<TinyVector<Dimension>> h_values{mesh->connectivity()};
h_values.fill(ZeroType{});
- DiscreteFunctionP0 zero{mesh, [&] {
- CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
- cell_value.fill(ZeroType{});
- return cell_value;
- }()};
+ DiscreteFunctionP0 zero_function{mesh, [&] {
+ CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
+ cell_value.fill(ZeroType{});
+ return cell_value;
+ }()};
DiscreteFunctionP0 h{mesh, h_values};
- REQUIRE(same_values(h, zero));
+ REQUIRE(same_values(h, zero_function));
REQUIRE(same_values(h, h_values));
DiscreteFunctionP0<Dimension, TinyVector<Dimension>> shallow_h{mesh};
@@ -112,7 +112,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
REQUIRE(same_values(shallow_h, h_values));
REQUIRE(same_values(h, h_values));
- REQUIRE(not same_values(h, zero));
+ REQUIRE(not same_values(h, zero_function));
DiscreteFunctionP0 moved_h{std::move(h)};
REQUIRE(same_values(moved_h, h_values));
@@ -144,14 +144,14 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
CellValue<TinyVector<Dimension>> h_values{mesh->connectivity()};
h_values.fill(ZeroType{});
- DiscreteFunctionP0 zero{mesh, [&] {
- CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
- cell_value.fill(ZeroType{});
- return cell_value;
- }()};
+ DiscreteFunctionP0 zero_function{mesh, [&] {
+ CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
+ cell_value.fill(ZeroType{});
+ return cell_value;
+ }()};
DiscreteFunctionP0 h{mesh, h_values};
- REQUIRE(same_values(h, zero));
+ REQUIRE(same_values(h, zero_function));
REQUIRE(same_values(h, h_values));
DiscreteFunctionP0<Dimension, TinyVector<Dimension>> shallow_h{mesh};
@@ -161,7 +161,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
REQUIRE(same_values(shallow_h, h_values));
REQUIRE(same_values(h, h_values));
- REQUIRE(not same_values(h, zero));
+ REQUIRE(not same_values(h, zero_function));
DiscreteFunctionP0 moved_h{std::move(h)};
REQUIRE(same_values(moved_h, h_values));
@@ -295,8 +295,8 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
SECTION("scalar")
{
- const size_t value = parallel::rank() + 1;
- const size_t zero = 0;
+ const size_t value = parallel::rank() + 1;
+ const size_t zero_value = 0;
DiscreteFunctionP0<Dimension, size_t> f{mesh};
f.fill(value);
@@ -304,18 +304,18 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0 g = copy(f);
- f.fill(zero);
+ f.fill(zero_value);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_value));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_value);
DiscreteFunctionP0<Dimension, const size_t> h = copy(f);
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_value));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -326,25 +326,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
SECTION("vector")
{
const TinyVector<2, size_t> value{parallel::rank() + 1, 3};
- const TinyVector<2, size_t> zero{ZeroType{}};
+ const TinyVector<2, size_t> zero_vector{ZeroType{}};
DiscreteFunctionP0<Dimension, TinyVector<2, size_t>> f{mesh};
f.fill(value);
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0 g = copy(f);
- f.fill(zero);
+ f.fill(zero_vector);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_vector));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_vector);
DiscreteFunctionP0<Dimension, const TinyVector<2, size_t>> h = copy(f);
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_vector));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -355,25 +355,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
SECTION("matrix")
{
const TinyMatrix<3, 3, size_t> value{1, 2, 3, 4, 5, 6, 7, 8, 9};
- const TinyMatrix<3, 3, size_t> zero{ZeroType{}};
+ const TinyMatrix<3, 3, size_t> zero_matrix{ZeroType{}};
DiscreteFunctionP0<Dimension, TinyMatrix<3, 3, size_t>> f{mesh};
f.fill(value);
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0 g = copy(f);
- f.fill(zero);
+ f.fill(zero_matrix);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_matrix));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_matrix);
DiscreteFunctionP0<Dimension, const TinyMatrix<3, 3, size_t>> h = copy(f);
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_matrix));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -397,8 +397,8 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
SECTION("scalar")
{
- const size_t value = parallel::rank() + 1;
- const size_t zero = 0;
+ const size_t value = parallel::rank() + 1;
+ const size_t zero_value = 0;
DiscreteFunctionP0<Dimension, size_t> f{mesh};
f.fill(value);
@@ -406,18 +406,18 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0 g = copy(f);
- f.fill(zero);
+ f.fill(zero_value);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_value));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_value);
DiscreteFunctionP0<Dimension, const size_t> h = copy(f);
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_value));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -428,25 +428,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
SECTION("vector")
{
const TinyVector<2, size_t> value{parallel::rank() + 1, 3};
- const TinyVector<2, size_t> zero{ZeroType{}};
+ const TinyVector<2, size_t> zero_vector{ZeroType{}};
DiscreteFunctionP0<Dimension, TinyVector<2, size_t>> f{mesh};
f.fill(value);
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0 g = copy(f);
- f.fill(zero);
+ f.fill(zero_vector);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_vector));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_vector);
DiscreteFunctionP0<Dimension, const TinyVector<2, size_t>> h = copy(f);
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_vector));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -457,25 +457,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
SECTION("matrix")
{
const TinyMatrix<3, 3, size_t> value{1, 2, 3, 4, 5, 6, 7, 8, 9};
- const TinyMatrix<3, 3, size_t> zero{ZeroType{}};
+ const TinyMatrix<3, 3, size_t> zero_vector{ZeroType{}};
DiscreteFunctionP0<Dimension, TinyMatrix<3, 3, size_t>> f{mesh};
f.fill(value);
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0 g = copy(f);
- f.fill(zero);
+ f.fill(zero_vector);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_vector));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_vector);
DiscreteFunctionP0<Dimension, const TinyMatrix<3, 3, size_t>> h = copy(f);
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_vector));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -499,8 +499,8 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
SECTION("scalar")
{
- const size_t value = parallel::rank() + 1;
- const size_t zero = 0;
+ const size_t value = parallel::rank() + 1;
+ const size_t zero_value = 0;
DiscreteFunctionP0<Dimension, size_t> f{mesh};
f.fill(value);
@@ -508,18 +508,18 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0 g = copy(f);
- f.fill(zero);
+ f.fill(zero_value);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_value));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_value);
DiscreteFunctionP0<Dimension, const size_t> h = copy(f);
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_value));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -530,25 +530,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
SECTION("vector")
{
const TinyVector<2, size_t> value{parallel::rank() + 1, 3};
- const TinyVector<2, size_t> zero{ZeroType{}};
+ const TinyVector<2, size_t> zero_vector{ZeroType{}};
DiscreteFunctionP0<Dimension, TinyVector<2, size_t>> f{mesh};
f.fill(value);
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0 g = copy(f);
- f.fill(zero);
+ f.fill(zero_vector);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_vector));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_vector);
DiscreteFunctionP0<Dimension, const TinyVector<2, size_t>> h = copy(f);
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_vector));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -559,25 +559,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
SECTION("matrix")
{
const TinyMatrix<3, 3, size_t> value{1, 2, 3, 4, 5, 6, 7, 8, 9};
- const TinyMatrix<3, 3, size_t> zero{ZeroType{}};
+ const TinyMatrix<3, 3, size_t> zero_matrix{ZeroType{}};
DiscreteFunctionP0<Dimension, TinyMatrix<3, 3, size_t>> f{mesh};
f.fill(value);
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0 g = copy(f);
- f.fill(zero);
+ f.fill(zero_matrix);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_matrix));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_matrix);
DiscreteFunctionP0<Dimension, const TinyMatrix<3, 3, size_t>> h = copy(f);
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_matrix));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -3439,7 +3439,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
const double x = xj[cell_id][0];
Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, //
- -0.2 * x - 1, 2 + x};
+ -0.2 * x - 1, 2 + x};
});
{
@@ -3461,7 +3461,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
const double x = xj[cell_id][0];
Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, //
- -0.2 * x - 1, 2 + x};
+ -0.2 * x - 1, 2 + x};
});
{
@@ -3483,7 +3483,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
const double x = xj[cell_id][0];
Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, //
- -0.2 * x - 1, 2 + x};
+ -0.2 * x - 1, 2 + x};
});
{
@@ -3505,7 +3505,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
const double x = xj[cell_id][0];
Ah[cell_id] = TinyMatrix<2>{x + 1, 2 * x - 3, //
- -0.2 * x - 1, 2 + x};
+ -0.2 * x - 1, 2 + x};
});
{
diff --git a/tests/test_DiscreteFunctionP0Vector.cpp b/tests/test_DiscreteFunctionP0Vector.cpp
index d2da3d84ef517f28dc0bd0ba60149be7c4fba725..2ab61b2405ba5eb098663db5fa6a3d26b6fe75b9 100644
--- a/tests/test_DiscreteFunctionP0Vector.cpp
+++ b/tests/test_DiscreteFunctionP0Vector.cpp
@@ -50,20 +50,20 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
CellArray<double> h_arrays{mesh->connectivity(), size};
h_arrays.fill(0);
- DiscreteFunctionP0Vector zero{mesh, [&] {
- CellArray<double> cell_array{mesh->connectivity(), size};
- cell_array.fill(0);
- return cell_array;
- }()};
+ DiscreteFunctionP0Vector zero_function{mesh, [&] {
+ CellArray<double> cell_array{mesh->connectivity(), size};
+ cell_array.fill(0);
+ return cell_array;
+ }()};
DiscreteFunctionP0Vector h{mesh, h_arrays};
- REQUIRE(same_values(h, zero));
+ REQUIRE(same_values(h, zero_function));
REQUIRE(same_values(h, h_arrays));
h_arrays.fill(1);
REQUIRE(same_values(h, h_arrays));
- REQUIRE(not same_values(h, zero));
+ REQUIRE(not same_values(h, zero_function));
DiscreteFunctionP0Vector moved_h{std::move(h)};
REQUIRE(same_values(moved_h, h_arrays));
@@ -98,20 +98,20 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
CellArray<double> h_arrays{mesh->connectivity(), size};
h_arrays.fill(0);
- DiscreteFunctionP0Vector zero{mesh, [&] {
- CellArray<double> cell_array{mesh->connectivity(), size};
- cell_array.fill(0);
- return cell_array;
- }()};
+ DiscreteFunctionP0Vector zero_function{mesh, [&] {
+ CellArray<double> cell_array{mesh->connectivity(), size};
+ cell_array.fill(0);
+ return cell_array;
+ }()};
DiscreteFunctionP0Vector h{mesh, h_arrays};
- REQUIRE(same_values(h, zero));
+ REQUIRE(same_values(h, zero_function));
REQUIRE(same_values(h, h_arrays));
h_arrays.fill(1);
REQUIRE(same_values(h, h_arrays));
- REQUIRE(not same_values(h, zero));
+ REQUIRE(not same_values(h, zero_function));
DiscreteFunctionP0Vector moved_h{std::move(h)};
REQUIRE(same_values(moved_h, h_arrays));
@@ -146,20 +146,20 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
CellArray<double> h_arrays{mesh->connectivity(), size};
h_arrays.fill(0);
- DiscreteFunctionP0Vector zero{mesh, [&] {
- CellArray<double> cell_array{mesh->connectivity(), size};
- cell_array.fill(0);
- return cell_array;
- }()};
+ DiscreteFunctionP0Vector zero_function{mesh, [&] {
+ CellArray<double> cell_array{mesh->connectivity(), size};
+ cell_array.fill(0);
+ return cell_array;
+ }()};
DiscreteFunctionP0Vector h{mesh, h_arrays};
- REQUIRE(same_values(h, zero));
+ REQUIRE(same_values(h, zero_function));
REQUIRE(same_values(h, h_arrays));
h_arrays.fill(1);
REQUIRE(same_values(h, h_arrays));
- REQUIRE(not same_values(h, zero));
+ REQUIRE(not same_values(h, zero_function));
DiscreteFunctionP0Vector moved_h{std::move(h)};
REQUIRE(same_values(moved_h, h_arrays));
@@ -271,9 +271,9 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
{
auto mesh = named_mesh.mesh();
- const size_t size = 3;
- const size_t value = parallel::rank() + 1;
- const size_t zero = 0;
+ const size_t size = 3;
+ const size_t value = parallel::rank() + 1;
+ const size_t zero_value = 0;
DiscreteFunctionP0Vector<Dimension, size_t> f{mesh, size};
f.fill(value);
@@ -281,13 +281,13 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0Vector g = copy(f);
- f.fill(zero);
+ f.fill(zero_value);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_value));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_value);
DiscreteFunctionP0Vector<Dimension, const size_t> h = copy(f);
@@ -295,8 +295,8 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
shallow_g = g;
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
- REQUIRE(all_values_equal(shallow_g, zero));
+ REQUIRE(all_values_equal(g, zero_value));
+ REQUIRE(all_values_equal(shallow_g, zero_value));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -317,9 +317,9 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
{
auto mesh = named_mesh.mesh();
- const size_t size = 3;
- const size_t value = parallel::rank() + 1;
- const size_t zero = 0;
+ const size_t size = 3;
+ const size_t value = parallel::rank() + 1;
+ const size_t zero_value = 0;
DiscreteFunctionP0Vector<Dimension, size_t> f{mesh, size};
f.fill(value);
@@ -327,13 +327,13 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0Vector g = copy(f);
- f.fill(zero);
+ f.fill(zero_value);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_value));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_value);
DiscreteFunctionP0Vector<Dimension, const size_t> h = copy(f);
@@ -341,8 +341,8 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
shallow_g = g;
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
- REQUIRE(all_values_equal(shallow_g, zero));
+ REQUIRE(all_values_equal(g, zero_value));
+ REQUIRE(all_values_equal(shallow_g, zero_value));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -364,9 +364,9 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
{
auto mesh = named_mesh.mesh();
- const size_t size = 3;
- const size_t value = parallel::rank() + 1;
- const size_t zero = 0;
+ const size_t size = 3;
+ const size_t value = parallel::rank() + 1;
+ const size_t zero_value = 0;
DiscreteFunctionP0Vector<Dimension, size_t> f{mesh, size};
f.fill(value);
@@ -374,13 +374,13 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
REQUIRE(all_values_equal(f, value));
DiscreteFunctionP0Vector g = copy(f);
- f.fill(zero);
+ f.fill(zero_value);
- REQUIRE(all_values_equal(f, zero));
+ REQUIRE(all_values_equal(f, zero_value));
REQUIRE(all_values_equal(g, value));
copy_to(g, f);
- g.fill(zero);
+ g.fill(zero_value);
DiscreteFunctionP0Vector<Dimension, const size_t> h = copy(f);
@@ -388,7 +388,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
shallow_g = g;
REQUIRE(all_values_equal(f, value));
- REQUIRE(all_values_equal(g, zero));
+ REQUIRE(all_values_equal(g, zero_value));
REQUIRE(all_values_equal(h, value));
copy_to(h, g);
@@ -573,10 +573,10 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
DiscreteFunctionP0Vector<Dimension, const double> const_f = f;
DiscreteFunctionP0Vector<Dimension, const double> const_g{g};
- auto same_data = [](const auto& f, const auto& g) {
- const size_t number_of_cells = g.size();
+ auto same_data = [](const auto& f0, const auto& f1) {
+ const size_t number_of_cells = f1.size();
for (CellId cell_id = 0; cell_id < number_of_cells; ++cell_id) {
- if (f[cell_id] != g[cell_id]) {
+ if (f0[cell_id] != f1[cell_id]) {
return false;
}
}
@@ -656,10 +656,10 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
DiscreteFunctionP0Vector<Dimension, const double> const_f = f;
DiscreteFunctionP0Vector<Dimension, const double> const_g{g};
- auto same_data = [](const auto& f, const auto& g) {
- const size_t number_of_cells = g.size();
+ auto same_data = [](const auto& f1, const auto& f2) {
+ const size_t number_of_cells = f2.size();
for (CellId cell_id = 0; cell_id < number_of_cells; ++cell_id) {
- if (f[cell_id] != g[cell_id]) {
+ if (f1[cell_id] != f2[cell_id]) {
return false;
}
}
@@ -739,10 +739,10 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
DiscreteFunctionP0Vector<Dimension, const double> const_f = f;
DiscreteFunctionP0Vector<Dimension, const double> const_g{g};
- auto same_data = [](const auto& f, const auto& g) {
- const size_t number_of_cells = g.size();
+ auto same_data = [](const auto& f1, const auto& f2) {
+ const size_t number_of_cells = f2.size();
for (CellId cell_id = 0; cell_id < number_of_cells; ++cell_id) {
- if (f[cell_id] != g[cell_id]) {
+ if (f1[cell_id] != f2[cell_id]) {
return false;
}
}
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp
index bfa17ffc7609a8a304ee5dd36b3574782fbba464..7da58023559d83d7c554c2cc2d0aa44282508e30 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp
@@ -10,11 +10,11 @@
const U_TYPE& u = P_U->get<U_TYPE>(); \
const FU_TYPE& fu = p_fu->get<FU_TYPE>(); \
\
- bool is_same = true; \
- auto values = u.cellValues(); \
- for (CellId cell_id = 0; cell_id < values.numberOfItems(); ++cell_id) { \
+ bool is_same = true; \
+ auto u_values = u.cellValues(); \
+ for (CellId cell_id = 0; cell_id < u_values.numberOfItems(); ++cell_id) { \
using namespace std; \
- if (fu[cell_id] != FCT(values[cell_id])) { \
+ if (fu[cell_id] != FCT(u_values[cell_id])) { \
is_same = false; \
break; \
} \
diff --git a/tests/test_ItemArray.cpp b/tests/test_ItemArray.cpp
index 2dbe964f3cdd5733aa77ddf5e1bc9204e9731998..644f348c6ae2df4dcf56c87816d1b3b9c323a1a1 100644
--- a/tests/test_ItemArray.cpp
+++ b/tests/test_ItemArray.cpp
@@ -157,15 +157,15 @@ TEST_CASE("ItemArray", "[mesh]")
CellArray<size_t> cell_array{connectivity, table};
- auto is_same = [](const CellArray<size_t>& cell_array, const Table<size_t>& table) {
- bool is_same = true;
- for (CellId cell_id = 0; cell_id < cell_array.numberOfItems(); ++cell_id) {
- auto sub_array = cell_array[cell_id];
+ auto is_same = [](const CellArray<size_t>& a_cell_array, const Table<size_t>& a_table) {
+ bool same = true;
+ for (CellId cell_id = 0; cell_id < a_cell_array.numberOfItems(); ++cell_id) {
+ auto sub_array = a_cell_array[cell_id];
for (size_t i = 0; i < sub_array.size(); ++i) {
- is_same &= (sub_array[i] == table(cell_id, i));
+ same &= (sub_array[i] == a_table(cell_id, i));
}
}
- return is_same;
+ return same;
};
REQUIRE(is_same(cell_array, table));
@@ -177,14 +177,14 @@ TEST_CASE("ItemArray", "[mesh]")
SECTION("copy")
{
auto is_same = [](const auto& cell_array, int value) {
- bool is_same = true;
+ bool same = true;
for (CellId cell_id = 0; cell_id < cell_array.numberOfItems(); ++cell_id) {
auto sub_array = cell_array[cell_id];
for (size_t i = 0; i < sub_array.size(); ++i) {
- is_same &= (sub_array[i] == value);
+ same &= (sub_array[i] == value);
}
}
- return is_same;
+ return same;
};
std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes();
@@ -367,12 +367,12 @@ TEST_CASE("ItemArray", "[mesh]")
const Connectivity<2>& connectivity_2d = mesh_2d->connectivity();
- std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes();
+ std::array mesh_3d_list = MeshDataBaseForTests::get().all3DMeshes();
- for (const auto& named_mesh : mesh_list) {
- SECTION(named_mesh.name())
+ for (const auto& named_mesh_3d : mesh_3d_list) {
+ SECTION(named_mesh_3d.name())
{
- auto mesh_3d = named_mesh.mesh();
+ auto mesh_3d = named_mesh_3d.mesh();
const Connectivity<3>& connectivity_3d = mesh_3d->connectivity();
diff --git a/tests/test_ItemValue.cpp b/tests/test_ItemValue.cpp
index 4271db6c25f21dc7aa7db61d93d9280a22aaf561..e5643274772843499826d487279f1003be2f1c4a 100644
--- a/tests/test_ItemValue.cpp
+++ b/tests/test_ItemValue.cpp
@@ -311,12 +311,12 @@ TEST_CASE("ItemValue", "[mesh]")
const Connectivity<2>& connectivity_2d = mesh_2d->connectivity();
- std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes();
+ std::array mesh_3d_list = MeshDataBaseForTests::get().all3DMeshes();
- for (const auto& named_mesh : mesh_list) {
- SECTION(named_mesh.name())
+ for (const auto& named_mesh_3d : mesh_3d_list) {
+ SECTION(named_mesh_3d.name())
{
- auto mesh_3d = named_mesh.mesh();
+ auto mesh_3d = named_mesh_3d.mesh();
const Connectivity<3>& connectivity_3d = mesh_3d->connectivity();
diff --git a/tests/test_ListAffectationProcessor.cpp b/tests/test_ListAffectationProcessor.cpp
index 5910b3b4967acb846c11ff768ae4aa043772be57..73733b9833200f492c5e022ff1b727e57d104640 100644
--- a/tests/test_ListAffectationProcessor.cpp
+++ b/tests/test_ListAffectationProcessor.cpp
@@ -116,12 +116,6 @@ TEST_CASE("ListAffectationProcessor", "[language]")
SECTION("lists with tuples affectation")
{
- auto stringify = [](auto&& value) {
- std::ostringstream os;
- os << std::boolalpha << value;
- return os.str();
- };
-
SECTION("with (B)")
{
SECTION("from value")
diff --git a/tests/test_MathModule.cpp b/tests/test_MathModule.cpp
index 2cb3481b1e6cde7561733d8ea03decd46153db9d..f299d1e3678217d4fc6bcb4c08e417264b22a252 100644
--- a/tests/test_MathModule.cpp
+++ b/tests/test_MathModule.cpp
@@ -71,9 +71,9 @@ TEST_CASE("MathModule", "[language]")
{
arg = double{-3};
- DataVariant arg_variant = arg;
+ DataVariant double_arg_variant = arg;
- DataVariant result_variant = function_embedder.apply({arg_variant});
+ DataVariant result_variant = function_embedder.apply({double_arg_variant});
auto result = std::abs(arg);
diff --git a/tests/test_ParallelChecker_read.cpp b/tests/test_ParallelChecker_read.cpp
index 497e1729d7ed719749327bcf652cf43a29ecaa4e..233d37e34d1b8b9069d918ade3657f07c3b3ba38 100644
--- a/tests/test_ParallelChecker_read.cpp
+++ b/tests/test_ParallelChecker_read.cpp
@@ -311,19 +311,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- CellArray<double> arrays{connectivity, 1};
- arrays.fill(0);
+ CellArray<double> double_cell_array{connectivity, 1};
+ double_cell_array.fill(0);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data");
}
{
- CellArray<double> arrays{connectivity, 2};
- arrays.fill(0);
+ CellArray<double> double_cell_array{connectivity, 2};
+ double_cell_array.fill(0);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data");
}
{
@@ -395,16 +395,16 @@ TEST_CASE("ParallelChecker_read", "[dev]")
group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
.write_raw<int>(&(numbers[0]));
- Table<double> arrays{numbers.size(), 2};
+ Table<double> double_table{numbers.size(), 2};
for (size_t i = 0; i < numbers.size(); ++i) {
for (size_t j = 0; j < 2; ++j) {
- arrays[i][j] = std::sin(2 * numbers[i] + j);
+ double_table[i][j] = std::sin(2 * numbers[i] + j);
}
}
group
- .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(),
- arrays.numberOfColumns()}})
- .write_raw<double>(&(arrays(0, 0)));
+ .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{double_table.numberOfRows(),
+ double_table.numberOfColumns()}})
+ .write_raw<double>(&(double_table(0, 0)));
group.createAttribute("filename", source_location.filename());
group.createAttribute("line", source_location.line());
@@ -418,39 +418,39 @@ TEST_CASE("ParallelChecker_read", "[dev]")
ParallelCheckerTester pc_tester;
pc_tester.setTag(tag);
- CellArray<double> arrays{connectivity, 2};
+ CellArray<double> double_cell_array{connectivity, 2};
CellValue<const int> cell_number = connectivity.cellNumber();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
for (size_t j = 0; j < 2; ++j) {
- arrays[cell_id][j] = std::sin(2 * cell_number[cell_id] + j);
+ double_cell_array[cell_id][j] = std::sin(2 * cell_number[cell_id] + j);
}
}
- REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different name in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(double_cell_array, "not_sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source file in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin",
SourceLocation{"other-source-file", source_location.line(),
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source line in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin",
SourceLocation{source_location.filename(), source_location.line() + 100,
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source function in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin",
SourceLocation{source_location.filename(), source_location.line(),
source_location.column(), "foo"}));
if (parallel::size() > 1) {
- CellArray<double> not_sync = copy(arrays);
+ CellArray<double> not_sync = copy(double_cell_array);
CellValue<const bool> is_owned = connectivity.cellIsOwned();
if (parallel::rank() == 0) {
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
@@ -467,7 +467,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- CellArray<double> different = copy(arrays);
+ CellArray<double> different = copy(double_cell_array);
bool has_difference = false;
if (parallel::rank() == 0) {
CellValue<const bool> is_owned = connectivity.cellIsOwned();
@@ -495,11 +495,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- CellArray<double> arrays{connectivity, 1};
- arrays.fill(0);
+ CellArray<double> double_cell_array2{connectivity, 1};
+ double_cell_array2.fill(0);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(double_cell_array2, "sin", source_location), "error: cannot compare data");
}
{
@@ -630,21 +630,21 @@ TEST_CASE("ParallelChecker_read", "[dev]")
group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
.write_raw<int>(&(numbers[0]));
- Table<DataType> arrays{numbers.size(), 2};
- for (size_t i = 0; i < arrays.numberOfRows(); ++i) {
- for (size_t j = 0; j < arrays.numberOfColumns(); ++j) {
+ Table<DataType> dt_table{numbers.size(), 2};
+ for (size_t i = 0; i < dt_table.numberOfRows(); ++i) {
+ for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) {
for (size_t k = 0; k < DataType::NumberOfRows; ++k) {
for (size_t l = 0; l < DataType::NumberOfColumns; ++l) {
- arrays[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l);
+ dt_table[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l);
}
}
}
}
group
.createDataSet(name,
- HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}},
+ HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}},
test_TinyMatrixDataType<DataType>{})
- .template write_raw<double>(&(arrays[0][0](0, 0)), test_TinyMatrixDataType<DataType>{});
+ .template write_raw<double>(&(dt_table[0][0](0, 0)), test_TinyMatrixDataType<DataType>{});
group.createAttribute("filename", source_location.filename());
group.createAttribute("line", source_location.line());
@@ -658,43 +658,43 @@ TEST_CASE("ParallelChecker_read", "[dev]")
ParallelCheckerTester pc_tester;
pc_tester.setTag(tag);
- FaceArray<DataType> arrays{connectivity, 2};
+ FaceArray<DataType> dt_face_array{connectivity, 2};
FaceValue<const int> face_number = connectivity.faceNumber();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
- for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) {
+ for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) {
for (size_t k = 0; k < DataType::NumberOfRows; ++k) {
for (size_t l = 0; l < DataType::NumberOfColumns; ++l) {
- arrays[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l);
+ dt_face_array[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l);
}
}
}
}
- REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different name in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source file in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{"other-source-file", source_location.line(),
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source line in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{source_location.filename(), source_location.line() + 100,
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source function in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{source_location.filename(), source_location.line(),
source_location.column(), "foo"}));
if (parallel::size() > 1) {
- FaceArray<DataType> not_sync = copy(arrays);
+ FaceArray<DataType> not_sync = copy(dt_face_array);
FaceValue<const bool> is_owned = connectivity.faceIsOwned();
if (parallel::rank() == 0) {
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
@@ -711,7 +711,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- FaceArray<DataType> different = copy(arrays);
+ FaceArray<DataType> different = copy(dt_face_array);
bool has_difference = false;
if (parallel::rank() == 0) {
FaceValue<const bool> is_owned = connectivity.faceIsOwned();
@@ -739,11 +739,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- FaceArray<DataType> arrays{connectivity, 1};
- arrays.fill(zero);
+ FaceArray<DataType> dt_face_array2{connectivity, 1};
+ dt_face_array2.fill(zero);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data");
}
{
@@ -878,19 +878,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
.write_raw<int>(&(numbers[0]));
- Table<DataType> arrays{numbers.size(), 2};
- for (size_t i = 0; i < arrays.numberOfRows(); ++i) {
- for (size_t j = 0; j < arrays.numberOfColumns(); ++j) {
+ Table<DataType> dt_table{numbers.size(), 2};
+ for (size_t i = 0; i < dt_table.numberOfRows(); ++i) {
+ for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) {
for (size_t k = 0; k < DataType::Dimension; ++k) {
- arrays[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k);
+ dt_table[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k);
}
}
}
group
.createDataSet(name,
- HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}},
+ HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}},
test_TinyVectorDataType<DataType>{})
- .template write_raw<double>(&(arrays[0][0][0]), test_TinyVectorDataType<DataType>{});
+ .template write_raw<double>(&(dt_table[0][0][0]), test_TinyVectorDataType<DataType>{});
group.createAttribute("filename", source_location.filename());
group.createAttribute("line", source_location.line());
@@ -904,41 +904,41 @@ TEST_CASE("ParallelChecker_read", "[dev]")
ParallelCheckerTester pc_tester;
pc_tester.setTag(tag);
- FaceArray<DataType> arrays{connectivity, 2};
+ FaceArray<DataType> dt_face_array{connectivity, 2};
FaceValue<const int> face_number = connectivity.faceNumber();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
- for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) {
+ for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) {
for (size_t k = 0; k < DataType::Dimension; ++k) {
- arrays[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k);
+ dt_face_array[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k);
}
}
}
- REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different name in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source file in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{"other-source-file", source_location.line(),
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source line in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{source_location.filename(), source_location.line() + 100,
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source function in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{source_location.filename(), source_location.line(),
source_location.column(), "foo"}));
if (parallel::size() > 1) {
- FaceArray<DataType> not_sync = copy(arrays);
+ FaceArray<DataType> not_sync = copy(dt_face_array);
FaceValue<const bool> is_owned = connectivity.faceIsOwned();
if (parallel::rank() == 0) {
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
@@ -955,7 +955,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- FaceArray<DataType> different = copy(arrays);
+ FaceArray<DataType> different = copy(dt_face_array);
bool has_difference = false;
if (parallel::rank() == 0) {
FaceValue<const bool> is_owned = connectivity.faceIsOwned();
@@ -983,11 +983,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- FaceArray<DataType> arrays{connectivity, 1};
- arrays.fill(zero);
+ FaceArray<DataType> dt_face_array2{connectivity, 1};
+ dt_face_array2.fill(zero);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data");
}
{
@@ -1135,11 +1135,12 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- CellArrayPerNode<double> arrays{connectivity, 1};
- arrays.fill(0);
+ CellArrayPerNode<double> double_cell_array_per_node{connectivity, 1};
+ double_cell_array_per_node.fill(0);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(double_cell_array_per_node, "sin", source_location),
+ "error: cannot compare data");
}
{
@@ -1235,19 +1236,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
rows_map.size()}})
.write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0]));
- Table<double> arrays{rows_map[rows_map.size() - 1], 2};
+ Table<double> double_table{rows_map[rows_map.size() - 1], 2};
for (size_t i = 0; i < numbers.size(); ++i) {
for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) {
const size_t j = i_row - rows_map[i];
for (size_t k = 0; k < 2; ++k) {
- arrays[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j);
+ double_table[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j);
}
}
}
group
- .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(),
- arrays.numberOfColumns()}})
- .write_raw<double>(&(arrays(0, 0)));
+ .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{double_table.numberOfRows(),
+ double_table.numberOfColumns()}})
+ .write_raw<double>(&(double_table(0, 0)));
group.createAttribute("filename", source_location.filename());
group.createAttribute("line", source_location.line());
@@ -1264,41 +1265,41 @@ TEST_CASE("ParallelChecker_read", "[dev]")
auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
- NodeArrayPerCell<double> arrays{connectivity, 2};
+ NodeArrayPerCell<double> double_node_array_per_cell{connectivity, 2};
CellValue<const int> cell_number = connectivity.cellNumber();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
for (size_t j = 0; j < cell_to_node_matrix[cell_id].size(); ++j) {
for (size_t k = 0; k < 2; ++k) {
- arrays[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j);
+ double_node_array_per_cell[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j);
}
}
}
- REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different name in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "not_sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source file in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
SourceLocation{"other-source-file", source_location.line(),
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source line in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
SourceLocation{source_location.filename(), source_location.line() + 100,
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source function in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
SourceLocation{source_location.filename(), source_location.line(),
source_location.column(), "foo"}));
if (parallel::size() > 1) {
- NodeArrayPerCell<double> not_sync = copy(arrays);
+ NodeArrayPerCell<double> not_sync = copy(double_node_array_per_cell);
CellValue<const bool> is_owned = connectivity.cellIsOwned();
if (parallel::rank() == 0) {
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
@@ -1315,7 +1316,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- NodeArrayPerCell<double> different = copy(arrays);
+ NodeArrayPerCell<double> different = copy(double_node_array_per_cell);
bool has_difference = false;
if (parallel::rank() == 0) {
CellValue<const bool> is_owned = connectivity.cellIsOwned();
@@ -1343,11 +1344,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- CellArray<double> arrays{connectivity, 1};
- arrays.fill(0);
+ CellArray<double> double_cell_array{connectivity, 1};
+ double_cell_array.fill(0);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data");
}
{
@@ -1385,21 +1386,21 @@ TEST_CASE("ParallelChecker_read", "[dev]")
group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
.write_raw<int>(&(numbers[0]));
- Table<DataType> arrays{numbers.size(), 2};
- for (size_t i = 0; i < arrays.numberOfRows(); ++i) {
- for (size_t j = 0; j < arrays.numberOfColumns(); ++j) {
+ Table<DataType> dt_table{numbers.size(), 2};
+ for (size_t i = 0; i < dt_table.numberOfRows(); ++i) {
+ for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) {
for (size_t k = 0; k < DataType::NumberOfRows; ++k) {
for (size_t l = 0; l < DataType::NumberOfColumns; ++l) {
- arrays[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l);
+ dt_table[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l);
}
}
}
}
group
.createDataSet(name,
- HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}},
+ HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}},
test_TinyMatrixDataType<DataType>{})
- .template write_raw<double>(&(arrays[0][0](0, 0)), test_TinyMatrixDataType<DataType>{});
+ .template write_raw<double>(&(dt_table[0][0](0, 0)), test_TinyMatrixDataType<DataType>{});
group.createAttribute("filename", source_location.filename());
group.createAttribute("line", source_location.line());
@@ -1413,43 +1414,43 @@ TEST_CASE("ParallelChecker_read", "[dev]")
ParallelCheckerTester pc_tester;
pc_tester.setTag(tag);
- FaceArray<DataType> arrays{connectivity, 2};
+ FaceArray<DataType> dt_face_array{connectivity, 2};
FaceValue<const int> face_number = connectivity.faceNumber();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
- for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) {
+ for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) {
for (size_t k = 0; k < DataType::NumberOfRows; ++k) {
for (size_t l = 0; l < DataType::NumberOfColumns; ++l) {
- arrays[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l);
+ dt_face_array[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l);
}
}
}
}
- REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different name in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source file in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{"other-source-file", source_location.line(),
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source line in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{source_location.filename(), source_location.line() + 100,
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source function in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{source_location.filename(), source_location.line(),
source_location.column(), "foo"}));
if (parallel::size() > 1) {
- FaceArray<DataType> not_sync = copy(arrays);
+ FaceArray<DataType> not_sync = copy(dt_face_array);
FaceValue<const bool> is_owned = connectivity.faceIsOwned();
if (parallel::rank() == 0) {
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
@@ -1466,7 +1467,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- FaceArray<DataType> different = copy(arrays);
+ FaceArray<DataType> different = copy(dt_face_array);
bool has_difference = false;
if (parallel::rank() == 0) {
FaceValue<const bool> is_owned = connectivity.faceIsOwned();
@@ -1494,11 +1495,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- FaceArray<DataType> arrays{connectivity, 1};
- arrays.fill(zero);
+ FaceArray<DataType> dt_face_array2{connectivity, 1};
+ dt_face_array2.fill(zero);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data");
}
{
@@ -1644,11 +1645,12 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- CellArrayPerNode<double> arrays{connectivity, 1};
- arrays.fill(0);
+ CellArrayPerNode<double> double_cell_array_per_node{connectivity, 1};
+ double_cell_array_per_node.fill(0);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(double_cell_array_per_node, "sin", source_location),
+ "error: cannot compare data");
}
{
@@ -1740,19 +1742,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
.write_raw<int>(&(numbers[0]));
- Table<DataType> arrays{numbers.size(), 2};
- for (size_t i = 0; i < arrays.numberOfRows(); ++i) {
- for (size_t j = 0; j < arrays.numberOfColumns(); ++j) {
+ Table<DataType> dt_table{numbers.size(), 2};
+ for (size_t i = 0; i < dt_table.numberOfRows(); ++i) {
+ for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) {
for (size_t k = 0; k < DataType::Dimension; ++k) {
- arrays[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k);
+ dt_table[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k);
}
}
}
group
.createDataSet(name,
- HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}},
+ HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}},
test_TinyVectorDataType<DataType>{})
- .template write_raw<double>(&(arrays[0][0][0]), test_TinyVectorDataType<DataType>{});
+ .template write_raw<double>(&(dt_table[0][0][0]), test_TinyVectorDataType<DataType>{});
group.createAttribute("filename", source_location.filename());
group.createAttribute("line", source_location.line());
@@ -1766,41 +1768,41 @@ TEST_CASE("ParallelChecker_read", "[dev]")
ParallelCheckerTester pc_tester;
pc_tester.setTag(tag);
- FaceArray<DataType> arrays{connectivity, 2};
+ FaceArray<DataType> dt_face_array{connectivity, 2};
FaceValue<const int> face_number = connectivity.faceNumber();
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
- for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) {
+ for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) {
for (size_t k = 0; k < DataType::Dimension; ++k) {
- arrays[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k);
+ dt_face_array[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k);
}
}
}
- REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different name in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source file in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{"other-source-file", source_location.line(),
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source line in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{source_location.filename(), source_location.line() + 100,
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source function in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
SourceLocation{source_location.filename(), source_location.line(),
source_location.column(), "foo"}));
if (parallel::size() > 1) {
- FaceArray<DataType> not_sync = copy(arrays);
+ FaceArray<DataType> not_sync = copy(dt_face_array);
FaceValue<const bool> is_owned = connectivity.faceIsOwned();
if (parallel::rank() == 0) {
for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
@@ -1817,7 +1819,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- FaceArray<DataType> different = copy(arrays);
+ FaceArray<DataType> different = copy(dt_face_array);
bool has_difference = false;
if (parallel::rank() == 0) {
FaceValue<const bool> is_owned = connectivity.faceIsOwned();
@@ -1845,11 +1847,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- FaceArray<DataType> arrays{connectivity, 1};
- arrays.fill(zero);
+ FaceArray<DataType> dt_face_array2{connectivity, 1};
+ dt_face_array2.fill(zero);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data");
}
{
@@ -1890,19 +1892,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
rows_map.size()}})
.write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0]));
- Table<double> arrays{rows_map[rows_map.size() - 1], 2};
+ Table<double> double_table{rows_map[rows_map.size() - 1], 2};
for (size_t i = 0; i < numbers.size(); ++i) {
for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) {
const size_t j = i_row - rows_map[i];
for (size_t k = 0; k < 2; ++k) {
- arrays[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j);
+ double_table[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j);
}
}
}
group
- .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(),
- arrays.numberOfColumns()}})
- .write_raw<double>(&(arrays(0, 0)));
+ .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{double_table.numberOfRows(),
+ double_table.numberOfColumns()}})
+ .write_raw<double>(&(double_table(0, 0)));
group.createAttribute("filename", source_location.filename());
group.createAttribute("line", source_location.line());
@@ -1919,41 +1921,41 @@ TEST_CASE("ParallelChecker_read", "[dev]")
auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
- NodeArrayPerCell<double> arrays{connectivity, 2};
+ NodeArrayPerCell<double> double_node_array_per_cell{connectivity, 2};
CellValue<const int> cell_number = connectivity.cellNumber();
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
for (size_t j = 0; j < cell_to_node_matrix[cell_id].size(); ++j) {
for (size_t k = 0; k < 2; ++k) {
- arrays[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j);
+ double_node_array_per_cell[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j);
}
}
}
- REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different name in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "not_sin", source_location));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source file in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
SourceLocation{"other-source-file", source_location.line(),
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source line in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
SourceLocation{source_location.filename(), source_location.line() + 100,
source_location.column(), source_location.function()}));
pc_tester.setTag(tag);
UNSCOPED_INFO("can have different source function in ref");
- REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+ REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
SourceLocation{source_location.filename(), source_location.line(),
source_location.column(), "foo"}));
if (parallel::size() > 1) {
- NodeArrayPerCell<double> not_sync = copy(arrays);
+ NodeArrayPerCell<double> not_sync = copy(double_node_array_per_cell);
CellValue<const bool> is_owned = connectivity.cellIsOwned();
if (parallel::rank() == 0) {
for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
@@ -1970,7 +1972,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- NodeArrayPerCell<double> different = copy(arrays);
+ NodeArrayPerCell<double> different = copy(double_node_array_per_cell);
bool has_difference = false;
if (parallel::rank() == 0) {
CellValue<const bool> is_owned = connectivity.cellIsOwned();
@@ -1998,11 +2000,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
}
{
- CellArray<double> arrays{connectivity, 1};
- arrays.fill(0);
+ CellArray<double> double_cell_array{connectivity, 1};
+ double_cell_array.fill(0);
pc_tester.setTag(tag);
- REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+ REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data");
}
{
diff --git a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
index 39b5012700f9b8d8293829b4ccff65dad93036f6..f503eaac5865ac213c3140cae9b1afb9b30a33b7 100644
--- a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
@@ -105,11 +105,13 @@ TEST_CASE("PrimalToDiamondDualConnectivityDataMapper", "[mesh]")
primal_to_dual_connectivity_mapper.toDualCell(primal_edge_value, dual_from_primal_edge_value);
- bool is_same = true;
- for (CellId cell_id = 0; cell_id < primal_connectivity.numberOfCells(); ++cell_id) {
- is_same &= (dual_from_primal_edge_value[cell_id] == dual_from_primal_face_value[cell_id]);
+ {
+ bool is_same = true;
+ for (CellId cell_id = 0; cell_id < primal_connectivity.numberOfCells(); ++cell_id) {
+ is_same &= (dual_from_primal_edge_value[cell_id] == dual_from_primal_face_value[cell_id]);
+ }
+ REQUIRE(is_same);
}
- REQUIRE(is_same);
{
bool is_same = true;
diff --git a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
index 2950b0d40c9be3330aecc397e228b9e81bb08682..6a753b49fecf2b89f420b28f8c61411b01fe14df 100644
--- a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
@@ -178,13 +178,6 @@ TEST_CASE("PrimalToMedianDualConnectivityDataMapper", "[mesh]")
primal_edge_value[edge_id] = 2 + (primal_edge_to_cell_matrix[edge_id].size() == 1);
});
- NodeValue<size_t> primal_node_value{primal_connectivity};
- primal_node_value.fill(2);
-
- NodeValue<size_t> dual_from_primal_value{dual_connectivity};
- primal_to_dual_connectivity_mapper.toDualNode(primal_node_value, primal_edge_value, primal_cell_value,
- dual_from_primal_value);
-
{
const auto& dual_node_to_edge_matrix = dual_connectivity.nodeToEdgeMatrix();
auto dual_node_number = dual_connectivity.nodeNumber();
diff --git a/tests/test_SmallArray.cpp b/tests/test_SmallArray.cpp
index 2565ac0d7eb82beb828076840fda74d9b3ffbfa5..66191faa55c8890aae7901eacfe96cfd725da149 100644
--- a/tests/test_SmallArray.cpp
+++ b/tests/test_SmallArray.cpp
@@ -286,67 +286,67 @@ TEST_CASE("SmallArray", "[utils]")
SECTION("checking for SmallArray reductions")
{
- SmallArray<int> a(10);
- a[0] = 13;
- a[1] = 1;
- a[2] = 8;
- a[3] = -3;
- a[4] = 23;
- a[5] = -1;
- a[6] = 13;
- a[7] = 0;
- a[8] = 12;
- a[9] = 9;
+ SmallArray<int> array(10);
+ array[0] = 13;
+ array[1] = 1;
+ array[2] = 8;
+ array[3] = -3;
+ array[4] = 23;
+ array[5] = -1;
+ array[6] = 13;
+ array[7] = 0;
+ array[8] = 12;
+ array[9] = 9;
SECTION("Min")
{
- REQUIRE(min(a) == -3);
+ REQUIRE(min(array) == -3);
}
SECTION("Max")
{
- REQUIRE(max(a) == 23);
+ REQUIRE(max(array) == 23);
}
SECTION("Sum")
{
- REQUIRE((sum(a) == 75));
+ REQUIRE((sum(array) == 75));
}
SECTION("TinyVector Sum")
{
using N2 = TinyVector<2, int>;
- SmallArray<N2> b(10);
- b[0] = N2{13, 2};
- b[1] = N2{1, 3};
- b[2] = N2{8, -2};
- b[3] = N2{-3, 2};
- b[4] = N2{23, 4};
- b[5] = N2{-1, -3};
- b[6] = N2{13, 17};
- b[7] = N2{0, 9};
- b[8] = N2{12, 13};
- b[9] = N2{9, -17};
-
- REQUIRE((sum(b) == N2{75, 28}));
+ SmallArray<N2> N2_array(10);
+ N2_array[0] = N2{13, 2};
+ N2_array[1] = N2{1, 3};
+ N2_array[2] = N2{8, -2};
+ N2_array[3] = N2{-3, 2};
+ N2_array[4] = N2{23, 4};
+ N2_array[5] = N2{-1, -3};
+ N2_array[6] = N2{13, 17};
+ N2_array[7] = N2{0, 9};
+ N2_array[8] = N2{12, 13};
+ N2_array[9] = N2{9, -17};
+
+ REQUIRE((sum(N2_array) == N2{75, 28}));
}
SECTION("TinyMatrix Sum")
{
using N22 = TinyMatrix<2, 2, int>;
- SmallArray<N22> b(10);
- b[0] = N22{13, 2, 0, 1};
- b[1] = N22{1, 3, 6, 3};
- b[2] = N22{8, -2, -1, 21};
- b[3] = N22{-3, 2, 5, 12};
- b[4] = N22{23, 4, 7, 1};
- b[5] = N22{-1, -3, 33, 11};
- b[6] = N22{13, 17, 12, 13};
- b[7] = N22{0, 9, 1, 14};
- b[8] = N22{12, 13, -3, -71};
- b[9] = N22{9, -17, 0, 16};
-
- REQUIRE((sum(b) == N22{75, 28, 60, 21}));
+ SmallArray<N22> N22_array(10);
+ N22_array[0] = N22{13, 2, 0, 1};
+ N22_array[1] = N22{1, 3, 6, 3};
+ N22_array[2] = N22{8, -2, -1, 21};
+ N22_array[3] = N22{-3, 2, 5, 12};
+ N22_array[4] = N22{23, 4, 7, 1};
+ N22_array[5] = N22{-1, -3, 33, 11};
+ N22_array[6] = N22{13, 17, 12, 13};
+ N22_array[7] = N22{0, 9, 1, 14};
+ N22_array[8] = N22{12, 13, -3, -71};
+ N22_array[9] = N22{9, -17, 0, 16};
+
+ REQUIRE((sum(N22_array) == N22{75, 28, 60, 21}));
}
}
#endif // NDEBUG
diff --git a/tests/test_SmallMatrix.cpp b/tests/test_SmallMatrix.cpp
index 9712e13e330ee84adc55afeee1bcf81150312bc9..131b1e1f2fc4ae64622d410ac8e38ea051e9c9a7 100644
--- a/tests/test_SmallMatrix.cpp
+++ b/tests/test_SmallMatrix.cpp
@@ -364,53 +364,50 @@ TEST_CASE("SmallMatrix", "[algebra]")
SECTION("output with signaling NaN")
{
- SmallMatrix<double> A(2, 3);
- A(0, 0) = 1;
- A(0, 2) = 3;
- A(1, 0) = 2;
- std::ostringstream A_ost;
- A_ost << A;
+ SmallMatrix<double> C(2, 3);
+ C(0, 0) = 1;
+ C(0, 2) = 3;
+ C(1, 0) = 2;
+ std::ostringstream C_ost;
+ C_ost << C;
std::ostringstream ref_ost;
ref_ost << "0| 0:1 1:nan 2:3\n";
ref_ost << "1| 0:2 1:nan 2:nan\n";
- REQUIRE(A_ost.str() == ref_ost.str());
+ REQUIRE(C_ost.str() == ref_ost.str());
}
- // SECTION("checking for bounds violation")
- // {
- // REQUIRE_THROWS_AS(A(3, 0), AssertError);
- // REQUIRE_THROWS_AS(A(0, 4), AssertError);
-
- // REQUIRE_THROWS_AS(getMinor(A, 3, 0), AssertError);
- // REQUIRE_THROWS_AS(getMinor(A, 0, 4), AssertError);
-
- // const TinyMatrix<3, 4, int>& constA = A;
- // REQUIRE_THROWS_AS(constA(3, 0), AssertError);
- // REQUIRE_THROWS_AS(constA(0, 4), AssertError);
- // }
-
- // SECTION("checking for nan initialization")
- // {
- // TinyMatrix<3, 4, double> B;
-
- // for (size_t i = 0; i < B.numberOfRows(); ++i) {
- // for (size_t j = 0; j < B.numberOfColumns(); ++j) {
- // REQUIRE(std::isnan(B(i, j)));
- // }
- // }
- // }
-
- // SECTION("checking for bad initialization")
- // {
- // TinyMatrix<3, 4, int> B;
-
- // for (size_t i = 0; i < B.numberOfRows(); ++i) {
- // for (size_t j = 0; j < B.numberOfColumns(); ++j) {
- // REQUIRE(B(i, j) == std::numeric_limits<int>::max() / 2);
- // }
- // }
- // }
+ SECTION("checking for bounds violation")
+ {
+ REQUIRE_THROWS_AS(A(3, 0), AssertError);
+ REQUIRE_THROWS_AS(A(0, 4), AssertError);
+
+ const SmallMatrix<int>& constA = A;
+ REQUIRE_THROWS_AS(constA(3, 0), AssertError);
+ REQUIRE_THROWS_AS(constA(0, 4), AssertError);
+ }
+
+ SECTION("checking for nan initialization")
+ {
+ SmallMatrix<double> C(3, 4);
+
+ for (size_t i = 0; i < C.numberOfRows(); ++i) {
+ for (size_t j = 0; j < C.numberOfColumns(); ++j) {
+ REQUIRE(std::isnan(C(i, j)));
+ }
+ }
+ }
+
+ SECTION("checking for bad initialization")
+ {
+ SmallMatrix<int> C(3, 5);
+
+ for (size_t i = 0; i < C.numberOfRows(); ++i) {
+ for (size_t j = 0; j < C.numberOfColumns(); ++j) {
+ REQUIRE(C(i, j) == std::numeric_limits<int>::max() / 2);
+ }
+ }
+ }
#endif // NDEBUG
}
diff --git a/tests/test_Socket.cpp b/tests/test_Socket.cpp
index 3293f6b8d7fe18db31a0db1aaac0ae30474d8808..a4ca9f6a4186e7edf326b433b80bbd2117ecdee9 100644
--- a/tests/test_Socket.cpp
+++ b/tests/test_Socket.cpp
@@ -29,10 +29,10 @@ TEST_CASE("Socket", "[utils]")
Socket client = acceptClientSocket(server);
- size_t vector_size = [&] {
- size_t vector_size;
- read(client, vector_size);
- return vector_size;
+ const size_t vector_size = [&] {
+ size_t read_vector_size;
+ read(client, read_vector_size);
+ return read_vector_size;
}();
REQUIRE(vector_size == 4);
diff --git a/tests/test_TinyMatrix.cpp b/tests/test_TinyMatrix.cpp
index 03d3bbe5dc0ad69655cda5d3ae764d8e770b0d60..80159a021b54ebb162d339be2bbd5195aec815a0 100644
--- a/tests/test_TinyMatrix.cpp
+++ b/tests/test_TinyMatrix.cpp
@@ -173,18 +173,18 @@ TEST_CASE("TinyMatrix", "[algebra]")
SECTION("checking for cofactors")
{
- TinyMatrix<3, 3, int> A(1, 2, 3, 4, 5, 6, 7, 8, 9);
- REQUIRE(cofactor(A, 0, 0) == (5 * 9 - 8 * 6));
- REQUIRE(cofactor(A, 1, 0) == -(2 * 9 - 8 * 3));
- REQUIRE(cofactor(A, 2, 0) == (2 * 6 - 5 * 3));
-
- REQUIRE(cofactor(A, 0, 1) == -(4 * 9 - 7 * 6));
- REQUIRE(cofactor(A, 1, 1) == (1 * 9 - 7 * 3));
- REQUIRE(cofactor(A, 2, 1) == -(1 * 6 - 4 * 3));
-
- REQUIRE(cofactor(A, 0, 2) == (4 * 8 - 5 * 7));
- REQUIRE(cofactor(A, 1, 2) == -(1 * 8 - 7 * 2));
- REQUIRE(cofactor(A, 2, 2) == (1 * 5 - 4 * 2));
+ TinyMatrix<3, 3, int> square_A(1, 2, 3, 4, 5, 6, 7, 8, 9);
+ REQUIRE(cofactor(square_A, 0, 0) == (5 * 9 - 8 * 6));
+ REQUIRE(cofactor(square_A, 1, 0) == -(2 * 9 - 8 * 3));
+ REQUIRE(cofactor(square_A, 2, 0) == (2 * 6 - 5 * 3));
+
+ REQUIRE(cofactor(square_A, 0, 1) == -(4 * 9 - 7 * 6));
+ REQUIRE(cofactor(square_A, 1, 1) == (1 * 9 - 7 * 3));
+ REQUIRE(cofactor(square_A, 2, 1) == -(1 * 6 - 4 * 3));
+
+ REQUIRE(cofactor(square_A, 0, 2) == (4 * 8 - 5 * 7));
+ REQUIRE(cofactor(square_A, 1, 2) == -(1 * 8 - 7 * 2));
+ REQUIRE(cofactor(square_A, 2, 2) == (1 * 5 - 4 * 2));
}
SECTION("checking for determinant calculations")
@@ -294,17 +294,17 @@ TEST_CASE("TinyMatrix", "[algebra]")
#ifndef NDEBUG
SECTION("output with signaling NaN")
{
- TinyMatrix<2, 3> A;
- A(0, 0) = 1;
- A(0, 2) = 3;
- A(1, 0) = 2;
- std::ostringstream A_ost;
- A_ost << A;
+ TinyMatrix<2, 3> C;
+ C(0, 0) = 1;
+ C(0, 2) = 3;
+ C(1, 0) = 2;
+ std::ostringstream C_ost;
+ C_ost << C;
std::ostringstream ref_ost;
ref_ost << "[[1,nan,3],[2,nan,nan]]";
- REQUIRE(A_ost.str() == ref_ost.str());
+ REQUIRE(C_ost.str() == ref_ost.str());
}
SECTION("checking for bounds violation")
@@ -322,22 +322,22 @@ TEST_CASE("TinyMatrix", "[algebra]")
SECTION("checking for nan initialization")
{
- TinyMatrix<3, 4, double> B;
+ TinyMatrix<3, 4, double> C;
- for (size_t i = 0; i < B.numberOfRows(); ++i) {
- for (size_t j = 0; j < B.numberOfColumns(); ++j) {
- REQUIRE(std::isnan(B(i, j)));
+ for (size_t i = 0; i < C.numberOfRows(); ++i) {
+ for (size_t j = 0; j < C.numberOfColumns(); ++j) {
+ REQUIRE(std::isnan(C(i, j)));
}
}
}
SECTION("checking for bad initialization")
{
- TinyMatrix<3, 4, int> B;
+ TinyMatrix<3, 4, int> C;
- for (size_t i = 0; i < B.numberOfRows(); ++i) {
- for (size_t j = 0; j < B.numberOfColumns(); ++j) {
- REQUIRE(B(i, j) == std::numeric_limits<int>::max() / 2);
+ for (size_t i = 0; i < C.numberOfRows(); ++i) {
+ for (size_t j = 0; j < C.numberOfColumns(); ++j) {
+ REQUIRE(C(i, j) == std::numeric_limits<int>::max() / 2);
}
}
}
diff --git a/tests/test_TinyVector.cpp b/tests/test_TinyVector.cpp
index 6a3942e84b1c95680d8c63080b5c8b37330f139b..12abadf46f3952ee8cceb8b4e9aa4b33c4ee88ed 100644
--- a/tests/test_TinyVector.cpp
+++ b/tests/test_TinyVector.cpp
@@ -89,33 +89,33 @@ TEST_CASE("TinyVector", "[algebra]")
SECTION("min/max")
{
- TinyVector<5, int> u{1, 7, 6, 2, 9};
+ TinyVector<5, int> u1{1, 7, 6, 2, 9};
- REQUIRE(min(u) == 1);
- REQUIRE(max(u) == 9);
- REQUIRE(min(-u) == -9);
- REQUIRE(max(-u) == -1);
+ REQUIRE(min(u1) == 1);
+ REQUIRE(max(u1) == 9);
+ REQUIRE(min(-u1) == -9);
+ REQUIRE(max(-u1) == -1);
- TinyVector<5, int> v{1, 11, 6, -2, 9};
+ TinyVector<5, int> u2{1, 11, 6, -2, 9};
- REQUIRE(min(v) == -2);
- REQUIRE(max(v) == 11);
- REQUIRE(min(-v) == -11);
- REQUIRE(max(-v) == 2);
+ REQUIRE(min(u2) == -2);
+ REQUIRE(max(u2) == 11);
+ REQUIRE(min(-u2) == -11);
+ REQUIRE(max(-u2) == 2);
}
#ifndef NDEBUG
SECTION("output with signaling NaN")
{
- TinyVector<3> x;
- x[1] = 1;
- std::ostringstream x_ost;
- x_ost << x;
+ TinyVector<3> X;
+ X[1] = 1;
+ std::ostringstream X_ost;
+ X_ost << X;
std::ostringstream ref_ost;
ref_ost << "[nan,1,nan]";
- REQUIRE(x_ost.str() == ref_ost.str());
+ REQUIRE(X_ost.str() == ref_ost.str());
}
SECTION("checking for bounds validation")