diff --git a/.clang-format b/.clang-format
index d1ee229f96f6015a3294f87431b4e1f64e5042a3..93106905c3432b92683e6cf88486a79ad4007d1b 100644
--- a/.clang-format
+++ b/.clang-format
@@ -13,23 +13,41 @@ AllowShortCaseLabelsOnASingleLine: 'false'
AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: 'false'
AllowShortLoopsOnASingleLine: 'false'
+AlwaysBreakAfterDefinitionReturnType: TopLevel
AlwaysBreakAfterReturnType: AllDefinitions
AlwaysBreakBeforeMultilineStrings: 'false'
AlwaysBreakTemplateDeclarations: 'Yes'
BinPackArguments: 'true'
BinPackParameters: 'false'
BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Mozilla
+BreakBeforeBraces: Custom
+BraceWrapping:
+# AfterCaseLabel: false
+ AfterClass: true
+ AfterControlStatement: false
+ AfterEnum: true
+ AfterStruct: true
+ AfterFunction: true
+ AfterNamespace: true
+ AfterUnion: true
+ AfterExternBlock: true
+ BeforeCatch: true
+ BeforeElse: false
+ IndentBraces: false
+ SplitEmptyFunction: false
+
BreakConstructorInitializers: BeforeColon
-ColumnLimit: '80'
+ColumnLimit: '120'
CompactNamespaces: 'true'
ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
Cpp11BracedListStyle: 'true'
FixNamespaceComments: 'true'
+IndentCaseLabels: false
KeepEmptyLinesAtTheStartOfBlocks: 'false'
Language: Cpp
MaxEmptyLinesToKeep: '1'
NamespaceIndentation: None
+PenaltyBreakBeforeFirstCallParameter: 10000
PointerAlignment: Left
ReflowComments: 'true'
SortUsingDeclarations: 'true'
diff --git a/src/algebra/TinyMatrix.hpp b/src/algebra/TinyMatrix.hpp
index 2c504170186a17391a893533963ad1a8982b122b..4f4d6a97453be47214d656c075d62973a6f4adf1 100644
--- a/src/algebra/TinyMatrix.hpp
+++ b/src/algebra/TinyMatrix.hpp
@@ -226,8 +226,7 @@ class TinyMatrix
constexpr TinyMatrix&
operator=(const ZeroType&) noexcept
{
- static_assert(std::is_arithmetic<T>(),
- "Cannot assign 'zero' value for non-arithmetic types");
+ static_assert(std::is_arithmetic<T>(), "Cannot assign 'zero' value for non-arithmetic types");
for (size_t i = 0; i < N * N; ++i) {
m_values[i] = 0;
}
@@ -238,8 +237,7 @@ class TinyMatrix
constexpr TinyMatrix&
operator=(const IdentityType&) noexcept
{
- static_assert(std::is_arithmetic<T>(),
- "Cannot assign 'identity' value for non-arithmetic types");
+ static_assert(std::is_arithmetic<T>(), "Cannot assign 'identity' value for non-arithmetic types");
for (size_t i = 0; i < N; ++i) {
for (size_t j = 0; j < N; ++j) {
m_values[_index(i, j)] = (i == j) ? 1 : 0;
@@ -269,9 +267,8 @@ class TinyMatrix
PUGS_INLINE
constexpr TinyMatrix(const ZeroType&) noexcept
{
- static_assert(
- std::is_arithmetic<T>(),
- "Cannot construct from 'zero' value for non-arithmetic types");
+ static_assert(std::is_arithmetic<T>(), "Cannot construct from 'zero' value "
+ "for non-arithmetic types");
for (size_t i = 0; i < N * N; ++i) {
m_values[i] = 0;
}
@@ -280,9 +277,8 @@ class TinyMatrix
PUGS_INLINE
constexpr TinyMatrix(const IdentityType&) noexcept
{
- static_assert(
- std::is_arithmetic<T>(),
- "Cannot construct from 'identity' value for non-arithmetic types");
+ static_assert(std::is_arithmetic<T>(), "Cannot construct from 'identity' "
+ "value for non-arithmetic types");
for (size_t i = 0; i < N; ++i) {
for (size_t j = 0; j < N; ++j) {
m_values[_index(i, j)] = (i == j) ? 1 : 0;
@@ -317,11 +313,9 @@ template <size_t N, typename T>
PUGS_INLINE constexpr T
det(const TinyMatrix<N, T>& A)
{
- static_assert(std::is_arithmetic<T>::value,
- "determinent is not defined for non-arithmetic types");
- static_assert(std::is_floating_point<T>::value,
- "determinent for arbitrary dimension N is defined for floating "
- "point types only");
+ static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non-arithmetic types");
+ static_assert(std::is_floating_point<T>::value, "determinent for arbitrary dimension N is defined for floating "
+ "point types only");
TinyMatrix<N, T> M = A;
TinyVector<N, size_t> index;
@@ -366,8 +360,7 @@ template <typename T>
PUGS_INLINE constexpr T
det(const TinyMatrix<1, T>& A)
{
- static_assert(std::is_arithmetic<T>::value,
- "determinent is not defined for non-arithmetic types");
+ static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non-arithmetic types");
return A(0, 0);
}
@@ -375,8 +368,7 @@ template <typename T>
PUGS_INLINE constexpr T
det(const TinyMatrix<2, T>& A)
{
- static_assert(std::is_arithmetic<T>::value,
- "determinent is not defined for non-arithmetic types");
+ static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non-arithmetic types");
return A(0, 0) * A(1, 1) - A(1, 0) * A(0, 1);
}
@@ -384,10 +376,8 @@ template <typename T>
PUGS_INLINE constexpr T
det(const TinyMatrix<3, T>& A)
{
- static_assert(std::is_arithmetic<T>::value,
- "determinent is not defined for non-arithmetic types");
- return A(0, 0) * (A(1, 1) * A(2, 2) - A(2, 1) * A(1, 2)) -
- A(1, 0) * (A(0, 1) * A(2, 2) - A(2, 1) * A(0, 2)) +
+ static_assert(std::is_arithmetic<T>::value, "determinent is not defined for non-arithmetic types");
+ return A(0, 0) * (A(1, 1) * A(2, 2) - A(2, 1) * A(1, 2)) - A(1, 0) * (A(0, 1) * A(2, 2) - A(2, 1) * A(0, 2)) +
A(2, 0) * (A(0, 1) * A(1, 2) - A(1, 1) * A(0, 2));
}
@@ -424,10 +414,8 @@ template <typename T>
PUGS_INLINE constexpr TinyMatrix<1, T>
inverse(const TinyMatrix<1, T>& A)
{
- static_assert(std::is_arithmetic<T>::value,
- "inverse is not defined for non-arithmetic types");
- static_assert(std::is_floating_point<T>::value,
- "inverse is defined for floating point types only");
+ static_assert(std::is_arithmetic<T>::value, "inverse is not defined for non-arithmetic types");
+ static_assert(std::is_floating_point<T>::value, "inverse is defined for floating point types only");
TinyMatrix<1, T> A_1(1. / A(0, 0));
return std::move(A_1);
@@ -437,8 +425,7 @@ template <size_t N, typename T>
PUGS_INLINE constexpr T
cofactor(const TinyMatrix<N, T>& A, const size_t& i, const size_t& j)
{
- static_assert(std::is_arithmetic<T>::value,
- "cofactor is not defined for non-arithmetic types");
+ static_assert(std::is_arithmetic<T>::value, "cofactor is not defined for non-arithmetic types");
const T sign = ((i + j) % 2) ? -1 : 1;
return sign * det(getMinor(A, i, j));
@@ -448,10 +435,8 @@ template <typename T>
PUGS_INLINE constexpr TinyMatrix<2, T>
inverse(const TinyMatrix<2, T>& A)
{
- static_assert(std::is_arithmetic<T>::value,
- "inverse is not defined for non-arithmetic types");
- static_assert(std::is_floating_point<T>::value,
- "inverse is defined for floating point types only");
+ static_assert(std::is_arithmetic<T>::value, "inverse is not defined for non-arithmetic types");
+ static_assert(std::is_floating_point<T>::value, "inverse is defined for floating point types only");
const T determinent = det(A);
const T inv_determinent = 1. / determinent;
@@ -464,17 +449,14 @@ template <typename T>
PUGS_INLINE constexpr TinyMatrix<3, T>
inverse(const TinyMatrix<3, T>& A)
{
- static_assert(std::is_arithmetic<T>::value,
- "inverse is not defined for non-arithmetic types");
- static_assert(std::is_floating_point<T>::value,
- "inverse is defined for floating point types only");
+ static_assert(std::is_arithmetic<T>::value, "inverse is not defined for non-arithmetic types");
+ static_assert(std::is_floating_point<T>::value, "inverse is defined for floating point types only");
const T determinent = det(A);
- TinyMatrix<3, T> A_cofactors_T(
- cofactor(A, 0, 0), cofactor(A, 1, 0), cofactor(A, 2, 0), cofactor(A, 0, 1),
- cofactor(A, 1, 1), cofactor(A, 2, 1), cofactor(A, 0, 2), cofactor(A, 1, 2),
- cofactor(A, 2, 2));
+ TinyMatrix<3, T> A_cofactors_T(cofactor(A, 0, 0), cofactor(A, 1, 0), cofactor(A, 2, 0), cofactor(A, 0, 1),
+ cofactor(A, 1, 1), cofactor(A, 2, 1), cofactor(A, 0, 2), cofactor(A, 1, 2),
+ cofactor(A, 2, 2));
return std::move(A_cofactors_T *= 1. / determinent);
}
diff --git a/src/algebra/TinyVector.hpp b/src/algebra/TinyVector.hpp
index f49c83de7815307eef8838960709c5d69176d4ba..ba4db3f02dca387ccdb435cd2634a2c4eb8016e3 100644
--- a/src/algebra/TinyVector.hpp
+++ b/src/algebra/TinyVector.hpp
@@ -202,8 +202,7 @@ class TinyVector
constexpr TinyVector&
operator=(const ZeroType&) noexcept
{
- static_assert(std::is_arithmetic<T>(),
- "Cannot assign 'zero' value for non-arithmetic types");
+ static_assert(std::is_arithmetic<T>(), "Cannot assign 'zero' value for non-arithmetic types");
for (size_t i = 0; i < N; ++i) {
m_values[i] = 0;
}
@@ -231,9 +230,8 @@ class TinyVector
PUGS_INLINE
constexpr TinyVector(const ZeroType&) noexcept
{
- static_assert(
- std::is_arithmetic<T>(),
- "Cannot construct from 'zero' value for non-arithmetic types");
+ static_assert(std::is_arithmetic<T>(), "Cannot construct from 'zero' value "
+ "for non-arithmetic types");
for (size_t i = 0; i < N; ++i) {
m_values[i] = 0;
}
@@ -253,10 +251,8 @@ template <size_t N, typename T>
PUGS_INLINE constexpr T
l2Norm(const TinyVector<N, T>& x)
{
- static_assert(std::is_arithmetic<T>(),
- "Cannot compute L2 norm for non-arithmetic types");
- static_assert(std::is_floating_point<T>::value,
- "L2 norm is defined for floating point types only");
+ static_assert(std::is_arithmetic<T>(), "Cannot compute L2 norm for non-arithmetic types");
+ static_assert(std::is_floating_point<T>::value, "L2 norm is defined for floating point types only");
return std::sqrt((x, x));
}
@@ -265,9 +261,7 @@ template <typename T>
PUGS_INLINE constexpr TinyVector<3, T>
crossProduct(const TinyVector<3, T>& u, const TinyVector<3, T>& v)
{
- TinyVector<3, T> cross_product(u[1] * v[2] - u[2] * v[1],
- u[2] * v[0] - u[0] * v[2],
- u[0] * v[1] - u[1] * v[0]);
+ TinyVector<3, T> cross_product(u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]);
return std::move(cross_product);
}
diff --git a/src/language/PugsParser.cpp b/src/language/PugsParser.cpp
index ed2be7c163de9ec37bff8205039001d1f0805e07..ae98aecdf50799e61aff1e9b607862acaa092f38 100644
--- a/src/language/PugsParser.cpp
+++ b/src/language/PugsParser.cpp
@@ -1,15 +1,15 @@
+#include <PugsOStream.hpp>
#include <PugsParser.hpp>
-#include <iostream>
#include <rang.hpp>
-#define TAO_PEGTL_NAMESPACE language
#include <pegtl.hpp>
#include <pegtl/analyze.hpp>
-namespace language {
-using namespace language;
+using namespace TAO_PEGTL_NAMESPACE;
+namespace language
+{
// clang-format off
struct comment
@@ -60,13 +60,21 @@ struct real
struct REAL : seq< real, ignored >{};
-struct expression : sor< REAL, INTEGER > {};
+struct IDENTIFIER : seq <identifier, ignored> {};
+
+struct expression : sor< REAL, INTEGER , IDENTIFIER> {};
+
+struct EXPRESSION : seq< expression, ignored> {};
+
+struct binary_op
+ : seq< EXPRESSION , one< '+' >, EXPRESSION> {};
struct semicol : one< ';' >{};
struct SEMICOL : seq< semicol , ignored > {};
struct instruction
- : sor<seq< expression , SEMICOL>,
+ : sor<seq< expression , SEMICOL >,
+ seq< binary_op, SEMICOL >,
SEMICOL>
{};
@@ -75,36 +83,51 @@ struct grammar
// clang-format on
template <typename Rule>
-struct my_action : nothing<Rule>
-{};
+struct action : nothing<Rule>
+{
+};
+
+template <>
+struct action<integer>
+{
+ template <typename Input>
+ static void
+ apply(const Input& in, std::string& v)
+ {
+ v += std::string("I:") + in.string() + std::string(" ;\n");
+ }
+};
+
+template <>
+struct action<real>
+{
+ template <typename Input>
+ static void
+ apply(const Input& in, std::string& v)
+ {
+ v += std::string("R:") + in.string() + std::string(" ;\n");
+ }
+};
template <>
-struct my_action<integer>
+struct action<identifier>
{
template <typename Input>
static void
apply(const Input& in, std::string& v)
{
- if (v.size() > 0) {
- v += std::string(", I:") + in.string();
- } else {
- v = std::string("I:") + in.string();
- }
+ v += std::string("S:") + in.string() + std::string(" ;\n");
}
};
template <>
-struct my_action<real>
+struct action<binary_op>
{
template <typename Input>
static void
apply(const Input& in, std::string& v)
{
- if (v.size() > 0) {
- v += std::string(", R:") + in.string();
- } else {
- v = std::string("R:") + in.string();
- }
+ v += "binary_op(" + in.string() + std::string(") ;\n");
}
};
@@ -125,8 +148,7 @@ template <typename Rule>
const std::string errors<Rule>::error_message = "parse error...";
template <>
-const std::string errors<eolf>::error_message =
- "parse error expecting expression";
+const std::string errors<eolf>::error_message = "parse error expecting expression";
} // namespace language
@@ -135,26 +157,28 @@ parser(const std::string& filename)
{
std::string name;
- const size_t grammar_issues = language::analyze<language::grammar>();
+ const size_t grammar_issues = analyze<language::grammar>();
- std::cout << "grammar_issues=" << grammar_issues << '\n';
- language::read_input in(filename);
+ pout() << rang::fgB::yellow << "grammar_issues=" << rang::fg::reset << grammar_issues << '\n';
+
+ pout() << rang::style::bold << "Parsing file " << rang::style::reset << rang::style::underline << filename
+ << rang::style::reset << " ...\n\n";
+
+ read_input in(filename);
try {
- language::parse<language::grammar,
- language::my_action //, language::errors
- >(in, name);
- } catch (const language::parse_error& e) {
+ parse<language::grammar,
+ language::action //, language::errors
+ >(in, name);
+ }
+ catch (const parse_error& e) {
const auto p = e.positions.front();
- std::cerr << rang::style::bold << p.source << ':' << p.line << ':'
- << p.byte_in_line << ": " << rang::style::reset << rang::fgB::red
- << "error: " << rang::fg::reset << rang::style::bold << e.what()
- << rang::style::reset << '\n'
- << in.line_at(p) << '\n'
- << std::string(p.byte_in_line, ' ') << rang::fgB::yellow << '^'
- << rang::fg::reset << std::endl;
+ perr() << rang::style::bold << p.source << ':' << p.line << ':' << p.byte_in_line << ": " << rang::style::reset
+ << rang::fgB::red << "error: " << rang::fg::reset << rang::style::bold << e.what() << rang::style::reset
+ << '\n'
+ << in.line_at(p) << '\n'
+ << std::string(p.byte_in_line, ' ') << rang::fgB::yellow << '^' << rang::fg::reset << std::endl;
std::exit(1);
}
- std::cout << "Good bye, " << name << "!" << std::endl;
- std::exit(0);
+ pout() << "Parsed:\n" << name << std::endl;
}
diff --git a/src/main.cpp b/src/main.cpp
index 83d73a54d64437eb3a8fcb1cc561a0db0f9f52c2..a08658afed41b499c930f256cedf44d1592f4851 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -45,8 +45,7 @@ main(int argc, char* argv[])
SynchronizerManager::create();
if (filename != "") {
- pout() << "Reading (gmsh) " << rang::style::underline << filename
- << rang::style::reset << " ...\n";
+ pout() << "Reading (gmsh) " << rang::style::underline << filename << rang::style::reset << " ...\n";
Timer gmsh_timer;
gmsh_timer.reset();
GmshReader gmsh_reader(filename);
@@ -55,396 +54,343 @@ main(int argc, char* argv[])
std::shared_ptr<IMesh> p_mesh = gmsh_reader.mesh();
switch (p_mesh->dimension()) {
- case 1: {
- std::vector<std::string> sym_boundary_name_list = {"XMIN", "XMAX"};
- std::vector<std::shared_ptr<BoundaryConditionDescriptor>>
- bc_descriptor_list;
- for (const auto& sym_boundary_name : sym_boundary_name_list) {
- std::shared_ptr<BoundaryDescriptor> boudary_descriptor =
- std::shared_ptr<BoundaryDescriptor>(
- new NamedBoundaryDescriptor(sym_boundary_name));
- SymmetryBoundaryConditionDescriptor* sym_bc_descriptor =
- new SymmetryBoundaryConditionDescriptor(boudary_descriptor);
-
- bc_descriptor_list.push_back(
- std::shared_ptr<BoundaryConditionDescriptor>(sym_bc_descriptor));
- }
+ case 1: {
+ std::vector<std::string> sym_boundary_name_list = {"XMIN", "XMAX"};
+ std::vector<std::shared_ptr<BoundaryConditionDescriptor>> bc_descriptor_list;
+ for (const auto& sym_boundary_name : sym_boundary_name_list) {
+ std::shared_ptr<BoundaryDescriptor> boudary_descriptor =
+ std::shared_ptr<BoundaryDescriptor>(new NamedBoundaryDescriptor(sym_boundary_name));
+ SymmetryBoundaryConditionDescriptor* sym_bc_descriptor =
+ new SymmetryBoundaryConditionDescriptor(boudary_descriptor);
+
+ bc_descriptor_list.push_back(std::shared_ptr<BoundaryConditionDescriptor>(sym_bc_descriptor));
+ }
- using ConnectivityType = Connectivity1D;
- using MeshType = Mesh<ConnectivityType>;
- using MeshDataType = MeshData<MeshType>;
- using UnknownsType = FiniteVolumesEulerUnknowns<MeshDataType>;
-
- const MeshType& mesh =
- dynamic_cast<const MeshType&>(*gmsh_reader.mesh());
-
- Timer timer;
- timer.reset();
- MeshDataType mesh_data(mesh);
-
- std::vector<BoundaryConditionHandler> bc_list;
- {
- for (const auto& bc_descriptor : bc_descriptor_list) {
- switch (bc_descriptor->type()) {
- case BoundaryConditionDescriptor::Type::symmetry: {
- const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor =
- dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(
- *bc_descriptor);
- for (size_t i_ref_node_list = 0;
- i_ref_node_list <
- mesh.connectivity().numberOfRefItemList<ItemType::node>();
- ++i_ref_node_list) {
- const RefNodeList& ref_node_list =
- mesh.connectivity().refItemList<ItemType::node>(
- i_ref_node_list);
- const RefId& ref = ref_node_list.refId();
- if (ref == sym_bc_descriptor.boundaryDescriptor()) {
- SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc =
- new SymmetryBoundaryCondition<MeshType::Dimension>(
- MeshFlatNodeBoundary<MeshType::Dimension>(
- mesh, ref_node_list));
- std::shared_ptr<
- SymmetryBoundaryCondition<MeshType::Dimension>>
- bc(sym_bc);
- bc_list.push_back(BoundaryConditionHandler(bc));
- }
- }
- break;
- }
- default: {
- perr() << "Unknown BCDescription\n";
- std::exit(1);
+ using ConnectivityType = Connectivity1D;
+ using MeshType = Mesh<ConnectivityType>;
+ using MeshDataType = MeshData<MeshType>;
+ using UnknownsType = FiniteVolumesEulerUnknowns<MeshDataType>;
+
+ const MeshType& mesh = dynamic_cast<const MeshType&>(*gmsh_reader.mesh());
+
+ Timer timer;
+ timer.reset();
+ MeshDataType mesh_data(mesh);
+
+ std::vector<BoundaryConditionHandler> bc_list;
+ {
+ for (const auto& bc_descriptor : bc_descriptor_list) {
+ switch (bc_descriptor->type()) {
+ case BoundaryConditionDescriptor::Type::symmetry: {
+ const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor =
+ dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(*bc_descriptor);
+ for (size_t i_ref_node_list = 0;
+ i_ref_node_list < mesh.connectivity().numberOfRefItemList<ItemType::node>(); ++i_ref_node_list) {
+ const RefNodeList& ref_node_list = mesh.connectivity().refItemList<ItemType::node>(i_ref_node_list);
+ const RefId& ref = ref_node_list.refId();
+ if (ref == sym_bc_descriptor.boundaryDescriptor()) {
+ SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc =
+ new SymmetryBoundaryCondition<MeshType::Dimension>(
+ MeshFlatNodeBoundary<MeshType::Dimension>(mesh, ref_node_list));
+ std::shared_ptr<SymmetryBoundaryCondition<MeshType::Dimension>> bc(sym_bc);
+ bc_list.push_back(BoundaryConditionHandler(bc));
}
}
+ break;
+ }
+ default: {
+ perr() << "Unknown BCDescription\n";
+ std::exit(1);
+ }
}
}
+ }
- UnknownsType unknowns(mesh_data);
+ UnknownsType unknowns(mesh_data);
- unknowns.initializeSod();
+ unknowns.initializeSod();
- AcousticSolver<MeshDataType> acoustic_solver(mesh_data, bc_list);
+ AcousticSolver<MeshDataType> acoustic_solver(mesh_data, bc_list);
- using Rd = TinyVector<MeshType::Dimension>;
+ using Rd = TinyVector<MeshType::Dimension>;
- const CellValue<const double>& Vj = mesh_data.Vj();
+ const CellValue<const double>& Vj = mesh_data.Vj();
- const double tmax = 0.2;
- double t = 0;
+ const double tmax = 0.2;
+ double t = 0;
- int itermax = std::numeric_limits<int>::max();
- int iteration = 0;
+ int itermax = std::numeric_limits<int>::max();
+ int iteration = 0;
- CellValue<double>& rhoj = unknowns.rhoj();
- CellValue<double>& ej = unknowns.ej();
- CellValue<double>& pj = unknowns.pj();
- CellValue<double>& gammaj = unknowns.gammaj();
- CellValue<double>& cj = unknowns.cj();
+ CellValue<double>& rhoj = unknowns.rhoj();
+ CellValue<double>& ej = unknowns.ej();
+ CellValue<double>& pj = unknowns.pj();
+ CellValue<double>& gammaj = unknowns.gammaj();
+ CellValue<double>& cj = unknowns.cj();
- BlockPerfectGas block_eos(rhoj, ej, pj, gammaj, cj);
+ BlockPerfectGas block_eos(rhoj, ej, pj, gammaj, cj);
- VTKWriter vtk_writer("mesh", 0.01);
+ VTKWriter vtk_writer("mesh", 0.01);
- while ((t < tmax) and (iteration < itermax)) {
- vtk_writer.write(
- mesh,
- {NamedItemValue{"density", rhoj},
- NamedItemValue{"velocity", unknowns.uj()},
- NamedItemValue{"coords", mesh.xr()},
- NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
- NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
- t);
- double dt = 0.4 * acoustic_solver.acoustic_dt(Vj, cj);
- if (t + dt > tmax) {
- dt = tmax - t;
- }
- acoustic_solver.computeNextStep(t, dt, unknowns);
+ while ((t < tmax) and (iteration < itermax)) {
+ vtk_writer.write(mesh,
+ {NamedItemValue{"density", rhoj}, NamedItemValue{"velocity", unknowns.uj()},
+ NamedItemValue{"coords", mesh.xr()},
+ NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
+ NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
+ t);
+ double dt = 0.4 * acoustic_solver.acoustic_dt(Vj, cj);
+ if (t + dt > tmax) {
+ dt = tmax - t;
+ }
+ acoustic_solver.computeNextStep(t, dt, unknowns);
- block_eos.updatePandCFromRhoE();
+ block_eos.updatePandCFromRhoE();
- t += dt;
- ++iteration;
- }
- vtk_writer.write(
- mesh,
- {NamedItemValue{"density", rhoj},
- NamedItemValue{"velocity", unknowns.uj()},
- NamedItemValue{"coords", mesh.xr()},
- NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
- NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
- t, true); // forces last output
-
- pout() << "* " << rang::style::underline << "Final time"
- << rang::style::reset << ": " << rang::fgB::green << t
- << rang::fg::reset << " (" << iteration << " iterations)\n";
-
- method_cost_map["AcousticSolverWithMesh"] = timer.seconds();
-
- { // gnuplot output for density
- const CellValue<const Rd>& xj = mesh_data.xj();
- const CellValue<const double>& rhoj = unknowns.rhoj();
- std::ofstream fout("rho");
- for (CellId j = 0; j < mesh.numberOfCells(); ++j) {
- fout << xj[j][0] << ' ' << rhoj[j] << '\n';
- }
+ t += dt;
+ ++iteration;
+ }
+ vtk_writer.write(mesh,
+ {NamedItemValue{"density", rhoj}, NamedItemValue{"velocity", unknowns.uj()},
+ NamedItemValue{"coords", mesh.xr()},
+ NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
+ NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
+ t, true); // forces last output
+
+ pout() << "* " << rang::style::underline << "Final time" << rang::style::reset << ": " << rang::fgB::green << t
+ << rang::fg::reset << " (" << iteration << " iterations)\n";
+
+ method_cost_map["AcousticSolverWithMesh"] = timer.seconds();
+
+ { // gnuplot output for density
+ const CellValue<const Rd>& xj = mesh_data.xj();
+ const CellValue<const double>& rhoj = unknowns.rhoj();
+ std::ofstream fout("rho");
+ for (CellId j = 0; j < mesh.numberOfCells(); ++j) {
+ fout << xj[j][0] << ' ' << rhoj[j] << '\n';
}
+ }
- break;
+ break;
+ }
+ case 2: {
+ // test case boundary condition description
+ std::vector<std::string> sym_boundary_name_list = {"XMIN", "XMAX", "YMIN", "YMAX"};
+ std::vector<std::shared_ptr<BoundaryConditionDescriptor>> bc_descriptor_list;
+ for (const auto& sym_boundary_name : sym_boundary_name_list) {
+ std::shared_ptr<BoundaryDescriptor> boudary_descriptor =
+ std::shared_ptr<BoundaryDescriptor>(new NamedBoundaryDescriptor(sym_boundary_name));
+ SymmetryBoundaryConditionDescriptor* sym_bc_descriptor =
+ new SymmetryBoundaryConditionDescriptor(boudary_descriptor);
+
+ bc_descriptor_list.push_back(std::shared_ptr<BoundaryConditionDescriptor>(sym_bc_descriptor));
}
- case 2: {
- // test case boundary condition description
- std::vector<std::string> sym_boundary_name_list = {"XMIN", "XMAX",
- "YMIN", "YMAX"};
- std::vector<std::shared_ptr<BoundaryConditionDescriptor>>
- bc_descriptor_list;
- for (const auto& sym_boundary_name : sym_boundary_name_list) {
- std::shared_ptr<BoundaryDescriptor> boudary_descriptor =
- std::shared_ptr<BoundaryDescriptor>(
- new NamedBoundaryDescriptor(sym_boundary_name));
- SymmetryBoundaryConditionDescriptor* sym_bc_descriptor =
- new SymmetryBoundaryConditionDescriptor(boudary_descriptor);
-
- bc_descriptor_list.push_back(
- std::shared_ptr<BoundaryConditionDescriptor>(sym_bc_descriptor));
- }
- using ConnectivityType = Connectivity2D;
- using MeshType = Mesh<ConnectivityType>;
- using MeshDataType = MeshData<MeshType>;
- using UnknownsType = FiniteVolumesEulerUnknowns<MeshDataType>;
-
- const MeshType& mesh =
- dynamic_cast<const MeshType&>(*gmsh_reader.mesh());
-
- Timer timer;
- timer.reset();
- MeshDataType mesh_data(mesh);
-
- std::vector<BoundaryConditionHandler> bc_list;
- {
- for (const auto& bc_descriptor : bc_descriptor_list) {
- switch (bc_descriptor->type()) {
- case BoundaryConditionDescriptor::Type::symmetry: {
- const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor =
- dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(
- *bc_descriptor);
- for (size_t i_ref_face_list = 0;
- i_ref_face_list <
- mesh.connectivity().numberOfRefItemList<ItemType::face>();
- ++i_ref_face_list) {
- const RefFaceList& ref_face_list =
- mesh.connectivity().refItemList<ItemType::face>(
- i_ref_face_list);
- const RefId& ref = ref_face_list.refId();
- if (ref == sym_bc_descriptor.boundaryDescriptor()) {
- SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc =
- new SymmetryBoundaryCondition<MeshType::Dimension>(
- MeshFlatNodeBoundary<MeshType::Dimension>(
- mesh, ref_face_list));
- std::shared_ptr<
- SymmetryBoundaryCondition<MeshType::Dimension>>
- bc(sym_bc);
- bc_list.push_back(BoundaryConditionHandler(bc));
- }
- }
- break;
- }
- default: {
- perr() << "Unknown BCDescription\n";
- std::exit(1);
+ using ConnectivityType = Connectivity2D;
+ using MeshType = Mesh<ConnectivityType>;
+ using MeshDataType = MeshData<MeshType>;
+ using UnknownsType = FiniteVolumesEulerUnknowns<MeshDataType>;
+
+ const MeshType& mesh = dynamic_cast<const MeshType&>(*gmsh_reader.mesh());
+
+ Timer timer;
+ timer.reset();
+ MeshDataType mesh_data(mesh);
+
+ std::vector<BoundaryConditionHandler> bc_list;
+ {
+ for (const auto& bc_descriptor : bc_descriptor_list) {
+ switch (bc_descriptor->type()) {
+ case BoundaryConditionDescriptor::Type::symmetry: {
+ const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor =
+ dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(*bc_descriptor);
+ for (size_t i_ref_face_list = 0;
+ i_ref_face_list < mesh.connectivity().numberOfRefItemList<ItemType::face>(); ++i_ref_face_list) {
+ const RefFaceList& ref_face_list = mesh.connectivity().refItemList<ItemType::face>(i_ref_face_list);
+ const RefId& ref = ref_face_list.refId();
+ if (ref == sym_bc_descriptor.boundaryDescriptor()) {
+ SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc =
+ new SymmetryBoundaryCondition<MeshType::Dimension>(
+ MeshFlatNodeBoundary<MeshType::Dimension>(mesh, ref_face_list));
+ std::shared_ptr<SymmetryBoundaryCondition<MeshType::Dimension>> bc(sym_bc);
+ bc_list.push_back(BoundaryConditionHandler(bc));
}
}
+ break;
+ }
+ default: {
+ perr() << "Unknown BCDescription\n";
+ std::exit(1);
+ }
}
}
+ }
- UnknownsType unknowns(mesh_data);
+ UnknownsType unknowns(mesh_data);
- unknowns.initializeSod();
+ unknowns.initializeSod();
- AcousticSolver<MeshDataType> acoustic_solver(mesh_data, bc_list);
+ AcousticSolver<MeshDataType> acoustic_solver(mesh_data, bc_list);
- const CellValue<const double>& Vj = mesh_data.Vj();
+ const CellValue<const double>& Vj = mesh_data.Vj();
- const double tmax = 0.2;
- double t = 0;
+ const double tmax = 0.2;
+ double t = 0;
- int itermax = std::numeric_limits<int>::max();
- int iteration = 0;
+ int itermax = std::numeric_limits<int>::max();
+ int iteration = 0;
- CellValue<double>& rhoj = unknowns.rhoj();
- CellValue<double>& ej = unknowns.ej();
- CellValue<double>& pj = unknowns.pj();
- CellValue<double>& gammaj = unknowns.gammaj();
- CellValue<double>& cj = unknowns.cj();
+ CellValue<double>& rhoj = unknowns.rhoj();
+ CellValue<double>& ej = unknowns.ej();
+ CellValue<double>& pj = unknowns.pj();
+ CellValue<double>& gammaj = unknowns.gammaj();
+ CellValue<double>& cj = unknowns.cj();
- BlockPerfectGas block_eos(rhoj, ej, pj, gammaj, cj);
+ BlockPerfectGas block_eos(rhoj, ej, pj, gammaj, cj);
- VTKWriter vtk_writer("mesh", 0.01);
+ VTKWriter vtk_writer("mesh", 0.01);
- while ((t < tmax) and (iteration < itermax)) {
- vtk_writer.write(
- mesh,
- {NamedItemValue{"density", rhoj},
- NamedItemValue{"velocity", unknowns.uj()},
- NamedItemValue{"coords", mesh.xr()},
- NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
- NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
- t);
- double dt = 0.4 * acoustic_solver.acoustic_dt(Vj, cj);
- if (t + dt > tmax) {
- dt = tmax - t;
- }
- acoustic_solver.computeNextStep(t, dt, unknowns);
+ while ((t < tmax) and (iteration < itermax)) {
+ vtk_writer.write(mesh,
+ {NamedItemValue{"density", rhoj}, NamedItemValue{"velocity", unknowns.uj()},
+ NamedItemValue{"coords", mesh.xr()},
+ NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
+ NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
+ t);
+ double dt = 0.4 * acoustic_solver.acoustic_dt(Vj, cj);
+ if (t + dt > tmax) {
+ dt = tmax - t;
+ }
+ acoustic_solver.computeNextStep(t, dt, unknowns);
- block_eos.updatePandCFromRhoE();
+ block_eos.updatePandCFromRhoE();
- t += dt;
- ++iteration;
- }
- vtk_writer.write(
- mesh,
- {NamedItemValue{"density", rhoj},
- NamedItemValue{"velocity", unknowns.uj()},
- NamedItemValue{"coords", mesh.xr()},
- NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
- NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
- t, true); // forces last output
-
- pout() << "* " << rang::style::underline << "Final time"
- << rang::style::reset << ": " << rang::fgB::green << t
- << rang::fg::reset << " (" << iteration << " iterations)\n";
-
- method_cost_map["AcousticSolverWithMesh"] = timer.seconds();
- break;
+ t += dt;
+ ++iteration;
+ }
+ vtk_writer.write(mesh,
+ {NamedItemValue{"density", rhoj}, NamedItemValue{"velocity", unknowns.uj()},
+ NamedItemValue{"coords", mesh.xr()},
+ NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
+ NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
+ t, true); // forces last output
+
+ pout() << "* " << rang::style::underline << "Final time" << rang::style::reset << ": " << rang::fgB::green << t
+ << rang::fg::reset << " (" << iteration << " iterations)\n";
+
+ method_cost_map["AcousticSolverWithMesh"] = timer.seconds();
+ break;
+ }
+ case 3: {
+ std::vector<std::string> sym_boundary_name_list = {"XMIN", "XMAX", "YMIN", "YMAX", "ZMIN", "ZMAX"};
+ std::vector<std::shared_ptr<BoundaryConditionDescriptor>> bc_descriptor_list;
+ for (const auto& sym_boundary_name : sym_boundary_name_list) {
+ std::shared_ptr<BoundaryDescriptor> boudary_descriptor =
+ std::shared_ptr<BoundaryDescriptor>(new NamedBoundaryDescriptor(sym_boundary_name));
+ SymmetryBoundaryConditionDescriptor* sym_bc_descriptor =
+ new SymmetryBoundaryConditionDescriptor(boudary_descriptor);
+
+ bc_descriptor_list.push_back(std::shared_ptr<BoundaryConditionDescriptor>(sym_bc_descriptor));
}
- case 3: {
- std::vector<std::string> sym_boundary_name_list = {
- "XMIN", "XMAX", "YMIN", "YMAX", "ZMIN", "ZMAX"};
- std::vector<std::shared_ptr<BoundaryConditionDescriptor>>
- bc_descriptor_list;
- for (const auto& sym_boundary_name : sym_boundary_name_list) {
- std::shared_ptr<BoundaryDescriptor> boudary_descriptor =
- std::shared_ptr<BoundaryDescriptor>(
- new NamedBoundaryDescriptor(sym_boundary_name));
- SymmetryBoundaryConditionDescriptor* sym_bc_descriptor =
- new SymmetryBoundaryConditionDescriptor(boudary_descriptor);
-
- bc_descriptor_list.push_back(
- std::shared_ptr<BoundaryConditionDescriptor>(sym_bc_descriptor));
- }
- using ConnectivityType = Connectivity3D;
- using MeshType = Mesh<ConnectivityType>;
- using MeshDataType = MeshData<MeshType>;
- using UnknownsType = FiniteVolumesEulerUnknowns<MeshDataType>;
-
- const MeshType& mesh =
- dynamic_cast<const MeshType&>(*gmsh_reader.mesh());
-
- Timer timer;
- timer.reset();
- MeshDataType mesh_data(mesh);
-
- std::vector<BoundaryConditionHandler> bc_list;
- {
- for (const auto& bc_descriptor : bc_descriptor_list) {
- switch (bc_descriptor->type()) {
- case BoundaryConditionDescriptor::Type::symmetry: {
- const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor =
- dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(
- *bc_descriptor);
- for (size_t i_ref_face_list = 0;
- i_ref_face_list <
- mesh.connectivity().numberOfRefItemList<ItemType::face>();
- ++i_ref_face_list) {
- const RefFaceList& ref_face_list =
- mesh.connectivity().refItemList<ItemType::face>(
- i_ref_face_list);
- const RefId& ref = ref_face_list.refId();
- if (ref == sym_bc_descriptor.boundaryDescriptor()) {
- SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc =
- new SymmetryBoundaryCondition<MeshType::Dimension>(
- MeshFlatNodeBoundary<MeshType::Dimension>(
- mesh, ref_face_list));
- std::shared_ptr<
- SymmetryBoundaryCondition<MeshType::Dimension>>
- bc(sym_bc);
- bc_list.push_back(BoundaryConditionHandler(bc));
- }
- }
- break;
- }
- default: {
- perr() << "Unknown BCDescription\n";
- std::exit(1);
+ using ConnectivityType = Connectivity3D;
+ using MeshType = Mesh<ConnectivityType>;
+ using MeshDataType = MeshData<MeshType>;
+ using UnknownsType = FiniteVolumesEulerUnknowns<MeshDataType>;
+
+ const MeshType& mesh = dynamic_cast<const MeshType&>(*gmsh_reader.mesh());
+
+ Timer timer;
+ timer.reset();
+ MeshDataType mesh_data(mesh);
+
+ std::vector<BoundaryConditionHandler> bc_list;
+ {
+ for (const auto& bc_descriptor : bc_descriptor_list) {
+ switch (bc_descriptor->type()) {
+ case BoundaryConditionDescriptor::Type::symmetry: {
+ const SymmetryBoundaryConditionDescriptor& sym_bc_descriptor =
+ dynamic_cast<const SymmetryBoundaryConditionDescriptor&>(*bc_descriptor);
+ for (size_t i_ref_face_list = 0;
+ i_ref_face_list < mesh.connectivity().numberOfRefItemList<ItemType::face>(); ++i_ref_face_list) {
+ const RefFaceList& ref_face_list = mesh.connectivity().refItemList<ItemType::face>(i_ref_face_list);
+ const RefId& ref = ref_face_list.refId();
+ if (ref == sym_bc_descriptor.boundaryDescriptor()) {
+ SymmetryBoundaryCondition<MeshType::Dimension>* sym_bc =
+ new SymmetryBoundaryCondition<MeshType::Dimension>(
+ MeshFlatNodeBoundary<MeshType::Dimension>(mesh, ref_face_list));
+ std::shared_ptr<SymmetryBoundaryCondition<MeshType::Dimension>> bc(sym_bc);
+ bc_list.push_back(BoundaryConditionHandler(bc));
}
}
+ break;
+ }
+ default: {
+ perr() << "Unknown BCDescription\n";
+ std::exit(1);
+ }
}
}
+ }
- UnknownsType unknowns(mesh_data);
-
- unknowns.initializeSod();
+ UnknownsType unknowns(mesh_data);
- AcousticSolver<MeshDataType> acoustic_solver(mesh_data, bc_list);
+ unknowns.initializeSod();
- const CellValue<const double>& Vj = mesh_data.Vj();
+ AcousticSolver<MeshDataType> acoustic_solver(mesh_data, bc_list);
- const double tmax = 0.2;
- double t = 0;
+ const CellValue<const double>& Vj = mesh_data.Vj();
- int itermax = std::numeric_limits<int>::max();
- int iteration = 0;
+ const double tmax = 0.2;
+ double t = 0;
- CellValue<double>& rhoj = unknowns.rhoj();
- CellValue<double>& ej = unknowns.ej();
- CellValue<double>& pj = unknowns.pj();
- CellValue<double>& gammaj = unknowns.gammaj();
- CellValue<double>& cj = unknowns.cj();
+ int itermax = std::numeric_limits<int>::max();
+ int iteration = 0;
- BlockPerfectGas block_eos(rhoj, ej, pj, gammaj, cj);
+ CellValue<double>& rhoj = unknowns.rhoj();
+ CellValue<double>& ej = unknowns.ej();
+ CellValue<double>& pj = unknowns.pj();
+ CellValue<double>& gammaj = unknowns.gammaj();
+ CellValue<double>& cj = unknowns.cj();
- VTKWriter vtk_writer("mesh", 0.01);
+ BlockPerfectGas block_eos(rhoj, ej, pj, gammaj, cj);
- while ((t < tmax) and (iteration < itermax)) {
- vtk_writer.write(
- mesh,
- {NamedItemValue{"density", rhoj},
- NamedItemValue{"velocity", unknowns.uj()},
- NamedItemValue{"coords", mesh.xr()},
- NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
- NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
- t);
- double dt = 0.4 * acoustic_solver.acoustic_dt(Vj, cj);
- if (t + dt > tmax) {
- dt = tmax - t;
- }
- acoustic_solver.computeNextStep(t, dt, unknowns);
- block_eos.updatePandCFromRhoE();
+ VTKWriter vtk_writer("mesh", 0.01);
- t += dt;
- ++iteration;
+ while ((t < tmax) and (iteration < itermax)) {
+ vtk_writer.write(mesh,
+ {NamedItemValue{"density", rhoj}, NamedItemValue{"velocity", unknowns.uj()},
+ NamedItemValue{"coords", mesh.xr()},
+ NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
+ NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
+ t);
+ double dt = 0.4 * acoustic_solver.acoustic_dt(Vj, cj);
+ if (t + dt > tmax) {
+ dt = tmax - t;
}
- vtk_writer.write(
- mesh,
- {NamedItemValue{"density", rhoj},
- NamedItemValue{"velocity", unknowns.uj()},
- NamedItemValue{"coords", mesh.xr()},
- NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
- NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
- t, true); // forces last output
-
- pout() << "* " << rang::style::underline << "Final time"
- << rang::style::reset << ": " << rang::fgB::green << t
- << rang::fg::reset << " (" << iteration << " iterations)\n";
-
- method_cost_map["AcousticSolverWithMesh"] = timer.seconds();
- break;
+ acoustic_solver.computeNextStep(t, dt, unknowns);
+ block_eos.updatePandCFromRhoE();
+
+ t += dt;
+ ++iteration;
}
+ vtk_writer.write(mesh,
+ {NamedItemValue{"density", rhoj}, NamedItemValue{"velocity", unknowns.uj()},
+ NamedItemValue{"coords", mesh.xr()},
+ NamedItemValue{"cell_owner", mesh.connectivity().cellOwner()},
+ NamedItemValue{"node_owner", mesh.connectivity().nodeOwner()}},
+ t, true); // forces last output
+
+ pout() << "* " << rang::style::underline << "Final time" << rang::style::reset << ": " << rang::fgB::green << t
+ << rang::fg::reset << " (" << iteration << " iterations)\n";
+
+ method_cost_map["AcousticSolverWithMesh"] = timer.seconds();
+ break;
+ }
}
- pout() << "* " << rang::fgB::red << "Could not be uglier!"
- << rang::fg::reset << " (" << __FILE__ << ':' << __LINE__ << ")\n";
+ pout() << "* " << rang::fgB::red << "Could not be uglier!" << rang::fg::reset << " (" << __FILE__ << ':' << __LINE__
+ << ")\n";
} else {
perr() << "Connectivity1D defined by number of nodes no more implemented\n";
@@ -461,10 +407,8 @@ main(int argc, char* argv[])
}
for (const auto& method_cost : method_cost_map) {
- pout() << "* [" << rang::fgB::cyan << std::setw(size) << std::left
- << method_cost.first << rang::fg::reset
- << "] Execution time: " << rang::style::bold << method_cost.second
- << rang::style::reset << '\n';
+ pout() << "* [" << rang::fgB::cyan << std::setw(size) << std::left << method_cost.first << rang::fg::reset
+ << "] Execution time: " << rang::style::bold << method_cost.second << rang::style::reset << '\n';
}
return 0;
diff --git a/src/mesh/CellType.hpp b/src/mesh/CellType.hpp
index 875ecd6bfc83ed55ad116319e4d18adb3e74a156..c0949ffbe27d6017b0c46a7e21cea188ea6c4abf 100644
--- a/src/mesh/CellType.hpp
+++ b/src/mesh/CellType.hpp
@@ -22,22 +22,22 @@ std::string_view
name(const CellType& cell_type)
{
switch (cell_type) {
- case CellType::Line:
- return "line";
- case CellType::Triangle:
- return "triangle";
- case CellType::Quadrangle:
- return "quadrangle";
- case CellType::Tetrahedron:
- return "tetrahedron";
- case CellType::Pyramid:
- return "pyramid";
- case CellType::Prism:
- return "prism";
- case CellType::Hexahedron:
- return "hexahedron";
- default:
- return "unknown cell type";
+ case CellType::Line:
+ return "line";
+ case CellType::Triangle:
+ return "triangle";
+ case CellType::Quadrangle:
+ return "quadrangle";
+ case CellType::Tetrahedron:
+ return "tetrahedron";
+ case CellType::Pyramid:
+ return "pyramid";
+ case CellType::Prism:
+ return "prism";
+ case CellType::Hexahedron:
+ return "hexahedron";
+ default:
+ return "unknown cell type";
}
}
diff --git a/src/mesh/Connectivity.cpp b/src/mesh/Connectivity.cpp
index 946933e8fc54720448e680bfb6455777edc9d597..632726a16c1993d986758562fcdf5f7c44ec832c 100644
--- a/src/mesh/Connectivity.cpp
+++ b/src/mesh/Connectivity.cpp
@@ -13,28 +13,21 @@ template <size_t Dimension>
void
Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
{
- Assert(descriptor.cell_to_node_vector.size() ==
- descriptor.cell_type_vector.size());
- Assert(descriptor.cell_number_vector.size() ==
- descriptor.cell_type_vector.size());
+ Assert(descriptor.cell_to_node_vector.size() == descriptor.cell_type_vector.size());
+ Assert(descriptor.cell_number_vector.size() == descriptor.cell_type_vector.size());
if constexpr (Dimension > 1) {
- Assert(descriptor.cell_to_face_vector.size() ==
- descriptor.cell_type_vector.size());
- Assert(descriptor.face_to_node_vector.size() ==
- descriptor.face_number_vector.size());
- Assert(descriptor.face_owner_vector.size() ==
- descriptor.face_number_vector.size());
+ Assert(descriptor.cell_to_face_vector.size() == descriptor.cell_type_vector.size());
+ Assert(descriptor.face_to_node_vector.size() == descriptor.face_number_vector.size());
+ Assert(descriptor.face_owner_vector.size() == descriptor.face_number_vector.size());
}
- auto& cell_to_node_matrix =
- m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::node)];
- cell_to_node_matrix = descriptor.cell_to_node_vector;
+ auto& cell_to_node_matrix = m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::node)];
+ cell_to_node_matrix = descriptor.cell_to_node_vector;
{
WeakCellValue<CellType> cell_type(*this);
- parallel_for(this->numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- cell_type[j] = descriptor.cell_type_vector[j];
- });
+ parallel_for(
+ this->numberOfCells(), PUGS_LAMBDA(const CellId& j) { cell_type[j] = descriptor.cell_type_vector[j]; });
m_cell_type = cell_type;
}
@@ -53,9 +46,8 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
{
WeakCellValue<int> cell_global_index(*this);
int first_index = 0;
- parallel_for(this->numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- cell_global_index[j] = first_index + j;
- });
+ parallel_for(
+ this->numberOfCells(), PUGS_LAMBDA(const CellId& j) { cell_global_index[j] = first_index + j; });
m_cell_global_index = cell_global_index;
}
@@ -68,9 +60,8 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
{
const int rank = parallel::rank();
WeakCellValue<bool> cell_is_owned(*this);
- parallel_for(this->numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- cell_is_owned[j] = (m_cell_owner[j] == rank);
- });
+ parallel_for(
+ this->numberOfCells(), PUGS_LAMBDA(const CellId& j) { cell_is_owned[j] = (m_cell_owner[j] == rank); });
m_cell_is_owned = cell_is_owned;
}
@@ -83,30 +74,23 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
{
const int rank = parallel::rank();
WeakNodeValue<bool> node_is_owned(*this);
- parallel_for(this->numberOfNodes(), PUGS_LAMBDA(const NodeId& r) {
- node_is_owned[r] = (m_node_owner[r] == rank);
- });
+ parallel_for(
+ this->numberOfNodes(), PUGS_LAMBDA(const NodeId& r) { node_is_owned[r] = (m_node_owner[r] == rank); });
m_node_is_owned = node_is_owned;
}
- m_ref_node_list_vector =
- descriptor.template refItemListVector<ItemType::node>();
- m_ref_cell_list_vector =
- descriptor.template refItemListVector<ItemType::cell>();
+ m_ref_node_list_vector = descriptor.template refItemListVector<ItemType::node>();
+ m_ref_cell_list_vector = descriptor.template refItemListVector<ItemType::cell>();
if constexpr (Dimension > 1) {
- m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::node)] =
- descriptor.face_to_node_vector;
+ m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::node)] = descriptor.face_to_node_vector;
- m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::face)] =
- descriptor.cell_to_face_vector;
+ m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::face)] = descriptor.cell_to_face_vector;
{
FaceValuePerCell<bool> cell_face_is_reversed(*this);
- for (CellId j = 0; j < descriptor.cell_face_is_reversed_vector.size();
- ++j) {
- const auto& face_cells_vector =
- descriptor.cell_face_is_reversed_vector[j];
+ for (CellId j = 0; j < descriptor.cell_face_is_reversed_vector.size(); ++j) {
+ const auto& face_cells_vector = descriptor.cell_face_is_reversed_vector[j];
for (unsigned short lj = 0; lj < face_cells_vector.size(); ++lj) {
cell_face_is_reversed(j, lj) = face_cells_vector[lj];
}
@@ -129,31 +113,24 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
{
const int rank = parallel::rank();
WeakFaceValue<bool> face_is_owned(*this);
- parallel_for(this->numberOfFaces(), PUGS_LAMBDA(const FaceId& l) {
- face_is_owned[l] = (m_face_owner[l] == rank);
- });
+ parallel_for(
+ this->numberOfFaces(), PUGS_LAMBDA(const FaceId& l) { face_is_owned[l] = (m_face_owner[l] == rank); });
m_face_is_owned = face_is_owned;
}
- m_ref_face_list_vector =
- descriptor.template refItemListVector<ItemType::face>();
+ m_ref_face_list_vector = descriptor.template refItemListVector<ItemType::face>();
if constexpr (Dimension > 2) {
- m_item_to_item_matrix[itemTId(ItemType::edge)][itemTId(ItemType::node)] =
- descriptor.edge_to_node_vector;
+ m_item_to_item_matrix[itemTId(ItemType::edge)][itemTId(ItemType::node)] = descriptor.edge_to_node_vector;
- m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::edge)] =
- descriptor.face_to_edge_vector;
+ m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::edge)] = descriptor.face_to_edge_vector;
- m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::edge)] =
- descriptor.cell_to_edge_vector;
+ m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::edge)] = descriptor.cell_to_edge_vector;
{
EdgeValuePerFace<bool> face_edge_is_reversed(*this);
- for (FaceId l = 0; l < descriptor.face_edge_is_reversed_vector.size();
- ++l) {
- const auto& edge_faces_vector =
- descriptor.face_edge_is_reversed_vector[l];
+ for (FaceId l = 0; l < descriptor.face_edge_is_reversed_vector.size(); ++l) {
+ const auto& edge_faces_vector = descriptor.face_edge_is_reversed_vector[l];
for (unsigned short el = 0; el < edge_faces_vector.size(); ++el) {
face_edge_is_reversed(l, el) = edge_faces_vector[el];
}
@@ -176,14 +153,12 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
{
const int rank = parallel::rank();
WeakEdgeValue<bool> edge_is_owned(*this);
- parallel_for(this->numberOfEdges(), PUGS_LAMBDA(const EdgeId& e) {
- edge_is_owned[e] = (m_edge_owner[e] == rank);
- });
+ parallel_for(
+ this->numberOfEdges(), PUGS_LAMBDA(const EdgeId& e) { edge_is_owned[e] = (m_edge_owner[e] == rank); });
m_edge_is_owned = edge_is_owned;
}
- m_ref_edge_list_vector =
- descriptor.template refItemListVector<ItemType::edge>();
+ m_ref_edge_list_vector = descriptor.template refItemListVector<ItemType::edge>();
}
}
}
diff --git a/src/mesh/Connectivity.hpp b/src/mesh/Connectivity.hpp
index 7d37e41435f32653cbbd4db87c6e2155fcddced3..1b815cdd023e066f4c8f4ee7fd0e058459da81e2 100644
--- a/src/mesh/Connectivity.hpp
+++ b/src/mesh/Connectivity.hpp
@@ -43,8 +43,7 @@ class Connectivity final : public IConnectivity
{
public:
PUGS_INLINE
- static std::shared_ptr<Connectivity<Dim>> build(
- const ConnectivityDescriptor&);
+ static std::shared_ptr<Connectivity<Dim>> build(const ConnectivityDescriptor&);
private:
constexpr static auto& itemTId = ItemTypeId<Dim>::itemTId;
@@ -85,33 +84,21 @@ class Connectivity final : public IConnectivity
WeakFaceValuePerCell<const bool> m_cell_face_is_reversed;
WeakEdgeValuePerFace<const bool> m_face_edge_is_reversed;
- WeakNodeValuePerCell<const unsigned short>
- m_cell_local_numbers_in_their_nodes;
- WeakEdgeValuePerCell<const unsigned short>
- m_cell_local_numbers_in_their_edges;
- WeakFaceValuePerCell<const unsigned short>
- m_cell_local_numbers_in_their_faces;
-
- WeakCellValuePerFace<const unsigned short>
- m_face_local_numbers_in_their_cells;
- WeakEdgeValuePerFace<const unsigned short>
- m_face_local_numbers_in_their_edges;
- WeakNodeValuePerFace<const unsigned short>
- m_face_local_numbers_in_their_nodes;
-
- WeakCellValuePerEdge<const unsigned short>
- m_edge_local_numbers_in_their_cells;
- WeakFaceValuePerEdge<const unsigned short>
- m_edge_local_numbers_in_their_faces;
- WeakNodeValuePerEdge<const unsigned short>
- m_edge_local_numbers_in_their_nodes;
-
- WeakCellValuePerNode<const unsigned short>
- m_node_local_numbers_in_their_cells;
- WeakEdgeValuePerNode<const unsigned short>
- m_node_local_numbers_in_their_edges;
- WeakFaceValuePerNode<const unsigned short>
- m_node_local_numbers_in_their_faces;
+ WeakNodeValuePerCell<const unsigned short> m_cell_local_numbers_in_their_nodes;
+ WeakEdgeValuePerCell<const unsigned short> m_cell_local_numbers_in_their_edges;
+ WeakFaceValuePerCell<const unsigned short> m_cell_local_numbers_in_their_faces;
+
+ WeakCellValuePerFace<const unsigned short> m_face_local_numbers_in_their_cells;
+ WeakEdgeValuePerFace<const unsigned short> m_face_local_numbers_in_their_edges;
+ WeakNodeValuePerFace<const unsigned short> m_face_local_numbers_in_their_nodes;
+
+ WeakCellValuePerEdge<const unsigned short> m_edge_local_numbers_in_their_cells;
+ WeakFaceValuePerEdge<const unsigned short> m_edge_local_numbers_in_their_faces;
+ WeakNodeValuePerEdge<const unsigned short> m_edge_local_numbers_in_their_nodes;
+
+ WeakCellValuePerNode<const unsigned short> m_node_local_numbers_in_their_cells;
+ WeakEdgeValuePerNode<const unsigned short> m_node_local_numbers_in_their_edges;
+ WeakFaceValuePerNode<const unsigned short> m_node_local_numbers_in_their_faces;
ConnectivityComputer m_connectivity_computer;
@@ -126,15 +113,12 @@ class Connectivity final : public IConnectivity
template <typename SubItemValuePerItemType>
PUGS_INLINE const SubItemValuePerItemType&
- _lazzyBuildItemNumberInTheirChild(
- const SubItemValuePerItemType& sub_item_value_per_item) const
+ _lazzyBuildItemNumberInTheirChild(const SubItemValuePerItemType& sub_item_value_per_item) const
{
- using ReversedItemOfItem =
- typename SubItemValuePerItemType::ItemOfItemType::Reversed;
+ using ReversedItemOfItem = typename SubItemValuePerItemType::ItemOfItemType::Reversed;
if (not sub_item_value_per_item.isBuilt()) {
const_cast<SubItemValuePerItemType&>(sub_item_value_per_item) =
- m_connectivity_computer
- .computeLocalItemNumberInChildItem<ReversedItemOfItem>(*this);
+ m_connectivity_computer.computeLocalItemNumberInChildItem<ReversedItemOfItem>(*this);
}
return sub_item_value_per_item;
}
@@ -145,12 +129,10 @@ class Connectivity final : public IConnectivity
const ConnectivityMatrix&
_getMatrix(const ItemType& item_type_0, const ItemType& item_type_1) const
{
- const ConnectivityMatrix& connectivity_matrix =
- m_item_to_item_matrix[itemTId(item_type_0)][itemTId(item_type_1)];
+ const ConnectivityMatrix& connectivity_matrix = m_item_to_item_matrix[itemTId(item_type_0)][itemTId(item_type_1)];
if (not connectivity_matrix.isBuilt()) {
const_cast<ConnectivityMatrix&>(connectivity_matrix) =
- m_connectivity_computer.computeConnectivityMatrix(*this, item_type_0,
- item_type_1);
+ m_connectivity_computer.computeConnectivityMatrix(*this, item_type_0, item_type_1);
}
return connectivity_matrix;
}
@@ -304,19 +286,16 @@ class Connectivity final : public IConnectivity
PUGS_INLINE
const bool&
- isConnectivityMatrixBuilt(const ItemType& item_type_0,
- const ItemType& item_type_1) const
+ isConnectivityMatrixBuilt(const ItemType& item_type_0, const ItemType& item_type_1) const
{
- const ConnectivityMatrix& connectivity_matrix =
- m_item_to_item_matrix[itemTId(item_type_0)][itemTId(item_type_1)];
+ const ConnectivityMatrix& connectivity_matrix = m_item_to_item_matrix[itemTId(item_type_0)][itemTId(item_type_1)];
return connectivity_matrix.isBuilt();
}
template <ItemType source_item_type, ItemType target_item_type>
PUGS_INLINE auto
getItemToItemMatrix() const
{
- return ItemToItemMatrix<source_item_type, target_item_type>(
- _getMatrix(source_item_type, target_item_type));
+ return ItemToItemMatrix<source_item_type, target_item_type>(_getMatrix(source_item_type, target_item_type));
}
PUGS_INLINE
@@ -407,8 +386,7 @@ class Connectivity final : public IConnectivity
const auto&
cellFaceIsReversed() const
{
- static_assert(Dimension > 1,
- "reversed faces makes no sense in dimension 1");
+ static_assert(Dimension > 1, "reversed faces makes no sense in dimension 1");
return m_cell_face_is_reversed;
}
@@ -416,8 +394,7 @@ class Connectivity final : public IConnectivity
const auto&
faceEdgeIsReversed() const
{
- static_assert(Dimension > 2,
- "reversed edges makes no sense in dimension 1 or 2");
+ static_assert(Dimension > 2, "reversed edges makes no sense in dimension 1 or 2");
return m_face_edge_is_reversed;
}
@@ -425,8 +402,7 @@ class Connectivity final : public IConnectivity
const auto&
cellLocalNumbersInTheirNodes() const
{
- return _lazzyBuildItemNumberInTheirChild(
- m_cell_local_numbers_in_their_nodes);
+ return _lazzyBuildItemNumberInTheirChild(m_cell_local_numbers_in_their_nodes);
}
PUGS_INLINE
@@ -434,8 +410,7 @@ class Connectivity final : public IConnectivity
cellLocalNumbersInTheirEdges() const
{
if constexpr (Dimension > 2) {
- return _lazzyBuildItemNumberInTheirChild(
- m_cell_local_numbers_in_their_edges);
+ return _lazzyBuildItemNumberInTheirChild(m_cell_local_numbers_in_their_edges);
} else {
return cellLocalNumbersInTheirFaces();
}
@@ -446,8 +421,7 @@ class Connectivity final : public IConnectivity
cellLocalNumbersInTheirFaces() const
{
if constexpr (Dimension > 1) {
- return _lazzyBuildItemNumberInTheirChild(
- m_cell_local_numbers_in_their_faces);
+ return _lazzyBuildItemNumberInTheirChild(m_cell_local_numbers_in_their_faces);
} else {
return cellLocalNumbersInTheirNodes();
}
@@ -458,8 +432,7 @@ class Connectivity final : public IConnectivity
faceLocalNumbersInTheirCells() const
{
if constexpr (Dimension > 1) {
- return _lazzyBuildItemNumberInTheirChild(
- m_face_local_numbers_in_their_cells);
+ return _lazzyBuildItemNumberInTheirChild(m_face_local_numbers_in_their_cells);
} else {
return nodeLocalNumbersInTheirCells();
}
@@ -470,8 +443,7 @@ class Connectivity final : public IConnectivity
faceLocalNumbersInTheirEdges() const
{
static_assert(Dimension > 2, "this function has no meaning in 1d or 2d");
- return _lazzyBuildItemNumberInTheirChild(
- m_face_local_numbers_in_their_edges);
+ return _lazzyBuildItemNumberInTheirChild(m_face_local_numbers_in_their_edges);
}
PUGS_INLINE
@@ -479,8 +451,7 @@ class Connectivity final : public IConnectivity
faceLocalNumbersInTheirNodes() const
{
static_assert(Dimension > 1, "this function has no meaning in 1d");
- return _lazzyBuildItemNumberInTheirChild(
- m_face_local_numbers_in_their_nodes);
+ return _lazzyBuildItemNumberInTheirChild(m_face_local_numbers_in_their_nodes);
}
PUGS_INLINE
@@ -488,8 +459,7 @@ class Connectivity final : public IConnectivity
edgeLocalNumbersInTheirCells() const
{
if constexpr (Dimension > 2) {
- return _lazzyBuildItemNumberInTheirChild(
- m_edge_local_numbers_in_their_cells);
+ return _lazzyBuildItemNumberInTheirChild(m_edge_local_numbers_in_their_cells);
} else {
return faceLocalNumbersInTheirCells();
}
@@ -500,8 +470,7 @@ class Connectivity final : public IConnectivity
edgeLocalNumbersInTheirFaces() const
{
static_assert(Dimension > 2, "this function has no meaning in 1d or 2d");
- return _lazzyBuildItemNumberInTheirChild(
- m_edge_local_numbers_in_their_faces);
+ return _lazzyBuildItemNumberInTheirChild(m_edge_local_numbers_in_their_faces);
}
PUGS_INLINE
@@ -509,16 +478,14 @@ class Connectivity final : public IConnectivity
edgeLocalNumbersInTheirNodes() const
{
static_assert(Dimension > 2, "this function has no meaning in 1d or 2d");
- return _lazzyBuildItemNumberInTheirChild(
- m_edge_local_numbers_in_their_nodes);
+ return _lazzyBuildItemNumberInTheirChild(m_edge_local_numbers_in_their_nodes);
}
PUGS_INLINE
const auto&
nodeLocalNumbersInTheirCells() const
{
- return _lazzyBuildItemNumberInTheirChild(
- m_node_local_numbers_in_their_cells);
+ return _lazzyBuildItemNumberInTheirChild(m_node_local_numbers_in_their_cells);
}
PUGS_INLINE
@@ -526,8 +493,7 @@ class Connectivity final : public IConnectivity
nodeLocalNumbersInTheirEdges() const
{
static_assert(Dimension > 2, "this function has no meaning in 1d or 2d");
- return _lazzyBuildItemNumberInTheirChild(
- m_node_local_numbers_in_their_edges);
+ return _lazzyBuildItemNumberInTheirChild(m_node_local_numbers_in_their_edges);
}
PUGS_INLINE
@@ -535,8 +501,7 @@ class Connectivity final : public IConnectivity
nodeLocalNumbersInTheirFaces() const
{
static_assert(Dimension > 1, "this function has no meaning in 1d");
- return _lazzyBuildItemNumberInTheirChild(
- m_node_local_numbers_in_their_faces);
+ return _lazzyBuildItemNumberInTheirChild(m_node_local_numbers_in_their_faces);
}
template <ItemType item_type>
@@ -646,8 +611,7 @@ class Connectivity final : public IConnectivity
size_t
numberOfNodes() const final
{
- const auto& node_to_cell_matrix =
- this->_getMatrix(ItemType::node, ItemType::cell);
+ const auto& node_to_cell_matrix = this->_getMatrix(ItemType::node, ItemType::cell);
return node_to_cell_matrix.numRows();
}
@@ -655,8 +619,7 @@ class Connectivity final : public IConnectivity
size_t
numberOfEdges() const final
{
- const auto& edge_to_node_matrix =
- this->_getMatrix(ItemType::edge, ItemType::node);
+ const auto& edge_to_node_matrix = this->_getMatrix(ItemType::edge, ItemType::node);
return edge_to_node_matrix.numRows();
}
@@ -664,8 +627,7 @@ class Connectivity final : public IConnectivity
size_t
numberOfFaces() const final
{
- const auto& face_to_node_matrix =
- this->_getMatrix(ItemType::face, ItemType::cell);
+ const auto& face_to_node_matrix = this->_getMatrix(ItemType::face, ItemType::cell);
return face_to_node_matrix.numRows();
}
@@ -673,8 +635,7 @@ class Connectivity final : public IConnectivity
size_t
numberOfCells() const final
{
- const auto& cell_to_node_matrix =
- this->_getMatrix(ItemType::cell, ItemType::node);
+ const auto& cell_to_node_matrix = this->_getMatrix(ItemType::cell, ItemType::node);
return cell_to_node_matrix.numRows();
}
@@ -682,16 +643,15 @@ class Connectivity final : public IConnectivity
invCellNbNodes() const
{
if (not m_inv_cell_nb_nodes.isBuilt()) {
- const auto& cell_to_node_matrix =
- m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::node)];
+ const auto& cell_to_node_matrix = m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::node)];
WeakCellValue<double> inv_cell_nb_nodes(*this);
- parallel_for(this->numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- const auto& cell_nodes = cell_to_node_matrix.rowConst(j);
- inv_cell_nb_nodes[j] = 1. / cell_nodes.length;
- });
- const_cast<WeakCellValue<const double>&>(m_inv_cell_nb_nodes) =
- inv_cell_nb_nodes;
+ parallel_for(
+ this->numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ const auto& cell_nodes = cell_to_node_matrix.rowConst(j);
+ inv_cell_nb_nodes[j] = 1. / cell_nodes.length;
+ });
+ const_cast<WeakCellValue<const double>&>(m_inv_cell_nb_nodes) = inv_cell_nb_nodes;
}
return m_inv_cell_nb_nodes;
diff --git a/src/mesh/ConnectivityComputer.cpp b/src/mesh/ConnectivityComputer.cpp
index f5d88bb5cd151751d0af6778fc1e28683709be7f..b040c48890f23085b2d6de6a0a9e2fe894d07a87 100644
--- a/src/mesh/ConnectivityComputer.cpp
+++ b/src/mesh/ConnectivityComputer.cpp
@@ -5,47 +5,39 @@
template <typename ConnectivityType>
PUGS_INLINE ConnectivityMatrix
-ConnectivityComputer::computeConnectivityMatrix(
- const ConnectivityType& connectivity,
- const ItemType& item_type,
- const ItemType& child_item_type) const
+ConnectivityComputer::computeConnectivityMatrix(const ConnectivityType& connectivity,
+ const ItemType& item_type,
+ const ItemType& child_item_type) const
{
ConnectivityMatrix item_to_child_item_matrix;
if (connectivity.isConnectivityMatrixBuilt(child_item_type, item_type)) {
- const ConnectivityMatrix& child_to_item_matrix =
- connectivity._getMatrix(child_item_type, item_type);
+ const ConnectivityMatrix& child_to_item_matrix = connectivity._getMatrix(child_item_type, item_type);
- pout() << "computing connectivity " << itemName(item_type) << " -> "
- << itemName(child_item_type) << '\n';
+ pout() << "computing connectivity " << itemName(item_type) << " -> " << itemName(child_item_type) << '\n';
item_to_child_item_matrix = this->_computeInverse(child_to_item_matrix);
} else {
- perr() << "unable to compute connectivity " << itemName(item_type) << " -> "
- << itemName(child_item_type) << '\n';
+ perr() << "unable to compute connectivity " << itemName(item_type) << " -> " << itemName(child_item_type) << '\n';
std::terminate();
}
return item_to_child_item_matrix;
}
-template ConnectivityMatrix ConnectivityComputer::computeConnectivityMatrix(
- const Connectivity1D&,
- const ItemType&,
- const ItemType&) const;
+template ConnectivityMatrix ConnectivityComputer::computeConnectivityMatrix(const Connectivity1D&,
+ const ItemType&,
+ const ItemType&) const;
-template ConnectivityMatrix ConnectivityComputer::computeConnectivityMatrix(
- const Connectivity2D&,
- const ItemType&,
- const ItemType&) const;
+template ConnectivityMatrix ConnectivityComputer::computeConnectivityMatrix(const Connectivity2D&,
+ const ItemType&,
+ const ItemType&) const;
-template ConnectivityMatrix ConnectivityComputer::computeConnectivityMatrix(
- const Connectivity3D&,
- const ItemType&,
- const ItemType&) const;
+template ConnectivityMatrix ConnectivityComputer::computeConnectivityMatrix(const Connectivity3D&,
+ const ItemType&,
+ const ItemType&) const;
ConnectivityMatrix
-ConnectivityComputer::_computeInverse(
- const ConnectivityMatrix& item_to_child_matrix) const
+ConnectivityComputer::_computeInverse(const ConnectivityMatrix& item_to_child_matrix) const
{
std::map<unsigned int, std::vector<unsigned int>> child_to_item_vector_map;
const size_t& number_of_items = item_to_child_matrix.numRows();
@@ -68,8 +60,7 @@ ConnectivityComputer::_computeInverse(
}
}
- std::vector<std::vector<unsigned int>> child_to_items_vector(
- child_to_item_vector_map.size());
+ std::vector<std::vector<unsigned int>> child_to_items_vector(child_to_item_vector_map.size());
for (const auto& [child_item_id, item_vector] : child_to_item_vector_map) {
child_to_items_vector[child_item_id] = item_vector;
}
@@ -79,23 +70,18 @@ ConnectivityComputer::_computeInverse(
template <typename ItemOfItem, typename ConnectivityType>
WeakSubItemValuePerItem<const unsigned short, typename ItemOfItem::Reversed>
-ConnectivityComputer::computeLocalItemNumberInChildItem(
- const ConnectivityType& connectivity) const
+ConnectivityComputer::computeLocalItemNumberInChildItem(const ConnectivityType& connectivity) const
{
using ReversedItemOfItem = typename ItemOfItem::Reversed;
constexpr ItemType item_type = ReversedItemOfItem::item_type;
constexpr ItemType child_item_type = ReversedItemOfItem::sub_item_type;
- const ConnectivityMatrix& child_item_to_items_matrix =
- connectivity._getMatrix(child_item_type, item_type);
- const ConnectivityMatrix& item_to_child_items_matrix =
- connectivity._getMatrix(item_type, child_item_type);
+ const ConnectivityMatrix& child_item_to_items_matrix = connectivity._getMatrix(child_item_type, item_type);
+ const ConnectivityMatrix& item_to_child_items_matrix = connectivity._getMatrix(item_type, child_item_type);
- WeakSubItemValuePerItem<unsigned short, ReversedItemOfItem>
- item_number_in_child_item(connectivity);
- for (ItemIdT<item_type> r = 0; r < item_to_child_items_matrix.numRows();
- ++r) {
+ WeakSubItemValuePerItem<unsigned short, ReversedItemOfItem> item_number_in_child_item(connectivity);
+ for (ItemIdT<item_type> r = 0; r < item_to_child_items_matrix.numRows(); ++r) {
const auto& item_to_child_items = item_to_child_items_matrix.rowConst(r);
for (unsigned short J = 0; J < item_to_child_items.length; ++J) {
const unsigned int j = item_to_child_items(J);
@@ -116,85 +102,65 @@ ConnectivityComputer::computeLocalItemNumberInChildItem(
// 1D
template WeakSubItemValuePerItem<const unsigned short, CellOfNode>
-ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfCell>(
- const Connectivity1D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfCell>(const Connectivity1D&) const;
template WeakSubItemValuePerItem<const unsigned short, NodeOfCell>
-ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfNode>(
- const Connectivity1D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfNode>(const Connectivity1D&) const;
// 2D
template WeakSubItemValuePerItem<const unsigned short, CellOfNode>
-ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfCell>(
- const Connectivity2D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfCell>(const Connectivity2D&) const;
template WeakSubItemValuePerItem<const unsigned short, CellOfFace>
-ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfCell>(
- const Connectivity2D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfCell>(const Connectivity2D&) const;
template WeakSubItemValuePerItem<const unsigned short, FaceOfNode>
-ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfFace>(
- const Connectivity2D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfFace>(const Connectivity2D&) const;
template WeakSubItemValuePerItem<const unsigned short, FaceOfCell>
-ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfFace>(
- const Connectivity2D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfFace>(const Connectivity2D&) const;
template WeakSubItemValuePerItem<const unsigned short, NodeOfFace>
-ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfNode>(
- const Connectivity2D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfNode>(const Connectivity2D&) const;
template WeakSubItemValuePerItem<const unsigned short, NodeOfCell>
-ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfNode>(
- const Connectivity2D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfNode>(const Connectivity2D&) const;
// 3D
template WeakSubItemValuePerItem<const unsigned short, CellOfNode>
-ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfCell>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfCell>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, CellOfEdge>
-ConnectivityComputer::computeLocalItemNumberInChildItem<EdgeOfCell>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<EdgeOfCell>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, CellOfFace>
-ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfCell>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfCell>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, FaceOfNode>
-ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfFace>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfFace>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, FaceOfEdge>
-ConnectivityComputer::computeLocalItemNumberInChildItem<EdgeOfFace>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<EdgeOfFace>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, FaceOfCell>
-ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfFace>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfFace>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, EdgeOfNode>
-ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfEdge>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<NodeOfEdge>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, EdgeOfFace>
-ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfEdge>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfEdge>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, EdgeOfCell>
-ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfEdge>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfEdge>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, NodeOfEdge>
-ConnectivityComputer::computeLocalItemNumberInChildItem<EdgeOfNode>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<EdgeOfNode>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, NodeOfFace>
-ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfNode>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<FaceOfNode>(const Connectivity3D&) const;
template WeakSubItemValuePerItem<const unsigned short, NodeOfCell>
-ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfNode>(
- const Connectivity3D&) const;
+ConnectivityComputer::computeLocalItemNumberInChildItem<CellOfNode>(const Connectivity3D&) const;
diff --git a/src/mesh/ConnectivityComputer.hpp b/src/mesh/ConnectivityComputer.hpp
index 183f513ae2a7fff2f9687314f9437656ddd9d84b..b56b1895ef74bec0afc55bbeeea7b6f7b911dfe6 100644
--- a/src/mesh/ConnectivityComputer.hpp
+++ b/src/mesh/ConnectivityComputer.hpp
@@ -7,19 +7,17 @@
class ConnectivityComputer
{
private:
- ConnectivityMatrix _computeInverse(
- const ConnectivityMatrix& item_to_child_matrix) const;
+ ConnectivityMatrix _computeInverse(const ConnectivityMatrix& item_to_child_matrix) const;
public:
template <typename ConnectivityType>
- ConnectivityMatrix computeConnectivityMatrix(
- const ConnectivityType& connectivity,
- const ItemType& item_type,
- const ItemType& child_item_type) const;
+ ConnectivityMatrix computeConnectivityMatrix(const ConnectivityType& connectivity,
+ const ItemType& item_type,
+ const ItemType& child_item_type) const;
template <typename ItemOfItem, typename ConnectivityType>
- WeakSubItemValuePerItem<const unsigned short, typename ItemOfItem::Reversed>
- computeLocalItemNumberInChildItem(const ConnectivityType& connectivity) const;
+ WeakSubItemValuePerItem<const unsigned short, typename ItemOfItem::Reversed> computeLocalItemNumberInChildItem(
+ const ConnectivityType& connectivity) const;
ConnectivityComputer(const ConnectivityComputer&) = default;
ConnectivityComputer() = default;
diff --git a/src/mesh/ConnectivityDispatcher.cpp b/src/mesh/ConnectivityDispatcher.cpp
index e3f419ca78cde0c41171a7f76b15ea56dcc36809..26ca51ce211bfda1d133fd42a49421f9d831ae74 100644
--- a/src/mesh/ConnectivityDispatcher.cpp
+++ b/src/mesh/ConnectivityDispatcher.cpp
@@ -19,27 +19,26 @@ ConnectivityDispatcher<Dimension>::_buildNewOwner()
this->_dispatchedInfo<ItemType::cell>().m_new_owner = cell_new_owner;
} else {
- const auto& item_to_cell_matrix =
- m_connectivity.template getItemToItemMatrix<item_type, ItemType::cell>();
+ const auto& item_to_cell_matrix = m_connectivity.template getItemToItemMatrix<item_type, ItemType::cell>();
- const auto& cell_number = m_connectivity.cellNumber();
- const auto& cell_new_owner =
- this->_dispatchedInfo<ItemType::cell>().m_new_owner;
+ const auto& cell_number = m_connectivity.cellNumber();
+ const auto& cell_new_owner = this->_dispatchedInfo<ItemType::cell>().m_new_owner;
using ItemId = ItemIdT<item_type>;
ItemValue<int, item_type> item_new_owner(m_connectivity);
- parallel_for(item_new_owner.size(), PUGS_LAMBDA(const ItemId& l) {
- const auto& item_to_cell = item_to_cell_matrix[l];
- CellId Jmin = item_to_cell[0];
-
- for (size_t j = 1; j < item_to_cell.size(); ++j) {
- const CellId J = item_to_cell[j];
- if (cell_number[J] < cell_number[Jmin]) {
- Jmin = J;
+ parallel_for(
+ item_new_owner.size(), PUGS_LAMBDA(const ItemId& l) {
+ const auto& item_to_cell = item_to_cell_matrix[l];
+ CellId Jmin = item_to_cell[0];
+
+ for (size_t j = 1; j < item_to_cell.size(); ++j) {
+ const CellId J = item_to_cell[j];
+ if (cell_number[J] < cell_number[Jmin]) {
+ Jmin = J;
+ }
}
- }
- item_new_owner[l] = cell_new_owner[Jmin];
- });
+ item_new_owner[l] = cell_new_owner[Jmin];
+ });
synchronize(item_new_owner);
this->_dispatchedInfo<item_type>().m_new_owner = item_new_owner;
@@ -68,11 +67,9 @@ ConnectivityDispatcher<Dimension>::_buildItemListToSend()
const auto& node_to_cell_matrix = m_connectivity.nodeToCellMatrix();
const auto& cell_to_node_matrix = m_connectivity.cellToNodeMatrix();
- const auto& cell_new_owner =
- this->_dispatchedInfo<ItemType::cell>().m_new_owner;
+ const auto& cell_new_owner = this->_dispatchedInfo<ItemType::cell>().m_new_owner;
- std::vector<std::vector<CellId>> cell_vector_to_send_by_proc(
- parallel::size());
+ std::vector<std::vector<CellId>> cell_vector_to_send_by_proc(parallel::size());
Array<bool> send_to_rank(parallel::size());
for (CellId j = 0; j < m_connectivity.numberOfCells(); ++j) {
send_to_rank.fill(false);
@@ -94,23 +91,18 @@ ConnectivityDispatcher<Dimension>::_buildItemListToSend()
}
}
- auto& cell_list_to_send_by_proc =
- this->_dispatchedInfo<ItemType::cell>().m_list_to_send_by_proc;
+ auto& cell_list_to_send_by_proc = this->_dispatchedInfo<ItemType::cell>().m_list_to_send_by_proc;
cell_list_to_send_by_proc.resize(parallel::size());
for (size_t i = 0; i < parallel::size(); ++i) {
- cell_list_to_send_by_proc[i] =
- convert_to_array(cell_vector_to_send_by_proc[i]);
+ cell_list_to_send_by_proc[i] = convert_to_array(cell_vector_to_send_by_proc[i]);
}
} else {
- const auto& cell_list_to_send_by_proc =
- this->_dispatchedInfo<ItemType::cell>().m_list_to_send_by_proc;
+ const auto& cell_list_to_send_by_proc = this->_dispatchedInfo<ItemType::cell>().m_list_to_send_by_proc;
- using ItemId = ItemIdT<item_type>;
- const auto& cell_to_sub_item_matrix =
- m_connectivity.template getItemToItemMatrix<ItemType::cell, item_type>();
+ using ItemId = ItemIdT<item_type>;
+ const auto& cell_to_sub_item_matrix = m_connectivity.template getItemToItemMatrix<ItemType::cell, item_type>();
- auto& item_list_to_send_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
+ auto& item_list_to_send_by_proc = this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
item_list_to_send_by_proc.resize(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
@@ -138,38 +130,30 @@ template <ItemType item_type>
void
ConnectivityDispatcher<Dimension>::_buildNumberOfItemToExchange()
{
- const auto& item_list_to_send_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
+ const auto& item_list_to_send_by_proc = this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
Array<unsigned int> nb_item_to_send_by_proc(parallel::size());
for (size_t i = 0; i < parallel::size(); ++i) {
nb_item_to_send_by_proc[i] = item_list_to_send_by_proc[i].size();
}
- this->_dispatchedInfo<item_type>().m_list_to_send_size_by_proc =
- nb_item_to_send_by_proc;
+ this->_dispatchedInfo<item_type>().m_list_to_send_size_by_proc = nb_item_to_send_by_proc;
- this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc =
- parallel::allToAll(nb_item_to_send_by_proc);
+ this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc = parallel::allToAll(nb_item_to_send_by_proc);
}
template <int Dimension>
template <typename DataType, ItemType item_type, typename ConnectivityPtr>
void
-ConnectivityDispatcher<Dimension>::_gatherFrom(
- const ItemValue<DataType, item_type, ConnectivityPtr>& data_to_gather,
- std::vector<std::remove_const_t<DataType>>& gathered_vector)
+ConnectivityDispatcher<Dimension>::_gatherFrom(const ItemValue<DataType, item_type, ConnectivityPtr>& data_to_gather,
+ std::vector<std::remove_const_t<DataType>>& gathered_vector)
{
- std::vector<Array<const DataType>> recv_item_data_by_proc =
- this->exchange(data_to_gather);
+ std::vector<Array<const DataType>> recv_item_data_by_proc = this->exchange(data_to_gather);
- const auto& recv_id_correspondance_by_proc =
- this->_dispatchedInfo<item_type>().m_recv_id_correspondance_by_proc;
+ const auto& recv_id_correspondance_by_proc = this->_dispatchedInfo<item_type>().m_recv_id_correspondance_by_proc;
Assert(recv_id_correspondance_by_proc.size() == parallel::size());
- gathered_vector.resize(
- this->_dispatchedInfo<item_type>().m_number_to_id_map.size());
+ gathered_vector.resize(this->_dispatchedInfo<item_type>().m_number_to_id_map.size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- Assert(recv_id_correspondance_by_proc[i_rank].size() ==
- recv_item_data_by_proc[i_rank].size());
+ Assert(recv_id_correspondance_by_proc[i_rank].size() == recv_item_data_by_proc[i_rank].size());
for (size_t r = 0; r < recv_id_correspondance_by_proc[i_rank].size(); ++r) {
const auto& item_id = recv_id_correspondance_by_proc[i_rank][r];
gathered_vector[item_id] = recv_item_data_by_proc[i_rank][r];
@@ -181,8 +165,7 @@ template <int Dimension>
template <typename DataType, typename ItemOfItem, typename ConnectivityPtr>
void
ConnectivityDispatcher<Dimension>::_gatherFrom(
- const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>&
- data_to_gather,
+ const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>& data_to_gather,
std::vector<Array<std::remove_const_t<DataType>>>& gathered_vector)
{
using MutableDataType = std::remove_const_t<DataType>;
@@ -190,8 +173,7 @@ ConnectivityDispatcher<Dimension>::_gatherFrom(
constexpr ItemType item_type = ItemOfItem::item_type;
using ItemId = ItemIdT<item_type>;
- const auto& item_list_to_send_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
+ const auto& item_list_to_send_by_proc = this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
std::vector<Array<MutableDataType>> data_to_send_by_proc(parallel::size());
@@ -208,26 +190,22 @@ ConnectivityDispatcher<Dimension>::_gatherFrom(
}
const auto& number_of_sub_item_per_item_to_recv_by_proc =
- this->_dispatchedInfo<ItemOfItem>()
- .m_number_of_sub_item_per_item_to_recv_by_proc;
+ this->_dispatchedInfo<ItemOfItem>().m_number_of_sub_item_per_item_to_recv_by_proc;
- std::vector<Array<MutableDataType>> recv_data_to_gather_by_proc(
- parallel::size());
+ std::vector<Array<MutableDataType>> recv_data_to_gather_by_proc(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- recv_data_to_gather_by_proc[i_rank] = Array<MutableDataType>(
- sum(number_of_sub_item_per_item_to_recv_by_proc[i_rank]));
+ recv_data_to_gather_by_proc[i_rank] =
+ Array<MutableDataType>(sum(number_of_sub_item_per_item_to_recv_by_proc[i_rank]));
}
parallel::exchange(data_to_send_by_proc, recv_data_to_gather_by_proc);
- const auto& item_list_to_recv_size_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
+ const auto& item_list_to_recv_size_by_proc = this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
int l = 0;
for (size_t i = 0; i < item_list_to_recv_size_by_proc[i_rank]; ++i) {
- Array<MutableDataType> data_vector(
- number_of_sub_item_per_item_to_recv_by_proc[i_rank][i]);
+ Array<MutableDataType> data_vector(number_of_sub_item_per_item_to_recv_by_proc[i_rank][i]);
for (size_t k = 0; k < data_vector.size(); ++k) {
data_vector[k] = recv_data_to_gather_by_proc[i_rank][l++];
}
@@ -240,16 +218,13 @@ template <int Dimension>
void
ConnectivityDispatcher<Dimension>::_buildCellNumberIdMap()
{
- const auto recv_cell_number_by_proc =
- this->exchange(m_connectivity.template number<ItemType::cell>());
- auto& cell_number_id_map =
- this->_dispatchedInfo<ItemType::cell>().m_number_to_id_map;
+ const auto recv_cell_number_by_proc = this->exchange(m_connectivity.template number<ItemType::cell>());
+ auto& cell_number_id_map = this->_dispatchedInfo<ItemType::cell>().m_number_to_id_map;
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
CellId cell_id = 0;
for (size_t i = 0; i < recv_cell_number_by_proc[i_rank].size(); ++i) {
- const int cell_number = recv_cell_number_by_proc[i_rank][i];
- auto [iterator, inserted] =
- cell_number_id_map.insert(std::make_pair(cell_number, cell_id));
+ const int cell_number = recv_cell_number_by_proc[i_rank][i];
+ auto [iterator, inserted] = cell_number_id_map.insert(std::make_pair(cell_number, cell_id));
if (inserted)
++cell_id;
}
@@ -261,22 +236,18 @@ template <typename ItemOfItemT>
void
ConnectivityDispatcher<Dimension>::_buildSubItemNumberToIdMap()
{
- static_assert(
- ItemOfItemT::item_type == ItemType::cell,
- "Dispatcher requires to be built using cell as master entities");
+ static_assert(ItemOfItemT::item_type == ItemType::cell, "Dispatcher requires to be built using cell as master "
+ "entities");
const auto& cell_sub_item_number_to_recv_by_proc =
this->_dispatchedInfo<ItemOfItemT>().m_sub_item_numbers_to_recv_by_proc;
- auto& sub_item_number_id_map =
- this->_dispatchedInfo<ItemOfItemT::sub_item_type>().m_number_to_id_map;
+ auto& sub_item_number_id_map = this->_dispatchedInfo<ItemOfItemT::sub_item_type>().m_number_to_id_map;
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
int sub_item_id = 0;
- for (size_t i = 0; i < cell_sub_item_number_to_recv_by_proc[i_rank].size();
- ++i) {
- int sub_item_number = cell_sub_item_number_to_recv_by_proc[i_rank][i];
- auto [iterator, inserted] = sub_item_number_id_map.insert(
- std::make_pair(sub_item_number, sub_item_id));
+ for (size_t i = 0; i < cell_sub_item_number_to_recv_by_proc[i_rank].size(); ++i) {
+ int sub_item_number = cell_sub_item_number_to_recv_by_proc[i_rank][i];
+ auto [iterator, inserted] = sub_item_number_id_map.insert(std::make_pair(sub_item_number, sub_item_id));
if (inserted)
sub_item_id++;
}
@@ -289,20 +260,16 @@ void
ConnectivityDispatcher<Dimension>::_buildNumberOfSubItemPerItemToRecvByProc()
{
const auto& item_to_sub_item_matrix =
- m_connectivity.template getItemToItemMatrix<
- SubItemOfItemT::item_type, SubItemOfItemT::sub_item_type>();
+ m_connectivity.template getItemToItemMatrix<SubItemOfItemT::item_type, SubItemOfItemT::sub_item_type>();
- ItemValue<int, SubItemOfItemT::item_type> number_of_sub_item_per_item(
- m_connectivity);
+ ItemValue<int, SubItemOfItemT::item_type> number_of_sub_item_per_item(m_connectivity);
using ItemId = ItemIdT<SubItemOfItemT::item_type>;
parallel_for(
- number_of_sub_item_per_item.size(), PUGS_LAMBDA(const ItemId& j) {
- number_of_sub_item_per_item[j] = item_to_sub_item_matrix[j].size();
- });
+ number_of_sub_item_per_item.size(),
+ PUGS_LAMBDA(const ItemId& j) { number_of_sub_item_per_item[j] = item_to_sub_item_matrix[j].size(); });
- this->_dispatchedInfo<SubItemOfItemT>()
- .m_number_of_sub_item_per_item_to_recv_by_proc =
+ this->_dispatchedInfo<SubItemOfItemT>().m_number_of_sub_item_per_item_to_recv_by_proc =
this->exchange(number_of_sub_item_per_item);
}
@@ -313,21 +280,16 @@ ConnectivityDispatcher<Dimension>::_buildSubItemNumbersToRecvByProc()
{
const std::vector<Array<const int>> sub_item_numbers_to_send_by_proc = [&]() {
const auto& item_to_sub_item_matrix =
- m_connectivity.template getItemToItemMatrix<
- SubItemOfItemT::item_type, SubItemOfItemT::sub_item_type>();
+ m_connectivity.template getItemToItemMatrix<SubItemOfItemT::item_type, SubItemOfItemT::sub_item_type>();
- const auto& sub_item_number =
- m_connectivity.template number<SubItemOfItemT::sub_item_type>();
+ const auto& sub_item_number = m_connectivity.template number<SubItemOfItemT::sub_item_type>();
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>> 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;
+ const auto& item_list_to_send_by_proc = this->_dispatchedInfo<SubItemOfItemT::item_type>().m_list_to_send_by_proc;
std::vector<int> sub_item_numbers_by_item_vector;
for (size_t j = 0; j < item_list_to_send_by_proc[i_rank].size(); ++j) {
@@ -335,35 +297,29 @@ ConnectivityDispatcher<Dimension>::_buildSubItemNumbersToRecvByProc()
const auto& sub_item_list = item_to_sub_item_matrix[item_id];
for (size_t r = 0; r < sub_item_list.size(); ++r) {
const SubItemId& sub_item_id = sub_item_list[r];
- sub_item_numbers_by_item_vector.push_back(
- sub_item_number[sub_item_id]);
+ 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);
+ 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;
}();
const auto& number_of_sub_item_per_item_to_recv_by_proc =
- this->_dispatchedInfo<SubItemOfItemT>()
- .m_number_of_sub_item_per_item_to_recv_by_proc;
+ this->_dispatchedInfo<SubItemOfItemT>().m_number_of_sub_item_per_item_to_recv_by_proc;
std::vector<Array<int>> sub_item_numbers_to_recv_by_proc(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- sub_item_numbers_to_recv_by_proc[i_rank] =
- Array<int>(sum(number_of_sub_item_per_item_to_recv_by_proc[i_rank]));
+ sub_item_numbers_to_recv_by_proc[i_rank] = Array<int>(sum(number_of_sub_item_per_item_to_recv_by_proc[i_rank]));
}
- parallel::exchange(sub_item_numbers_to_send_by_proc,
- sub_item_numbers_to_recv_by_proc);
+ parallel::exchange(sub_item_numbers_to_send_by_proc, sub_item_numbers_to_recv_by_proc);
auto& const_sub_item_numbers_to_recv_by_proc =
this->_dispatchedInfo<SubItemOfItemT>().m_sub_item_numbers_to_recv_by_proc;
const_sub_item_numbers_to_recv_by_proc.resize(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- const_sub_item_numbers_to_recv_by_proc[i_rank] =
- sub_item_numbers_to_recv_by_proc[i_rank];
+ const_sub_item_numbers_to_recv_by_proc[i_rank] = sub_item_numbers_to_recv_by_proc[i_rank];
}
}
@@ -375,15 +331,12 @@ ConnectivityDispatcher<Dimension>::_buildItemToSubItemDescriptor()
constexpr ItemType item_type = ItemOfItemT::item_type;
constexpr ItemType sub_item_type = ItemOfItemT::sub_item_type;
- const auto& item_list_to_recv_size_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
+ const auto& item_list_to_recv_size_by_proc = this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
const auto& number_of_sub_item_per_item_to_recv_by_proc =
- this->_dispatchedInfo<ItemOfItemT>()
- .m_number_of_sub_item_per_item_to_recv_by_proc;
+ this->_dispatchedInfo<ItemOfItemT>().m_number_of_sub_item_per_item_to_recv_by_proc;
- const auto& sub_item_number_id_map =
- this->_dispatchedInfo<sub_item_type>().m_number_to_id_map;
+ const auto& sub_item_number_id_map = this->_dispatchedInfo<sub_item_type>().m_number_to_id_map;
const auto& recv_item_of_item_numbers_by_proc =
this->_dispatchedInfo<ItemOfItemT>().m_sub_item_numbers_to_recv_by_proc;
@@ -392,15 +345,12 @@ ConnectivityDispatcher<Dimension>::_buildItemToSubItemDescriptor()
int l = 0;
for (size_t i = 0; i < item_list_to_recv_size_by_proc[i_rank]; ++i) {
std::vector<unsigned int> sub_item_vector;
- for (int k = 0;
- k < number_of_sub_item_per_item_to_recv_by_proc[i_rank][i]; ++k) {
- const auto& searched_sub_item_id = sub_item_number_id_map.find(
- recv_item_of_item_numbers_by_proc[i_rank][l++]);
+ for (int k = 0; k < number_of_sub_item_per_item_to_recv_by_proc[i_rank][i]; ++k) {
+ const auto& searched_sub_item_id = sub_item_number_id_map.find(recv_item_of_item_numbers_by_proc[i_rank][l++]);
Assert(searched_sub_item_id != sub_item_number_id_map.end());
sub_item_vector.push_back(searched_sub_item_id->second);
}
- m_new_descriptor.itemOfItemVector<ItemOfItemT>().emplace_back(
- sub_item_vector);
+ m_new_descriptor.itemOfItemVector<ItemOfItemT>().emplace_back(sub_item_vector);
}
}
}
@@ -410,40 +360,31 @@ template <ItemType item_type>
void
ConnectivityDispatcher<Dimension>::_buildRecvItemIdCorrespondanceByProc()
{
- const auto& item_list_to_send_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
- using ItemId = ItemIdT<item_type>;
+ const auto& item_list_to_send_by_proc = this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
+ using ItemId = ItemIdT<item_type>;
- std::vector<Array<const ItemId>> recv_item_id_correspondance_by_proc(
- parallel::size());
- const ItemValue<const int, item_type>& item_number =
- m_connectivity.template number<item_type>();
+ std::vector<Array<const ItemId>> recv_item_id_correspondance_by_proc(parallel::size());
+ const ItemValue<const int, item_type>& item_number = m_connectivity.template number<item_type>();
std::vector<Array<const int>> send_item_number_by_proc(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
Array<int> send_item_number(item_list_to_send_by_proc[i_rank].size());
const Array<const ItemId> send_item_id = item_list_to_send_by_proc[i_rank];
- parallel_for(send_item_number.size(), PUGS_LAMBDA(const size_t& j) {
- send_item_number[j] = item_number[send_item_id[j]];
- });
+ parallel_for(
+ send_item_number.size(), PUGS_LAMBDA(const size_t& j) { send_item_number[j] = item_number[send_item_id[j]]; });
send_item_number_by_proc[i_rank] = send_item_number;
}
- const auto& item_list_to_recv_size_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
+ const auto& item_list_to_recv_size_by_proc = this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
std::vector<Array<int>> recv_item_number_by_proc(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- recv_item_number_by_proc[i_rank] =
- Array<int>(item_list_to_recv_size_by_proc[i_rank]);
+ recv_item_number_by_proc[i_rank] = Array<int>(item_list_to_recv_size_by_proc[i_rank]);
}
parallel::exchange(send_item_number_by_proc, recv_item_number_by_proc);
- const auto& item_number_to_id_map =
- this->_dispatchedInfo<item_type>().m_number_to_id_map;
- 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]);
+ const auto& item_number_to_id_map = this->_dispatchedInfo<item_type>().m_number_to_id_map;
+ 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);
@@ -452,8 +393,7 @@ ConnectivityDispatcher<Dimension>::_buildRecvItemIdCorrespondanceByProc()
}
recv_item_id_correspondance_by_proc[i_rank] = item_id_correspondance;
}
- this->_dispatchedInfo<item_type>().m_recv_id_correspondance_by_proc =
- recv_item_id_correspondance_by_proc;
+ this->_dispatchedInfo<item_type>().m_recv_id_correspondance_by_proc = recv_item_id_correspondance_by_proc;
}
template <int Dimension>
@@ -464,14 +404,13 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
using ItemId = ItemIdT<item_type>;
// Getting references
- Array<const size_t> number_of_item_ref_list_per_proc = parallel::allGather(
- m_connectivity.template numberOfRefItemList<item_type>());
+ Array<const size_t> number_of_item_ref_list_per_proc =
+ parallel::allGather(m_connectivity.template numberOfRefItemList<item_type>());
const size_t number_of_item_list_sender = [&]() {
size_t 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);
+ number_of_item_list_sender += (number_of_item_ref_list_per_proc[i_rank] > 0);
}
return number_of_item_list_sender;
}();
@@ -479,8 +418,7 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
if (number_of_item_list_sender > 0) {
if (number_of_item_list_sender > 1) {
perr() << __FILE__ << ':' << __LINE__ << ": " << rang::fgB::red
- << "need to check that knowing procs know the same item_ref_lists!"
- << rang::fg::reset << '\n';
+ << "need to check that knowing procs know the same item_ref_lists!" << rang::fg::reset << '\n';
}
if (number_of_item_list_sender < parallel::size()) {
@@ -497,47 +435,34 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
Assert(number_of_item_list_sender < parallel::size());
// sending references tags
- Array<RefId::TagNumberType> ref_tag_list{
- number_of_item_ref_list_per_proc[sender_rank]};
+ Array<RefId::TagNumberType> ref_tag_list{number_of_item_ref_list_per_proc[sender_rank]};
if (parallel::rank() == sender_rank) {
- for (size_t i_item_ref_list = 0;
- i_item_ref_list <
- m_connectivity.template numberOfRefItemList<item_type>();
+ for (size_t i_item_ref_list = 0; i_item_ref_list < m_connectivity.template numberOfRefItemList<item_type>();
++i_item_ref_list) {
- auto item_ref_list =
- m_connectivity.template refItemList<item_type>(i_item_ref_list);
+ auto item_ref_list = m_connectivity.template refItemList<item_type>(i_item_ref_list);
ref_tag_list[i_item_ref_list] = item_ref_list.refId().tagNumber();
}
}
parallel::broadcast(ref_tag_list, sender_rank);
// sending references name size
- Array<size_t> ref_name_size_list{
- number_of_item_ref_list_per_proc[sender_rank]};
+ Array<size_t> ref_name_size_list{number_of_item_ref_list_per_proc[sender_rank]};
if (parallel::rank() == sender_rank) {
- for (size_t i_item_ref_list = 0;
- i_item_ref_list <
- m_connectivity.template numberOfRefItemList<item_type>();
+ for (size_t i_item_ref_list = 0; i_item_ref_list < m_connectivity.template numberOfRefItemList<item_type>();
++i_item_ref_list) {
- auto item_ref_list =
- m_connectivity.template refItemList<item_type>(i_item_ref_list);
- ref_name_size_list[i_item_ref_list] =
- item_ref_list.refId().tagName().size();
+ auto item_ref_list = m_connectivity.template refItemList<item_type>(i_item_ref_list);
+ ref_name_size_list[i_item_ref_list] = item_ref_list.refId().tagName().size();
}
}
parallel::broadcast(ref_name_size_list, sender_rank);
// sending references name size
- Array<RefId::TagNameType::value_type> ref_name_cat{
- sum(ref_name_size_list)};
+ Array<RefId::TagNameType::value_type> ref_name_cat{sum(ref_name_size_list)};
if (parallel::rank() == sender_rank) {
size_t i_char = 0;
- for (size_t i_item_ref_list = 0;
- i_item_ref_list <
- m_connectivity.template numberOfRefItemList<item_type>();
+ for (size_t i_item_ref_list = 0; i_item_ref_list < m_connectivity.template numberOfRefItemList<item_type>();
++i_item_ref_list) {
- auto item_ref_list =
- m_connectivity.template refItemList<item_type>(i_item_ref_list);
+ auto item_ref_list = m_connectivity.template refItemList<item_type>(i_item_ref_list);
for (auto c : item_ref_list.refId().tagName()) {
ref_name_cat[i_char++] = c;
}
@@ -551,8 +476,7 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
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});
+ ref_id_list.emplace_back(ref_tag_list[i_ref], std::string{&(ref_name_cat[begining]), size});
begining += size;
}
return ref_id_list;
@@ -560,20 +484,16 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
using block_type = int32_t;
constexpr size_t block_size = sizeof(block_type);
- const size_t nb_block = ref_id_list.size() / block_size +
- (ref_id_list.size() % block_size != 0);
+ const size_t nb_block = ref_id_list.size() / block_size + (ref_id_list.size() % block_size != 0);
for (size_t i_block = 0; i_block < nb_block; ++i_block) {
ItemValue<block_type, item_type> item_references(m_connectivity);
item_references.fill(0);
if (m_connectivity.template numberOfRefItemList<item_type>() > 0) {
- const size_t max_i_ref =
- std::min(ref_id_list.size(), block_size * (i_block + 1));
- for (size_t i_ref = block_size * i_block, i = 0; i_ref < max_i_ref;
- ++i_ref, ++i) {
+ const size_t max_i_ref = std::min(ref_id_list.size(), block_size * (i_block + 1));
+ for (size_t i_ref = block_size * i_block, i = 0; i_ref < max_i_ref; ++i_ref, ++i) {
block_type ref_bit{1 << i};
- auto item_ref_list =
- m_connectivity.template refItemList<item_type>(i_ref);
+ auto item_ref_list = m_connectivity.template refItemList<item_type>(i_ref);
const auto& item_list = item_ref_list.list();
for (size_t i_item = 0; i_item < item_list.size(); ++i_item) {
@@ -583,49 +503,42 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
}
}
- const auto& nb_item_to_send_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_send_size_by_proc;
+ const auto& nb_item_to_send_by_proc = this->_dispatchedInfo<item_type>().m_list_to_send_size_by_proc;
- const auto& send_item_id_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
+ const auto& send_item_id_by_proc = this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
- std::vector<Array<const block_type>> send_item_refs_by_proc(
- parallel::size());
+ std::vector<Array<const block_type>> send_item_refs_by_proc(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
Array<block_type> send_item_refs(nb_item_to_send_by_proc[i_rank]);
const Array<const ItemId> send_item_id = send_item_id_by_proc[i_rank];
- parallel_for(send_item_id.size(), PUGS_LAMBDA(const size_t& l) {
- const ItemId& item_id = send_item_id[l];
- send_item_refs[l] = item_references[item_id];
- });
+ parallel_for(
+ send_item_id.size(), PUGS_LAMBDA(const size_t& l) {
+ const ItemId& item_id = send_item_id[l];
+ send_item_refs[l] = item_references[item_id];
+ });
send_item_refs_by_proc[i_rank] = send_item_refs;
}
std::vector<Array<block_type>> recv_item_refs_by_proc(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
recv_item_refs_by_proc[i_rank] =
- Array<block_type>(this->_dispatchedInfo<item_type>()
- .m_list_to_recv_size_by_proc[i_rank]);
+ Array<block_type>(this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc[i_rank]);
}
parallel::exchange(send_item_refs_by_proc, recv_item_refs_by_proc);
const auto& recv_item_id_correspondance_by_proc =
this->_dispatchedInfo<item_type>().m_recv_id_correspondance_by_proc;
- std::vector<block_type> item_refs(
- m_new_descriptor.template itemNumberVector<item_type>().size());
+ std::vector<block_type> item_refs(m_new_descriptor.template itemNumberVector<item_type>().size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
for (size_t r = 0; r < recv_item_refs_by_proc[i_rank].size(); ++r) {
- const ItemId& item_id =
- recv_item_id_correspondance_by_proc[i_rank][r];
- item_refs[item_id] = recv_item_refs_by_proc[i_rank][r];
+ const ItemId& item_id = recv_item_id_correspondance_by_proc[i_rank][r];
+ item_refs[item_id] = recv_item_refs_by_proc[i_rank][r];
}
}
- const size_t max_i_ref =
- std::min(ref_id_list.size(), block_size * (i_block + 1));
- for (size_t i_ref = block_size * i_block, i = 0; i_ref < max_i_ref;
- ++i_ref, ++i) {
+ const size_t max_i_ref = std::min(ref_id_list.size(), block_size * (i_block + 1));
+ for (size_t i_ref = block_size * i_block, i = 0; i_ref < max_i_ref; ++i_ref, ++i) {
block_type ref_bit{1 << i};
std::vector<ItemId> item_id_vector;
@@ -639,8 +552,7 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
Array<const ItemId> item_id_array = convert_to_array(item_id_vector);
- m_new_descriptor.addRefItemList(
- RefItemList<item_type>(ref_id_list[i_ref], item_id_array));
+ m_new_descriptor.addRefItemList(RefItemList<item_type>(ref_id_list[i_ref], item_id_array));
}
}
}
@@ -657,8 +569,7 @@ ConnectivityDispatcher<Dimension>::_dispatchEdges()
this->_buildSubItemNumberToIdMap<EdgeOfCell>();
this->_buildItemToExchangeLists<ItemType::edge>();
- this->_gatherFrom(m_connectivity.template number<ItemType::edge>(),
- m_new_descriptor.edge_number_vector);
+ this->_gatherFrom(m_connectivity.template number<ItemType::edge>(), m_new_descriptor.edge_number_vector);
this->_buildItemToSubItemDescriptor<EdgeOfCell>();
@@ -670,11 +581,9 @@ ConnectivityDispatcher<Dimension>::_dispatchEdges()
this->_buildSubItemNumbersToRecvByProc<EdgeOfFace>();
this->_buildItemToSubItemDescriptor<EdgeOfFace>();
- this->_gatherFrom(m_connectivity.faceEdgeIsReversed(),
- m_new_descriptor.face_edge_is_reversed_vector);
+ this->_gatherFrom(m_connectivity.faceEdgeIsReversed(), m_new_descriptor.face_edge_is_reversed_vector);
- this->_gatherFrom(this->_dispatchedInfo<ItemType::edge>().m_new_owner,
- m_new_descriptor.edge_owner_vector);
+ this->_gatherFrom(this->_dispatchedInfo<ItemType::edge>().m_new_owner, m_new_descriptor.edge_owner_vector);
this->_buildItemReferenceList<ItemType::edge>();
}
@@ -694,24 +603,20 @@ ConnectivityDispatcher<Dimension>::_dispatchFaces()
this->_buildSubItemNumbersToRecvByProc<NodeOfFace>();
this->_buildItemToSubItemDescriptor<NodeOfFace>();
- this->_gatherFrom(m_connectivity.template number<ItemType::face>(),
- m_new_descriptor.face_number_vector);
+ this->_gatherFrom(m_connectivity.template number<ItemType::face>(), m_new_descriptor.face_number_vector);
this->_buildItemToSubItemDescriptor<FaceOfCell>();
- this->_gatherFrom(m_connectivity.cellFaceIsReversed(),
- m_new_descriptor.cell_face_is_reversed_vector);
+ this->_gatherFrom(m_connectivity.cellFaceIsReversed(), m_new_descriptor.cell_face_is_reversed_vector);
- this->_gatherFrom(this->_dispatchedInfo<ItemType::face>().m_new_owner,
- m_new_descriptor.face_owner_vector);
+ this->_gatherFrom(this->_dispatchedInfo<ItemType::face>().m_new_owner, m_new_descriptor.face_owner_vector);
this->_buildItemReferenceList<ItemType::face>();
}
}
template <int Dimension>
-ConnectivityDispatcher<Dimension>::ConnectivityDispatcher(
- const ConnectivityType& connectivity)
+ConnectivityDispatcher<Dimension>::ConnectivityDispatcher(const ConnectivityType& connectivity)
: m_connectivity(connectivity)
{
this->_buildNewOwner<ItemType::cell>();
@@ -725,23 +630,18 @@ ConnectivityDispatcher<Dimension>::ConnectivityDispatcher(
this->_buildSubItemNumbersToRecvByProc<NodeOfCell>();
- this->_gatherFrom(m_connectivity.template number<ItemType::cell>(),
- m_new_descriptor.cell_number_vector);
+ this->_gatherFrom(m_connectivity.template number<ItemType::cell>(), m_new_descriptor.cell_number_vector);
this->_buildSubItemNumberToIdMap<NodeOfCell>();
this->_buildItemToExchangeLists<ItemType::node>();
// Fill new descriptor
- this->_gatherFrom(m_connectivity.cellType(),
- m_new_descriptor.cell_type_vector);
- this->_gatherFrom(this->_dispatchedInfo<ItemType::cell>().m_new_owner,
- m_new_descriptor.cell_owner_vector);
+ this->_gatherFrom(m_connectivity.cellType(), m_new_descriptor.cell_type_vector);
+ this->_gatherFrom(this->_dispatchedInfo<ItemType::cell>().m_new_owner, m_new_descriptor.cell_owner_vector);
- this->_gatherFrom(m_connectivity.template number<ItemType::node>(),
- m_new_descriptor.node_number_vector);
- this->_gatherFrom(this->_dispatchedInfo<ItemType::node>().m_new_owner,
- m_new_descriptor.node_owner_vector);
+ this->_gatherFrom(m_connectivity.template number<ItemType::node>(), m_new_descriptor.node_number_vector);
+ this->_gatherFrom(this->_dispatchedInfo<ItemType::node>().m_new_owner, m_new_descriptor.node_owner_vector);
this->_buildItemToSubItemDescriptor<NodeOfCell>();
@@ -756,9 +656,6 @@ ConnectivityDispatcher<Dimension>::ConnectivityDispatcher(
m_dispatched_connectivity = ConnectivityType::build(m_new_descriptor);
}
-template ConnectivityDispatcher<1>::ConnectivityDispatcher(
- const ConnectivityType&);
-template ConnectivityDispatcher<2>::ConnectivityDispatcher(
- const ConnectivityType&);
-template ConnectivityDispatcher<3>::ConnectivityDispatcher(
- const ConnectivityType&);
+template ConnectivityDispatcher<1>::ConnectivityDispatcher(const ConnectivityType&);
+template ConnectivityDispatcher<2>::ConnectivityDispatcher(const ConnectivityType&);
+template ConnectivityDispatcher<3>::ConnectivityDispatcher(const ConnectivityType&);
diff --git a/src/mesh/ConnectivityDispatcher.hpp b/src/mesh/ConnectivityDispatcher.hpp
index afc2f2ef5002b68a39ced2a1320d4f73b5d97fbf..0e28f02e87ebef116ba02713450fe9e0a27cdc04 100644
--- a/src/mesh/ConnectivityDispatcher.hpp
+++ b/src/mesh/ConnectivityDispatcher.hpp
@@ -179,15 +179,12 @@ class ConnectivityDispatcher
void _dispatchFaces();
template <typename DataType, ItemType item_type, typename ConnectivityPtr>
- void _gatherFrom(
- const ItemValue<DataType, item_type, ConnectivityPtr>& data_to_gather,
- std::vector<std::remove_const_t<DataType>>& gathered_vector);
+ void _gatherFrom(const ItemValue<DataType, item_type, ConnectivityPtr>& data_to_gather,
+ std::vector<std::remove_const_t<DataType>>& gathered_vector);
template <typename DataType, typename ItemOfItem, typename ConnectivityPtr>
- void _gatherFrom(
- const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>&
- data_to_gather,
- std::vector<Array<std::remove_const_t<DataType>>>& gathered_vector);
+ void _gatherFrom(const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>& data_to_gather,
+ std::vector<Array<std::remove_const_t<DataType>>>& gathered_vector);
template <typename SubItemOfItemT>
void _buildNumberOfSubItemPerItemToRecvByProc();
@@ -214,35 +211,29 @@ class ConnectivityDispatcher
{
using ItemId = ItemIdT<item_type>;
using MutableDataType = std::remove_const_t<DataType>;
- std::vector<Array<const DataType>> item_value_to_send_by_proc(
- parallel::size());
+ std::vector<Array<const DataType>> item_value_to_send_by_proc(parallel::size());
- const auto& item_list_to_send_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
+ const auto& item_list_to_send_by_proc = this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
for (size_t i = 0; i < parallel::size(); ++i) {
const Array<const ItemId>& item_list = item_list_to_send_by_proc[i];
Array<MutableDataType> item_value_list(item_list.size());
- parallel_for(item_list.size(), PUGS_LAMBDA(const ItemId& item_id) {
- item_value_list[item_id] = item_value[item_list[item_id]];
- });
+ parallel_for(
+ item_list.size(),
+ PUGS_LAMBDA(const ItemId& item_id) { item_value_list[item_id] = item_value[item_list[item_id]]; });
item_value_to_send_by_proc[i] = item_value_list;
}
- std::vector<Array<MutableDataType>> recv_item_value_by_proc(
- parallel::size());
+ std::vector<Array<MutableDataType>> recv_item_value_by_proc(parallel::size());
{
- const auto& list_to_recv_size_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
+ const auto& list_to_recv_size_by_proc = this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
for (size_t i = 0; i < parallel::size(); ++i) {
- recv_item_value_by_proc[i] =
- Array<MutableDataType>(list_to_recv_size_by_proc[i]);
+ recv_item_value_by_proc[i] = Array<MutableDataType>(list_to_recv_size_by_proc[i]);
}
}
parallel::exchange(item_value_to_send_by_proc, recv_item_value_by_proc);
- std::vector<Array<const DataType>> const_recv_item_value_by_proc(
- parallel::size());
+ std::vector<Array<const DataType>> const_recv_item_value_by_proc(parallel::size());
for (size_t i = 0; i < parallel::size(); ++i) {
const_recv_item_value_by_proc[i] = recv_item_value_by_proc[i];
}
@@ -256,46 +247,40 @@ class ConnectivityDispatcher
{
using ItemId = ItemIdT<item_type>;
- Assert(m_dispatched_connectivity.use_count() > 0,
- "cannot dispatch quantity before connectivity");
+ Assert(m_dispatched_connectivity.use_count() > 0, "cannot dispatch quantity before connectivity");
- const auto& item_list_to_send_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
+ const auto& item_list_to_send_by_proc = this->_dispatchedInfo<item_type>().m_list_to_send_by_proc;
using MutableDataType = std::remove_const_t<DataType>;
std::vector<Array<DataType>> item_value_to_send_by_proc(parallel::size());
for (size_t i = 0; i < parallel::size(); ++i) {
const Array<const ItemId>& item_list = item_list_to_send_by_proc[i];
Array<MutableDataType> item_value_list(item_list.size());
- parallel_for(item_list.size(), PUGS_LAMBDA(const ItemId& item_id) {
- item_value_list[item_id] = item_value[item_list[item_id]];
- });
+ parallel_for(
+ item_list.size(),
+ PUGS_LAMBDA(const ItemId& item_id) { item_value_list[item_id] = item_value[item_list[item_id]]; });
item_value_to_send_by_proc[i] = item_value_list;
}
- const auto& item_list_to_recv_size_by_proc =
- this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
- std::vector<Array<MutableDataType>> recv_item_value_by_proc(
- parallel::size());
+ const auto& item_list_to_recv_size_by_proc = this->_dispatchedInfo<item_type>().m_list_to_recv_size_by_proc;
+ std::vector<Array<MutableDataType>> recv_item_value_by_proc(parallel::size());
for (size_t i = 0; i < parallel::size(); ++i) {
- recv_item_value_by_proc[i] =
- Array<MutableDataType>(item_list_to_recv_size_by_proc[i]);
+ recv_item_value_by_proc[i] = Array<MutableDataType>(item_list_to_recv_size_by_proc[i]);
}
parallel::exchange(item_value_to_send_by_proc, recv_item_value_by_proc);
const auto& recv_item_id_correspondance_by_proc =
this->_dispatchedInfo<item_type>().m_recv_id_correspondance_by_proc;
- ItemValue<MutableDataType, item_type> new_item_value(
- *m_dispatched_connectivity);
+ ItemValue<MutableDataType, item_type> new_item_value(*m_dispatched_connectivity);
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- const auto& recv_item_id_correspondance =
- recv_item_id_correspondance_by_proc[i_rank];
- const auto& recv_item_value = recv_item_value_by_proc[i_rank];
- parallel_for(recv_item_value.size(), PUGS_LAMBDA(size_t r) {
- const ItemId& item_id = recv_item_id_correspondance[r];
- new_item_value[item_id] = recv_item_value[r];
- });
+ const auto& recv_item_id_correspondance = recv_item_id_correspondance_by_proc[i_rank];
+ const auto& recv_item_value = recv_item_value_by_proc[i_rank];
+ parallel_for(
+ recv_item_value.size(), PUGS_LAMBDA(size_t r) {
+ const ItemId& item_id = recv_item_id_correspondance[r];
+ new_item_value[item_id] = recv_item_value[r];
+ });
}
return new_item_value;
}
diff --git a/src/mesh/ConnectivityMatrix.hpp b/src/mesh/ConnectivityMatrix.hpp
index 6573d011daaac3430df4a77b3283b624af76f057..0ddb21a964e18e9adae051e536c5a3f266c0e8bb 100644
--- a/src/mesh/ConnectivityMatrix.hpp
+++ b/src/mesh/ConnectivityMatrix.hpp
@@ -66,10 +66,7 @@ class ConnectivityMatrix
PUGS_INLINE
ConnectivityMatrix(const std::vector<std::vector<unsigned int>>& initializer)
- : m_host_matrix{Kokkos::create_staticcrsgraph<HostMatrix>(
- "connectivity_matrix",
- initializer)},
- m_is_built{true}
+ : m_host_matrix{Kokkos::create_staticcrsgraph<HostMatrix>("connectivity_matrix", initializer)}, m_is_built{true}
{
;
}
diff --git a/src/mesh/GmshReader.cpp b/src/mesh/GmshReader.cpp
index 3dcbb21df29e36ef2023f925209bce5c847c308c..3d2c7985b58fcea14015334d2b1e329b9e51d8c3 100644
--- a/src/mesh/GmshReader.cpp
+++ b/src/mesh/GmshReader.cpp
@@ -37,9 +37,8 @@ class ErrorHandler
};
private:
- const std::string
- __filename; /**< The source file name where the error occured */
- const size_t __lineNumber; /**< The line number where exception was raised */
+ const std::string __filename; /**< The source file name where the error occured */
+ const size_t __lineNumber; /**< The line number where exception was raised */
const std::string __errorMessage; /**< The reporting message */
const Type __type; /**< the type of the error */
@@ -56,10 +55,7 @@ class ErrorHandler
* @param e an handled error
*/
ErrorHandler(const ErrorHandler& e)
- : __filename(e.__filename),
- __lineNumber(e.__lineNumber),
- __errorMessage(e.__errorMessage),
- __type(e.__type)
+ : __filename(e.__filename), __lineNumber(e.__lineNumber), __errorMessage(e.__errorMessage), __type(e.__type)
{
;
}
@@ -91,39 +87,32 @@ void
ErrorHandler::writeErrorMessage() const
{
switch (__type) {
- case asked: {
- perr() << "\nremark: exit command explicitly called\n";
- [[fallthrough]];
- }
- case normal: {
- perr() << '\n'
- << __filename << ':' << __lineNumber
- << ":remark: emitted the following message\n";
- perr() << "error: " << __errorMessage << '\n';
- break;
- }
- case compilation: {
- perr() << "\nline " << __lineNumber << ':' << __errorMessage << '\n';
- break;
- }
- case unexpected: {
- perr() << '\n'
- << __filename << ':' << __lineNumber << ":\n"
- << __errorMessage << '\n';
- perr()
- << "\nUNEXPECTED ERROR: this should not occure, please report it\n";
- perr() << "\nBUG REPORT: Please send bug reports to:\n"
- << " ff3d-dev@nongnu.org or freefem@ann.jussieu.fr\n"
- << "or better, use the Bug Tracking System:\n"
- << " http://savannah.nongnu.org/bugs/?group=ff3d\n";
- break;
- }
- default: {
- perr() << __filename << ':' << __lineNumber << ": " << __errorMessage
- << '\n';
- perr() << __FILE__ << ':' << __LINE__
- << ":remark: error type not implemented!\n";
- }
+ case asked: {
+ perr() << "\nremark: exit command explicitly called\n";
+ [[fallthrough]];
+ }
+ case normal: {
+ perr() << '\n' << __filename << ':' << __lineNumber << ":remark: emitted the following message\n";
+ perr() << "error: " << __errorMessage << '\n';
+ break;
+ }
+ case compilation: {
+ perr() << "\nline " << __lineNumber << ':' << __errorMessage << '\n';
+ break;
+ }
+ case unexpected: {
+ perr() << '\n' << __filename << ':' << __lineNumber << ":\n" << __errorMessage << '\n';
+ perr() << "\nUNEXPECTED ERROR: this should not occure, please report it\n";
+ perr() << "\nBUG REPORT: Please send bug reports to:\n"
+ << " ff3d-dev@nongnu.org or freefem@ann.jussieu.fr\n"
+ << "or better, use the Bug Tracking System:\n"
+ << " http://savannah.nongnu.org/bugs/?group=ff3d\n";
+ break;
+ }
+ default: {
+ perr() << __filename << ':' << __lineNumber << ": " << __errorMessage << '\n';
+ perr() << __FILE__ << ':' << __LINE__ << ":remark: error type not implemented!\n";
+ }
}
}
@@ -131,10 +120,7 @@ ErrorHandler::ErrorHandler(const std::string& filename,
const size_t& lineNumber,
const std::string& errorMessage,
const Type& type)
- : __filename(filename),
- __lineNumber(lineNumber),
- __errorMessage(errorMessage),
- __type(type)
+ : __filename(filename), __lineNumber(lineNumber), __errorMessage(errorMessage), __type(type)
{
;
}
@@ -215,23 +201,18 @@ class ConnectivityFace<2>
bool
operator<(const ConnectivityFace& f) const
{
- return (
- (m_node_number_vector[m_node0_id] < m_node_number_vector[f.m_node0_id]) or
- ((m_node_number_vector[m_node0_id] ==
- m_node_number_vector[f.m_node0_id]) and
- (m_node_number_vector[m_node1_id] <
- m_node_number_vector[f.m_node1_id])));
+ return ((m_node_number_vector[m_node0_id] < m_node_number_vector[f.m_node0_id]) or
+ ((m_node_number_vector[m_node0_id] == m_node_number_vector[f.m_node0_id]) and
+ (m_node_number_vector[m_node1_id] < m_node_number_vector[f.m_node1_id])));
}
PUGS_INLINE
- ConnectivityFace(const std::vector<unsigned int>& node_id_list,
- const std::vector<int>& node_number_vector)
+ ConnectivityFace(const std::vector<unsigned int>& node_id_list, const std::vector<int>& node_number_vector)
: m_node_number_vector(node_number_vector)
{
Assert(node_id_list.size() == 2);
- if (m_node_number_vector[node_id_list[0]] <
- m_node_number_vector[node_id_list[1]]) {
+ if (m_node_number_vector[node_id_list[0]] < m_node_number_vector[node_id_list[1]]) {
m_node0_id = node_id_list[0];
m_node1_id = node_id_list[1];
m_reversed = false;
@@ -281,12 +262,10 @@ class ConnectivityFace<3>
const int shift = std::distance(node_list.begin(), min_id);
std::vector<unsigned int> rotated_node_list(node_list.size());
- if (node_list[(shift + 1) % node_list.size()] >
- node_list[(shift + node_list.size() - 1) % node_list.size()]) {
+ if (node_list[(shift + 1) % node_list.size()] > node_list[(shift + node_list.size() - 1) % node_list.size()]) {
for (size_t i = 0; i < node_list.size(); ++i) {
- rotated_node_list[i] =
- node_list[(shift + node_list.size() - i) % node_list.size()];
- m_reversed = true;
+ rotated_node_list[i] = node_list[(shift + node_list.size() - i) % node_list.size()];
+ m_reversed = true;
}
} else {
for (size_t i = 0; i < node_list.size(); ++i) {
@@ -313,11 +292,8 @@ class ConnectivityFace<3>
}
PUGS_INLINE
- ConnectivityFace(const std::vector<unsigned int>& given_node_id_list,
- const std::vector<int>& node_number_vector)
- : m_reversed(false),
- m_node_id_list(_sort(given_node_id_list)),
- m_node_number_vector(node_number_vector)
+ ConnectivityFace(const std::vector<unsigned int>& given_node_id_list, const std::vector<int>& node_number_vector)
+ : m_reversed(false), m_node_id_list(_sort(given_node_id_list)), m_node_number_vector(node_number_vector)
{
;
}
@@ -341,8 +317,7 @@ class ConnectivityFace<3>
bool
operator<(const ConnectivityFace& f) const
{
- const size_t min_nb_nodes =
- std::min(f.m_node_id_list.size(), m_node_id_list.size());
+ const size_t min_nb_nodes = std::min(f.m_node_id_list.size(), m_node_id_list.size());
for (size_t i = 0; i < min_nb_nodes; ++i) {
if (m_node_id_list[i] < f.m_node_id_list[i])
return true;
@@ -435,95 +410,87 @@ GmshReader::GmshReader(const std::string& filename) : m_filename(filename)
// Getting vertices list
GmshReader::Keyword kw = this->__nextKeyword();
switch (kw.second) {
- // case NOD: {
- // this->__readGmsh1();
- // break;
- // }
- case MESHFORMAT: {
- double fileVersion = this->_getReal();
- if (fileVersion != 2.2) {
- throw ErrorHandler(__FILE__, __LINE__,
- "Cannot read Gmsh format '" +
- std::to_string(fileVersion) + "'",
- ErrorHandler::normal);
- }
- int fileType = this->_getInteger();
- __binary = (fileType == 1);
- if ((fileType < 0) or (fileType > 1)) {
- throw ErrorHandler(__FILE__, __LINE__,
- "Cannot read Gmsh file type '" +
- std::to_string(fileType) + "'",
- ErrorHandler::normal);
- }
-
- int dataSize = this->_getInteger();
- if (dataSize != sizeof(double)) {
- throw ErrorHandler(__FILE__, __LINE__,
- "Data size not supported '" +
- std::to_string(dataSize) + "'",
- ErrorHandler::normal);
- }
-
- if (__binary) {
- // int one=0;
-
- // fseek(__ifh,1L,SEEK_CUR);
- // fread(reinterpret_cast<char*>(&one),sizeof(int),1,__ifh);
-
- // if (one == 1) {
- // __convertEndian = false;
- // } else {
- // invertEndianess(one);
-
- // if (one == 1) {
- // __convertEndian = true;
- // } else {
- // throw ErrorHandler(__FILE__,__LINE__,
- // "Cannot determine endianess",
- // ErrorHandler::normal);
- // }
- // }
-
- // pout() << "- Binary format: ";
- // #ifdef WORDS_BIGENDIAN
- // if (not __convertEndian) {
- // pout() << "big endian\n";
- // } else {
- // pout() << "little endian\n";
- // }
- // #else // WORDS_BIGENDIAN
- // if (not __convertEndian) {
- // pout() << "little endian\n";
- // } else {
- // pout() << "big endian\n";
- // }
- // #endif // WORDS_BIGENDIAN
- }
-
- kw = this->__nextKeyword();
- if (kw.second != ENDMESHFORMAT) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': expecting $EndMeshFormat, '" + kw.first +
- "' was found",
- ErrorHandler::normal);
- }
+ // case NOD: {
+ // this->__readGmsh1();
+ // break;
+ // }
+ case MESHFORMAT: {
+ double fileVersion = this->_getReal();
+ if (fileVersion != 2.2) {
+ throw ErrorHandler(__FILE__, __LINE__, "Cannot read Gmsh format '" + std::to_string(fileVersion) + "'",
+ ErrorHandler::normal);
+ }
+ int fileType = this->_getInteger();
+ __binary = (fileType == 1);
+ if ((fileType < 0) or (fileType > 1)) {
+ throw ErrorHandler(__FILE__, __LINE__, "Cannot read Gmsh file type '" + std::to_string(fileType) + "'",
+ ErrorHandler::normal);
+ }
- this->__readGmshFormat2_2();
+ int dataSize = this->_getInteger();
+ if (dataSize != sizeof(double)) {
+ throw ErrorHandler(__FILE__, __LINE__, "Data size not supported '" + std::to_string(dataSize) + "'",
+ ErrorHandler::normal);
+ }
- break;
+ if (__binary) {
+ // int one=0;
+
+ // fseek(__ifh,1L,SEEK_CUR);
+ // fread(reinterpret_cast<char*>(&one),sizeof(int),1,__ifh);
+
+ // if (one == 1) {
+ // __convertEndian = false;
+ // } else {
+ // invertEndianess(one);
+
+ // if (one == 1) {
+ // __convertEndian = true;
+ // } else {
+ // throw ErrorHandler(__FILE__,__LINE__,
+ // "Cannot determine endianess",
+ // ErrorHandler::normal);
+ // }
+ // }
+
+ // pout() << "- Binary format: ";
+ // #ifdef WORDS_BIGENDIAN
+ // if (not __convertEndian) {
+ // pout() << "big endian\n";
+ // } else {
+ // pout() << "little endian\n";
+ // }
+ // #else // WORDS_BIGENDIAN
+ // if (not __convertEndian) {
+ // pout() << "little endian\n";
+ // } else {
+ // pout() << "big endian\n";
+ // }
+ // #endif // WORDS_BIGENDIAN
}
- default: {
+
+ kw = this->__nextKeyword();
+ if (kw.second != ENDMESHFORMAT) {
throw ErrorHandler(__FILE__, __LINE__,
- "cannot determine format version of '" +
- m_filename + "'",
+ "reading file '" + m_filename + "': expecting $EndMeshFormat, '" + kw.first +
+ "' was found",
ErrorHandler::normal);
}
+
+ this->__readGmshFormat2_2();
+
+ break;
+ }
+ default: {
+ throw ErrorHandler(__FILE__, __LINE__, "cannot determine format version of '" + m_filename + "'",
+ ErrorHandler::normal);
+ }
}
this->__proceedData();
// this->__createMesh();
- } catch (const ErrorHandler& e) {
+ }
+ catch (const ErrorHandler& e) {
e.writeErrorMessage();
std::exit(0);
}
@@ -554,22 +521,22 @@ GmshReader::GmshReader(const std::string& filename) : m_filename(filename)
return *begin(dimension_set);
}();
switch (mesh_dimension) {
- case 1: {
- this->_dispatch<1>();
- break;
- }
- case 2: {
- this->_dispatch<2>();
- break;
- }
- case 3: {
- this->_dispatch<3>();
- break;
- }
- default: {
- perr() << "unexpected dimension " << mesh_dimension << '\n';
- std::exit(1);
- }
+ case 1: {
+ this->_dispatch<1>();
+ break;
+ }
+ case 2: {
+ this->_dispatch<2>();
+ break;
+ }
+ case 3: {
+ this->_dispatch<3>();
+ break;
+ }
+ default: {
+ perr() << "unexpected dimension " << mesh_dimension << '\n';
+ std::exit(1);
+ }
}
}
}
@@ -580,9 +547,7 @@ GmshReader::__readVertices()
const int numberOfVerices = this->_getInteger();
pout() << "- Number Of Vertices: " << numberOfVerices << '\n';
if (numberOfVerices < 0) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + this->m_filename +
- "': number of vertices is negative",
+ throw ErrorHandler(__FILE__, __LINE__, "reading file '" + this->m_filename + "': number of vertices is negative",
ErrorHandler::normal);
}
@@ -676,9 +641,7 @@ GmshReader::__readElements2_2()
const int numberOfElements = this->_getInteger();
pout() << "- Number Of Elements: " << numberOfElements << '\n';
if (numberOfElements < 0) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': number of elements is negative",
+ throw ErrorHandler(__FILE__, __LINE__, "reading file '" + m_filename + "': number of elements is negative",
ErrorHandler::normal);
}
@@ -694,9 +657,8 @@ GmshReader::__readElements2_2()
if ((elementType < 0) or (elementType > 14)) {
throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': unknown element type '" +
- std::to_string(elementType) + "'",
+ "reading file '" + m_filename + "': unknown element type '" + std::to_string(elementType) +
+ "'",
ErrorHandler::normal);
}
__elementType[i] = elementType;
@@ -789,13 +751,11 @@ GmshReader::__readPhysicalNames2_2()
m_fin >> physical_name;
physical_name = std::regex_replace(physical_name, std::regex("(\")"), "");
- PhysicalRefId physical_ref_id(physical_dimension,
- RefId(physical_number, physical_name));
+ PhysicalRefId physical_ref_id(physical_dimension, RefId(physical_number, physical_name));
auto searched_physical_ref_id = m_physical_ref_map.find(physical_number);
if (searched_physical_ref_id != m_physical_ref_map.end()) {
- perr() << "Physical reference id '" << physical_ref_id
- << "' already defined as '" << searched_physical_ref_id->second
- << "'!";
+ perr() << "Physical reference id '" << physical_ref_id << "' already defined as '"
+ << searched_physical_ref_id->second << "'!";
std::exit(0);
}
m_physical_ref_map[physical_number] = physical_ref_id;
@@ -804,11 +764,9 @@ GmshReader::__readPhysicalNames2_2()
template <size_t Dimension>
void
-GmshReader::__computeCellFaceAndFaceNodeConnectivities(
- ConnectivityDescriptor& descriptor)
+GmshReader::__computeCellFaceAndFaceNodeConnectivities(ConnectivityDescriptor& descriptor)
{
- static_assert((Dimension == 2) or (Dimension == 3),
- "Invalid dimension to compute cell-face connectivities");
+ static_assert((Dimension == 2) or (Dimension == 3), "Invalid dimension to compute cell-face connectivities");
using CellFaceInfo = std::tuple<CellId, unsigned short, bool>;
using Face = ConnectivityFace<Dimension>;
@@ -820,117 +778,104 @@ GmshReader::__computeCellFaceAndFaceNodeConnectivities(
if constexpr (Dimension == 2) {
switch (descriptor.cell_type_vector[j]) {
- case CellType::Triangle: {
- cell_nb_faces[j] = 3;
- // face 0
- Face f0({cell_nodes[1], cell_nodes[2]}, node_number_vector);
- face_cells_map[f0].emplace_back(std::make_tuple(j, 0, f0.reversed()));
-
- // face 1
- Face f1({cell_nodes[2], cell_nodes[0]}, node_number_vector);
- face_cells_map[f1].emplace_back(std::make_tuple(j, 1, f1.reversed()));
-
- // face 2
- Face f2({cell_nodes[0], cell_nodes[1]}, node_number_vector);
- face_cells_map[f2].emplace_back(std::make_tuple(j, 2, f2.reversed()));
- break;
- }
- case CellType::Quadrangle: {
- cell_nb_faces[j] = 4;
- // face 0
- Face f0({cell_nodes[0], cell_nodes[1]}, node_number_vector);
- face_cells_map[f0].emplace_back(std::make_tuple(j, 0, f0.reversed()));
-
- // face 1
- Face f1({cell_nodes[1], cell_nodes[2]}, node_number_vector);
- face_cells_map[f1].emplace_back(std::make_tuple(j, 1, f1.reversed()));
-
- // face 2
- Face f2({cell_nodes[2], cell_nodes[3]}, node_number_vector);
- face_cells_map[f2].emplace_back(std::make_tuple(j, 2, f2.reversed()));
-
- // face 3
- Face f3({cell_nodes[3], cell_nodes[0]}, node_number_vector);
- face_cells_map[f3].emplace_back(std::make_tuple(j, 3, f3.reversed()));
- break;
- }
- default: {
- perr() << name(descriptor.cell_type_vector[j])
- << ": unexpected cell type in dimension 2!\n";
- std::terminate();
- }
+ case CellType::Triangle: {
+ cell_nb_faces[j] = 3;
+ // face 0
+ Face f0({cell_nodes[1], cell_nodes[2]}, node_number_vector);
+ face_cells_map[f0].emplace_back(std::make_tuple(j, 0, f0.reversed()));
+
+ // face 1
+ Face f1({cell_nodes[2], cell_nodes[0]}, node_number_vector);
+ face_cells_map[f1].emplace_back(std::make_tuple(j, 1, f1.reversed()));
+
+ // face 2
+ Face f2({cell_nodes[0], cell_nodes[1]}, node_number_vector);
+ face_cells_map[f2].emplace_back(std::make_tuple(j, 2, f2.reversed()));
+ break;
+ }
+ case CellType::Quadrangle: {
+ cell_nb_faces[j] = 4;
+ // face 0
+ Face f0({cell_nodes[0], cell_nodes[1]}, node_number_vector);
+ face_cells_map[f0].emplace_back(std::make_tuple(j, 0, f0.reversed()));
+
+ // face 1
+ Face f1({cell_nodes[1], cell_nodes[2]}, node_number_vector);
+ face_cells_map[f1].emplace_back(std::make_tuple(j, 1, f1.reversed()));
+
+ // face 2
+ Face f2({cell_nodes[2], cell_nodes[3]}, node_number_vector);
+ face_cells_map[f2].emplace_back(std::make_tuple(j, 2, f2.reversed()));
+
+ // face 3
+ Face f3({cell_nodes[3], cell_nodes[0]}, node_number_vector);
+ face_cells_map[f3].emplace_back(std::make_tuple(j, 3, f3.reversed()));
+ break;
+ }
+ default: {
+ perr() << name(descriptor.cell_type_vector[j]) << ": unexpected cell type in dimension 2!\n";
+ std::terminate();
+ }
}
} else if constexpr (Dimension == 3) {
switch (descriptor.cell_type_vector[j]) {
- case CellType::Tetrahedron: {
- cell_nb_faces[j] = 4;
- // face 0
- Face f0({cell_nodes[1], cell_nodes[2], cell_nodes[3]},
- node_number_vector);
- face_cells_map[f0].emplace_back(std::make_tuple(j, 0, f0.reversed()));
-
- // face 1
- Face f1({cell_nodes[0], cell_nodes[3], cell_nodes[2]},
- node_number_vector);
- face_cells_map[f1].emplace_back(std::make_tuple(j, 1, f1.reversed()));
-
- // face 2
- Face f2({cell_nodes[0], cell_nodes[1], cell_nodes[3]},
- node_number_vector);
- face_cells_map[f2].emplace_back(std::make_tuple(j, 2, f2.reversed()));
-
- // face 3
- Face f3({cell_nodes[0], cell_nodes[2], cell_nodes[1]},
- node_number_vector);
- face_cells_map[f3].emplace_back(std::make_tuple(j, 3, f3.reversed()));
- break;
- }
- case CellType::Hexahedron: {
- // face 0
- Face f0({cell_nodes[3], cell_nodes[2], cell_nodes[1], cell_nodes[0]},
- node_number_vector);
- face_cells_map[f0].emplace_back(std::make_tuple(j, 0, f0.reversed()));
-
- // face 1
- Face f1({cell_nodes[4], cell_nodes[5], cell_nodes[6], cell_nodes[7]},
- node_number_vector);
- face_cells_map[f1].emplace_back(std::make_tuple(j, 1, f1.reversed()));
-
- // face 2
- Face f2({cell_nodes[0], cell_nodes[4], cell_nodes[7], cell_nodes[3]},
- node_number_vector);
- face_cells_map[f2].emplace_back(std::make_tuple(j, 2, f2.reversed()));
-
- // face 3
- Face f3({cell_nodes[1], cell_nodes[2], cell_nodes[6], cell_nodes[5]},
- node_number_vector);
- face_cells_map[f3].emplace_back(std::make_tuple(j, 3, f3.reversed()));
-
- // face 4
- Face f4({cell_nodes[0], cell_nodes[1], cell_nodes[5], cell_nodes[4]},
- node_number_vector);
- face_cells_map[f4].emplace_back(std::make_tuple(j, 4, f4.reversed()));
-
- // face 5
- Face f5({cell_nodes[3], cell_nodes[7], cell_nodes[6], cell_nodes[2]},
- node_number_vector);
- face_cells_map[f5].emplace_back(std::make_tuple(j, 5, f5.reversed()));
-
- cell_nb_faces[j] = 6;
- break;
- }
- default: {
- perr() << name(descriptor.cell_type_vector[j])
- << ": unexpected cell type in dimension 3!\n";
- std::terminate();
- }
+ case CellType::Tetrahedron: {
+ cell_nb_faces[j] = 4;
+ // face 0
+ Face f0({cell_nodes[1], cell_nodes[2], cell_nodes[3]}, node_number_vector);
+ face_cells_map[f0].emplace_back(std::make_tuple(j, 0, f0.reversed()));
+
+ // face 1
+ Face f1({cell_nodes[0], cell_nodes[3], cell_nodes[2]}, node_number_vector);
+ face_cells_map[f1].emplace_back(std::make_tuple(j, 1, f1.reversed()));
+
+ // face 2
+ Face f2({cell_nodes[0], cell_nodes[1], cell_nodes[3]}, node_number_vector);
+ face_cells_map[f2].emplace_back(std::make_tuple(j, 2, f2.reversed()));
+
+ // face 3
+ Face f3({cell_nodes[0], cell_nodes[2], cell_nodes[1]}, node_number_vector);
+ face_cells_map[f3].emplace_back(std::make_tuple(j, 3, f3.reversed()));
+ break;
+ }
+ case CellType::Hexahedron: {
+ // face 0
+ Face f0({cell_nodes[3], cell_nodes[2], cell_nodes[1], cell_nodes[0]}, node_number_vector);
+ face_cells_map[f0].emplace_back(std::make_tuple(j, 0, f0.reversed()));
+
+ // face 1
+ Face f1({cell_nodes[4], cell_nodes[5], cell_nodes[6], cell_nodes[7]}, node_number_vector);
+ face_cells_map[f1].emplace_back(std::make_tuple(j, 1, f1.reversed()));
+
+ // face 2
+ Face f2({cell_nodes[0], cell_nodes[4], cell_nodes[7], cell_nodes[3]}, node_number_vector);
+ face_cells_map[f2].emplace_back(std::make_tuple(j, 2, f2.reversed()));
+
+ // face 3
+ Face f3({cell_nodes[1], cell_nodes[2], cell_nodes[6], cell_nodes[5]}, node_number_vector);
+ face_cells_map[f3].emplace_back(std::make_tuple(j, 3, f3.reversed()));
+
+ // face 4
+ Face f4({cell_nodes[0], cell_nodes[1], cell_nodes[5], cell_nodes[4]}, node_number_vector);
+ face_cells_map[f4].emplace_back(std::make_tuple(j, 4, f4.reversed()));
+
+ // face 5
+ Face f5({cell_nodes[3], cell_nodes[7], cell_nodes[6], cell_nodes[2]}, node_number_vector);
+ face_cells_map[f5].emplace_back(std::make_tuple(j, 5, f5.reversed()));
+
+ cell_nb_faces[j] = 6;
+ break;
+ }
+ default: {
+ perr() << name(descriptor.cell_type_vector[j]) << ": unexpected cell type in dimension 3!\n";
+ std::terminate();
+ }
}
}
}
{
- descriptor.cell_to_face_vector.resize(
- descriptor.cell_to_node_vector.size());
+ descriptor.cell_to_face_vector.resize(descriptor.cell_to_node_vector.size());
for (CellId j = 0; j < descriptor.cell_to_face_vector.size(); ++j) {
descriptor.cell_to_face_vector[j].resize(cell_nb_faces[j]);
}
@@ -938,7 +883,7 @@ GmshReader::__computeCellFaceAndFaceNodeConnectivities(
for (const auto& face_cells_vector : face_cells_map) {
const auto& cells_vector = face_cells_vector.second;
for (unsigned short lj = 0; lj < cells_vector.size(); ++lj) {
- const auto& [cell_number, cell_local_face, reversed] = cells_vector[lj];
+ const auto& [cell_number, cell_local_face, reversed] = cells_vector[lj];
descriptor.cell_to_face_vector[cell_number][cell_local_face] = l;
}
++l;
@@ -946,19 +891,15 @@ GmshReader::__computeCellFaceAndFaceNodeConnectivities(
}
{
- descriptor.cell_face_is_reversed_vector.resize(
- descriptor.cell_to_node_vector.size());
- for (CellId j = 0; j < descriptor.cell_face_is_reversed_vector.size();
- ++j) {
- descriptor.cell_face_is_reversed_vector[j] =
- Array<bool>(cell_nb_faces[j]);
+ descriptor.cell_face_is_reversed_vector.resize(descriptor.cell_to_node_vector.size());
+ for (CellId j = 0; j < descriptor.cell_face_is_reversed_vector.size(); ++j) {
+ descriptor.cell_face_is_reversed_vector[j] = Array<bool>(cell_nb_faces[j]);
}
for (const auto& face_cells_vector : face_cells_map) {
const auto& cells_vector = face_cells_vector.second;
for (unsigned short lj = 0; lj < cells_vector.size(); ++lj) {
- const auto& [cell_number, cell_local_face, reversed] = cells_vector[lj];
- descriptor.cell_face_is_reversed_vector[cell_number][cell_local_face] =
- reversed;
+ const auto& [cell_number, cell_local_face, reversed] = cells_vector[lj];
+ descriptor.cell_face_is_reversed_vector[cell_number][cell_local_face] = reversed;
}
}
}
@@ -984,11 +925,9 @@ GmshReader::__computeCellFaceAndFaceNodeConnectivities(
template <size_t Dimension>
void
-GmshReader::__computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(
- ConnectivityDescriptor& descriptor)
+GmshReader::__computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(ConnectivityDescriptor& descriptor)
{
- static_assert(Dimension == 3,
- "Invalid dimension to compute face-edge connectivities");
+ static_assert(Dimension == 3, "Invalid dimension to compute face-edge connectivities");
using FaceEdgeInfo = std::tuple<FaceId, unsigned short, bool>;
using Edge = ConnectivityFace<2>;
@@ -1004,17 +943,14 @@ GmshReader::__computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(
edge_faces_map[e].emplace_back(std::make_tuple(l, r, e.reversed()));
}
{
- Edge e({face_nodes[face_nodes.size() - 1], face_nodes[0]},
- node_number_vector);
- edge_faces_map[e].emplace_back(
- std::make_tuple(l, face_nodes.size() - 1, e.reversed()));
+ Edge e({face_nodes[face_nodes.size() - 1], face_nodes[0]}, node_number_vector);
+ edge_faces_map[e].emplace_back(std::make_tuple(l, face_nodes.size() - 1, e.reversed()));
}
}
std::unordered_map<Edge, EdgeId, typename Edge::Hash> edge_id_map;
{
- descriptor.face_to_edge_vector.resize(
- descriptor.face_to_node_vector.size());
+ descriptor.face_to_edge_vector.resize(descriptor.face_to_node_vector.size());
for (FaceId l = 0; l < descriptor.face_to_node_vector.size(); ++l) {
descriptor.face_to_edge_vector[l].resize(face_nb_edges[l]);
}
@@ -1022,7 +958,7 @@ GmshReader::__computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(
for (const auto& edge_faces_vector : edge_faces_map) {
const auto& faces_vector = edge_faces_vector.second;
for (unsigned short l = 0; l < faces_vector.size(); ++l) {
- const auto& [face_number, face_local_edge, reversed] = faces_vector[l];
+ const auto& [face_number, face_local_edge, reversed] = faces_vector[l];
descriptor.face_to_edge_vector[face_number][face_local_edge] = e;
}
edge_id_map[edge_faces_vector.first] = e;
@@ -1031,19 +967,15 @@ GmshReader::__computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(
}
{
- descriptor.face_edge_is_reversed_vector.resize(
- descriptor.face_to_node_vector.size());
- for (FaceId j = 0; j < descriptor.face_edge_is_reversed_vector.size();
- ++j) {
- descriptor.face_edge_is_reversed_vector[j] =
- Array<bool>(face_nb_edges[j]);
+ descriptor.face_edge_is_reversed_vector.resize(descriptor.face_to_node_vector.size());
+ for (FaceId j = 0; j < descriptor.face_edge_is_reversed_vector.size(); ++j) {
+ descriptor.face_edge_is_reversed_vector[j] = Array<bool>(face_nb_edges[j]);
}
for (const auto& edge_faces_vector : edge_faces_map) {
const auto& faces_vector = edge_faces_vector.second;
for (unsigned short lj = 0; lj < faces_vector.size(); ++lj) {
- const auto& [face_number, face_local_edge, reversed] = faces_vector[lj];
- descriptor.face_edge_is_reversed_vector[face_number][face_local_edge] =
- reversed;
+ const auto& [face_number, face_local_edge, reversed] = faces_vector[lj];
+ descriptor.face_edge_is_reversed_vector[face_number][face_local_edge] = reversed;
}
}
}
@@ -1067,54 +999,50 @@ GmshReader::__computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(
}
{
- descriptor.cell_to_node_vector.reserve(
- descriptor.cell_to_node_vector.size());
+ descriptor.cell_to_node_vector.reserve(descriptor.cell_to_node_vector.size());
for (CellId j = 0; j < descriptor.cell_to_node_vector.size(); ++j) {
const auto& cell_nodes = descriptor.cell_to_node_vector[j];
switch (descriptor.cell_type_vector[j]) {
- case CellType::Tetrahedron: {
- constexpr int local_edge[6][2] = {{0, 1}, {0, 2}, {0, 3},
- {1, 2}, {2, 3}, {3, 1}};
- std::vector<unsigned int> cell_edge_vector;
- cell_edge_vector.reserve(6);
- for (int i_edge = 0; i_edge < 6; ++i_edge) {
- const auto e = local_edge[i_edge];
- Edge edge{{cell_nodes[e[0]], cell_nodes[e[1]]}, node_number_vector};
- auto i = edge_id_map.find(edge);
- if (i == edge_id_map.end()) {
- std::cerr << "could not find this edge!\n";
- std::terminate();
- }
- cell_edge_vector.push_back(i->second);
+ case CellType::Tetrahedron: {
+ constexpr int local_edge[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {2, 3}, {3, 1}};
+ std::vector<unsigned int> cell_edge_vector;
+ cell_edge_vector.reserve(6);
+ for (int i_edge = 0; i_edge < 6; ++i_edge) {
+ const auto e = local_edge[i_edge];
+ Edge edge{{cell_nodes[e[0]], cell_nodes[e[1]]}, node_number_vector};
+ auto i = edge_id_map.find(edge);
+ if (i == edge_id_map.end()) {
+ std::cerr << "could not find this edge!\n";
+ std::terminate();
}
- descriptor.cell_to_edge_vector.emplace_back(cell_edge_vector);
- break;
+ cell_edge_vector.push_back(i->second);
}
- case CellType::Hexahedron: {
- constexpr int local_edge[12][2] = {{0, 1}, {1, 2}, {2, 3}, {3, 0},
- {4, 5}, {5, 6}, {6, 7}, {7, 4},
- {0, 4}, {1, 5}, {2, 6}, {3, 7}};
- std::vector<unsigned int> cell_edge_vector;
- cell_edge_vector.reserve(12);
- for (int i_edge = 0; i_edge < 12; ++i_edge) {
- const auto e = local_edge[i_edge];
- Edge edge{{cell_nodes[e[0]], cell_nodes[e[1]]}, node_number_vector};
- auto i = edge_id_map.find(edge);
- if (i == edge_id_map.end()) {
- std::cerr << "could not find this edge!\n";
- std::terminate();
- }
- cell_edge_vector.push_back(i->second);
+ descriptor.cell_to_edge_vector.emplace_back(cell_edge_vector);
+ break;
+ }
+ case CellType::Hexahedron: {
+ constexpr int local_edge[12][2] = {{0, 1}, {1, 2}, {2, 3}, {3, 0}, {4, 5}, {5, 6},
+ {6, 7}, {7, 4}, {0, 4}, {1, 5}, {2, 6}, {3, 7}};
+ std::vector<unsigned int> cell_edge_vector;
+ cell_edge_vector.reserve(12);
+ for (int i_edge = 0; i_edge < 12; ++i_edge) {
+ const auto e = local_edge[i_edge];
+ Edge edge{{cell_nodes[e[0]], cell_nodes[e[1]]}, node_number_vector};
+ auto i = edge_id_map.find(edge);
+ if (i == edge_id_map.end()) {
+ std::cerr << "could not find this edge!\n";
+ std::terminate();
}
- descriptor.cell_to_edge_vector.emplace_back(cell_edge_vector);
- break;
- }
- default: {
- perr() << name(descriptor.cell_type_vector[j])
- << ": unexpected cell type in dimension 3!\n";
- std::terminate();
+ cell_edge_vector.push_back(i->second);
}
+ descriptor.cell_to_edge_vector.emplace_back(cell_edge_vector);
+ break;
+ }
+ default: {
+ perr() << name(descriptor.cell_type_vector[j]) << ": unexpected cell type in dimension 3!\n";
+ std::terminate();
+ }
}
}
}
@@ -1134,75 +1062,71 @@ GmshReader::__proceedData()
for (size_t i = 0; i < elementNumber.dimension(); ++i) {
if (elementNumber[i] > 0) {
- pout() << " - Number of " << __primitivesNames[i] << ": "
- << elementNumber[i];
+ pout() << " - Number of " << __primitivesNames[i] << ": " << elementNumber[i];
if (not(__supportedPrimitives[i])) {
- pout() << " [" << rang::fg::yellow << "IGNORED" << rang::style::reset
- << "]";
+ pout() << " [" << rang::fg::yellow << "IGNORED" << rang::style::reset << "]";
} else {
pout() << " references: ";
- for (std::set<size_t>::const_iterator iref =
- elementReferences[i].begin();
- iref != elementReferences[i].end(); ++iref) {
+ for (std::set<size_t>::const_iterator iref = elementReferences[i].begin(); iref != elementReferences[i].end();
+ ++iref) {
if (iref != elementReferences[i].begin())
pout() << ',';
pout() << *iref;
}
switch (i) {
- // Supported entities
- case 0: { // edges
- __edges = Array<Edge>(elementNumber[i]);
- __edges_ref.resize(elementNumber[i]);
- __edges_number.resize(elementNumber[i]);
- break;
- }
- case 1: { // triangles
- __triangles = Array<Triangle>(elementNumber[i]);
- __triangles_ref.resize(elementNumber[i]);
- __triangles_number.resize(elementNumber[i]);
- break;
- }
- case 2: { // quadrangles
- __quadrangles = Array<Quadrangle>(elementNumber[i]);
- __quadrangles_ref.resize(elementNumber[i]);
- __quadrangles_number.resize(elementNumber[i]);
- break;
- }
- case 3: { // tetrahedra
- __tetrahedra = Array<Tetrahedron>(elementNumber[i]);
- __tetrahedra_ref.resize(elementNumber[i]);
- __tetrahedra_number.resize(elementNumber[i]);
- break;
- }
- case 4: { // hexahedra
- __hexahedra = Array<Hexahedron>(elementNumber[i]);
- __hexahedra_ref.resize(elementNumber[i]);
- __hexahedra_number.resize(elementNumber[i]);
- break;
- }
- case 14: { // point
- __points = Array<Point>(elementNumber[i]);
- __points_ref.resize(elementNumber[i]);
- __points_number.resize(elementNumber[i]);
- break;
- }
- // Unsupported entities
- case 5: // prism
- case 6: // pyramid
- case 7: // second order edge
- case 8: // second order triangle
- case 9: // second order quadrangle
- case 10: // second order tetrahedron
- case 11: // second order hexahedron
- case 12: // second order prism
- case 13: // second order pyramid
- default: {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': ff3d cannot read this kind of element",
- ErrorHandler::normal);
- }
+ // Supported entities
+ case 0: { // edges
+ __edges = Array<Edge>(elementNumber[i]);
+ __edges_ref.resize(elementNumber[i]);
+ __edges_number.resize(elementNumber[i]);
+ break;
+ }
+ case 1: { // triangles
+ __triangles = Array<Triangle>(elementNumber[i]);
+ __triangles_ref.resize(elementNumber[i]);
+ __triangles_number.resize(elementNumber[i]);
+ break;
+ }
+ case 2: { // quadrangles
+ __quadrangles = Array<Quadrangle>(elementNumber[i]);
+ __quadrangles_ref.resize(elementNumber[i]);
+ __quadrangles_number.resize(elementNumber[i]);
+ break;
+ }
+ case 3: { // tetrahedra
+ __tetrahedra = Array<Tetrahedron>(elementNumber[i]);
+ __tetrahedra_ref.resize(elementNumber[i]);
+ __tetrahedra_number.resize(elementNumber[i]);
+ break;
+ }
+ case 4: { // hexahedra
+ __hexahedra = Array<Hexahedron>(elementNumber[i]);
+ __hexahedra_ref.resize(elementNumber[i]);
+ __hexahedra_number.resize(elementNumber[i]);
+ break;
+ }
+ case 14: { // point
+ __points = Array<Point>(elementNumber[i]);
+ __points_ref.resize(elementNumber[i]);
+ __points_number.resize(elementNumber[i]);
+ break;
+ }
+ // Unsupported entities
+ case 5: // prism
+ case 6: // pyramid
+ case 7: // second order edge
+ case 8: // second order triangle
+ case 9: // second order quadrangle
+ case 10: // second order tetrahedron
+ case 11: // second order hexahedron
+ case 12: // second order prism
+ case 13: // second order pyramid
+ default: {
+ throw ErrorHandler(__FILE__, __LINE__,
+ "reading file '" + m_filename + "': ff3d cannot read this kind of element",
+ ErrorHandler::normal);
+ }
}
}
pout() << '\n';
@@ -1221,7 +1145,8 @@ GmshReader::__proceedData()
if (minNumber < 0) {
throw ErrorHandler(__FILE__, __LINE__,
"reading file '" + m_filename +
- "': ff3d does not implement negative vertices number",
+ "': ff3d does not implement negative vertices "
+ "number",
ErrorHandler::normal);
}
@@ -1239,134 +1164,126 @@ GmshReader::__proceedData()
for (size_t i = 0; i < __elementType.size(); ++i) {
std::vector<int>& elementVertices = __elementVertices[i];
switch (__elementType[i]) {
- // Supported entities
- case 0: { // edge
- int& edgeNumber = elementNumber[0];
- const int a = __verticesCorrepondance[elementVertices[0]];
- const int b = __verticesCorrepondance[elementVertices[1]];
- if ((a < 0) or (b < 0)) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': error reading element " + std::to_string(i) +
- " [bad vertices definition]",
- ErrorHandler::normal);
- }
- __edges[edgeNumber] = Edge(a, b);
- __edges_ref[edgeNumber] = __references[i];
- __edges_number[edgeNumber] = __elementNumber[i];
- edgeNumber++; // one more edge
- break;
+ // Supported entities
+ case 0: { // edge
+ int& edgeNumber = elementNumber[0];
+ const int a = __verticesCorrepondance[elementVertices[0]];
+ const int b = __verticesCorrepondance[elementVertices[1]];
+ if ((a < 0) or (b < 0)) {
+ throw ErrorHandler(__FILE__, __LINE__,
+ "reading file '" + m_filename + "': error reading element " + std::to_string(i) +
+ " [bad vertices definition]",
+ ErrorHandler::normal);
}
- case 1: { // triangles
- int& triangleNumber = elementNumber[1];
+ __edges[edgeNumber] = Edge(a, b);
+ __edges_ref[edgeNumber] = __references[i];
+ __edges_number[edgeNumber] = __elementNumber[i];
+ edgeNumber++; // one more edge
+ break;
+ }
+ case 1: { // triangles
+ int& triangleNumber = elementNumber[1];
- const int a = __verticesCorrepondance[elementVertices[0]];
- const int b = __verticesCorrepondance[elementVertices[1]];
- const int c = __verticesCorrepondance[elementVertices[2]];
- if ((a < 0) or (b < 0) or (c < 0)) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': error reading element " + std::to_string(i) +
- " [bad vertices definition]",
- ErrorHandler::normal);
- }
- __triangles[triangleNumber] = Triangle(a, b, c);
- __triangles_ref[triangleNumber] = __references[i];
- __triangles_number[triangleNumber] = __elementNumber[i];
- triangleNumber++; // one more triangle
- break;
- }
- case 2: { // quadrangle
- int& quadrilateralNumber = elementNumber[2];
-
- const int a = __verticesCorrepondance[elementVertices[0]];
- const int b = __verticesCorrepondance[elementVertices[1]];
- const int c = __verticesCorrepondance[elementVertices[2]];
- const int d = __verticesCorrepondance[elementVertices[3]];
- if ((a < 0) or (b < 0) or (c < 0) or (d < 0)) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': error reading element " + std::to_string(i) +
- " [bad vertices definition]",
- ErrorHandler::normal);
- }
- __quadrangles[quadrilateralNumber] = Quadrangle(a, b, c, d);
- __quadrangles_ref[quadrilateralNumber] = __references[i];
- __quadrangles_number[quadrilateralNumber] = __elementNumber[i];
- quadrilateralNumber++; // one more quadrangle
- break;
- }
- case 3: { // tetrahedra
- int& tetrahedronNumber = elementNumber[3];
-
- const int a = __verticesCorrepondance[elementVertices[0]];
- const int b = __verticesCorrepondance[elementVertices[1]];
- const int c = __verticesCorrepondance[elementVertices[2]];
- const int d = __verticesCorrepondance[elementVertices[3]];
- if ((a < 0) or (b < 0) or (c < 0) or (d < 0)) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': error reading element " + std::to_string(i) +
- " [bad vertices definition]",
- ErrorHandler::normal);
- }
- __tetrahedra[tetrahedronNumber] = Tetrahedron(a, b, c, d);
- __tetrahedra_ref[tetrahedronNumber] = __references[i];
- __tetrahedra_number[tetrahedronNumber] = __elementNumber[i];
- tetrahedronNumber++; // one more tetrahedron
- break;
- }
- case 4: { // hexaredron
- int& hexahedronNumber = elementNumber[4];
-
- const int a = __verticesCorrepondance[elementVertices[0]];
- const int b = __verticesCorrepondance[elementVertices[1]];
- const int c = __verticesCorrepondance[elementVertices[2]];
- const int d = __verticesCorrepondance[elementVertices[3]];
- const int e = __verticesCorrepondance[elementVertices[4]];
- const int f = __verticesCorrepondance[elementVertices[5]];
- const int g = __verticesCorrepondance[elementVertices[6]];
- const int h = __verticesCorrepondance[elementVertices[7]];
- if ((a < 0) or (b < 0) or (c < 0) or (d < 0) or (e < 0) or (f < 0) or
- (g < 0) or (h < 0)) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': error reading element " + std::to_string(i) +
- " [bad vertices definition]",
- ErrorHandler::normal);
- }
- __hexahedra[hexahedronNumber] = Hexahedron(a, b, c, d, e, f, g, h);
- __hexahedra_ref[hexahedronNumber] = __references[i];
- __hexahedra_number[hexahedronNumber] = __elementNumber[i];
- hexahedronNumber++; // one more hexahedron
- break;
+ const int a = __verticesCorrepondance[elementVertices[0]];
+ const int b = __verticesCorrepondance[elementVertices[1]];
+ const int c = __verticesCorrepondance[elementVertices[2]];
+ if ((a < 0) or (b < 0) or (c < 0)) {
+ throw ErrorHandler(__FILE__, __LINE__,
+ "reading file '" + m_filename + "': error reading element " + std::to_string(i) +
+ " [bad vertices definition]",
+ ErrorHandler::normal);
}
- // Unsupported entities
- case 14: { // point
- int& point_number = elementNumber[14];
- const int a = __verticesCorrepondance[elementVertices[0]];
- __points[point_number] = a;
- __points_ref[point_number] = __references[i];
- __points_number[point_number] = __elementNumber[i];
- point_number++;
- break;
+ __triangles[triangleNumber] = Triangle(a, b, c);
+ __triangles_ref[triangleNumber] = __references[i];
+ __triangles_number[triangleNumber] = __elementNumber[i];
+ triangleNumber++; // one more triangle
+ break;
+ }
+ case 2: { // quadrangle
+ int& quadrilateralNumber = elementNumber[2];
+
+ const int a = __verticesCorrepondance[elementVertices[0]];
+ const int b = __verticesCorrepondance[elementVertices[1]];
+ const int c = __verticesCorrepondance[elementVertices[2]];
+ const int d = __verticesCorrepondance[elementVertices[3]];
+ if ((a < 0) or (b < 0) or (c < 0) or (d < 0)) {
+ throw ErrorHandler(__FILE__, __LINE__,
+ "reading file '" + m_filename + "': error reading element " + std::to_string(i) +
+ " [bad vertices definition]",
+ ErrorHandler::normal);
}
- case 5: // prism
- case 6: // pyramid
- case 7: // second order edge
- case 8: // second order triangle
- case 9: // second order quadrangle
- case 10: // second order tetrahedron
- case 11: // second order hexahedron
- case 12: // second order prism
- case 13: { // second order pyramid
+ __quadrangles[quadrilateralNumber] = Quadrangle(a, b, c, d);
+ __quadrangles_ref[quadrilateralNumber] = __references[i];
+ __quadrangles_number[quadrilateralNumber] = __elementNumber[i];
+ quadrilateralNumber++; // one more quadrangle
+ break;
+ }
+ case 3: { // tetrahedra
+ int& tetrahedronNumber = elementNumber[3];
+
+ const int a = __verticesCorrepondance[elementVertices[0]];
+ const int b = __verticesCorrepondance[elementVertices[1]];
+ const int c = __verticesCorrepondance[elementVertices[2]];
+ const int d = __verticesCorrepondance[elementVertices[3]];
+ if ((a < 0) or (b < 0) or (c < 0) or (d < 0)) {
+ throw ErrorHandler(__FILE__, __LINE__,
+ "reading file '" + m_filename + "': error reading element " + std::to_string(i) +
+ " [bad vertices definition]",
+ ErrorHandler::normal);
}
- default: {
+ __tetrahedra[tetrahedronNumber] = Tetrahedron(a, b, c, d);
+ __tetrahedra_ref[tetrahedronNumber] = __references[i];
+ __tetrahedra_number[tetrahedronNumber] = __elementNumber[i];
+ tetrahedronNumber++; // one more tetrahedron
+ break;
+ }
+ case 4: { // hexaredron
+ int& hexahedronNumber = elementNumber[4];
+
+ const int a = __verticesCorrepondance[elementVertices[0]];
+ const int b = __verticesCorrepondance[elementVertices[1]];
+ const int c = __verticesCorrepondance[elementVertices[2]];
+ const int d = __verticesCorrepondance[elementVertices[3]];
+ const int e = __verticesCorrepondance[elementVertices[4]];
+ const int f = __verticesCorrepondance[elementVertices[5]];
+ const int g = __verticesCorrepondance[elementVertices[6]];
+ const int h = __verticesCorrepondance[elementVertices[7]];
+ if ((a < 0) or (b < 0) or (c < 0) or (d < 0) or (e < 0) or (f < 0) or (g < 0) or (h < 0)) {
throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': ff3d cannot read this kind of element",
+ "reading file '" + m_filename + "': error reading element " + std::to_string(i) +
+ " [bad vertices definition]",
ErrorHandler::normal);
}
+ __hexahedra[hexahedronNumber] = Hexahedron(a, b, c, d, e, f, g, h);
+ __hexahedra_ref[hexahedronNumber] = __references[i];
+ __hexahedra_number[hexahedronNumber] = __elementNumber[i];
+ hexahedronNumber++; // one more hexahedron
+ break;
+ }
+ // Unsupported entities
+ case 14: { // point
+ int& point_number = elementNumber[14];
+ const int a = __verticesCorrepondance[elementVertices[0]];
+ __points[point_number] = a;
+ __points_ref[point_number] = __references[i];
+ __points_number[point_number] = __elementNumber[i];
+ point_number++;
+ break;
+ }
+ case 5: // prism
+ case 6: // pyramid
+ case 7: // second order edge
+ case 8: // second order triangle
+ case 9: // second order quadrangle
+ case 10: // second order tetrahedron
+ case 11: // second order hexahedron
+ case 12: // second order prism
+ case 13: { // second order pyramid
+ }
+ default: {
+ throw ErrorHandler(__FILE__, __LINE__, "reading file '" + m_filename + "': ff3d cannot read this kind of element",
+ ErrorHandler::normal);
+ }
}
}
@@ -1390,14 +1307,10 @@ GmshReader::__proceedData()
dimension3_mask[12] = 1;
dimension3_mask[13] = 1;
- pout() << "- dimension 0 entities: " << (dimension0_mask, elementNumber)
- << '\n';
- pout() << "- dimension 1 entities: " << (dimension1_mask, elementNumber)
- << '\n';
- pout() << "- dimension 2 entities: " << (dimension2_mask, elementNumber)
- << '\n';
- pout() << "- dimension 3 entities: " << (dimension3_mask, elementNumber)
- << '\n';
+ pout() << "- dimension 0 entities: " << (dimension0_mask, elementNumber) << '\n';
+ pout() << "- dimension 1 entities: " << (dimension1_mask, elementNumber) << '\n';
+ pout() << "- dimension 2 entities: " << (dimension2_mask, elementNumber) << '\n';
+ pout() << "- dimension 3 entities: " << (dimension3_mask, elementNumber) << '\n';
if ((dimension3_mask, elementNumber) > 0) {
const size_t nb_cells = (dimension3_mask, elementNumber);
@@ -1446,10 +1359,8 @@ GmshReader::__proceedData()
for (size_t j = 0; j < ref_cell_list.second.size(); ++j) {
cell_list[j] = ref_cell_list.second[j];
}
- const PhysicalRefId& physical_ref_id =
- m_physical_ref_map.at(ref_cell_list.first);
- descriptor.addRefItemList(
- RefCellList(physical_ref_id.refId(), cell_list));
+ const PhysicalRefId& physical_ref_id = m_physical_ref_map.at(ref_cell_list.first);
+ descriptor.addRefItemList(RefCellList(physical_ref_id.refId(), cell_list));
}
this->__computeCellFaceAndFaceNodeConnectivities<3>(descriptor);
@@ -1457,33 +1368,30 @@ GmshReader::__proceedData()
const auto& node_number_vector = descriptor.node_number_vector;
{
- using Face = ConnectivityFace<3>;
- const std::unordered_map<Face, FaceId, typename Face::Hash>
- face_to_id_map = [&] {
- std::unordered_map<Face, FaceId, typename Face::Hash> face_to_id_map;
- for (FaceId l = 0; l < descriptor.face_to_node_vector.size(); ++l) {
- const auto& node_vector = descriptor.face_to_node_vector[l];
- face_to_id_map[Face(node_vector, node_number_vector)] = l;
- }
- return face_to_id_map;
- }();
+ using Face = ConnectivityFace<3>;
+ const std::unordered_map<Face, FaceId, typename Face::Hash> face_to_id_map = [&] {
+ std::unordered_map<Face, FaceId, typename Face::Hash> face_to_id_map;
+ for (FaceId l = 0; l < descriptor.face_to_node_vector.size(); ++l) {
+ const auto& node_vector = descriptor.face_to_node_vector[l];
+ face_to_id_map[Face(node_vector, node_number_vector)] = l;
+ }
+ return face_to_id_map;
+ }();
std::unordered_map<int, FaceId> face_number_id_map = [&] {
std::unordered_map<int, FaceId> face_number_id_map;
for (size_t l = 0; l < descriptor.face_number_vector.size(); ++l) {
face_number_id_map[descriptor.face_number_vector[l]] = l;
}
- Assert(face_number_id_map.size() ==
- descriptor.face_number_vector.size());
+ Assert(face_number_id_map.size() == descriptor.face_number_vector.size());
return face_number_id_map;
}();
std::map<unsigned int, std::vector<unsigned int>> ref_faces_map;
for (unsigned int f = 0; f < __triangles.size(); ++f) {
const unsigned int face_id = [&] {
- auto i = face_to_id_map.find(
- Face({__triangles[f][0], __triangles[f][1], __triangles[f][2]},
- node_number_vector));
+ auto i =
+ face_to_id_map.find(Face({__triangles[f][0], __triangles[f][1], __triangles[f][2]}, node_number_vector));
if (i == face_to_id_map.end()) {
std::cerr << "face not found!\n";
std::terminate();
@@ -1495,35 +1403,28 @@ GmshReader::__proceedData()
ref_faces_map[ref].push_back(face_id);
if (descriptor.face_number_vector[face_id] != __quadrangles_number[f]) {
- if (auto i_face = face_number_id_map.find(__quadrangles_number[f]);
- i_face != face_number_id_map.end()) {
+ if (auto i_face = face_number_id_map.find(__quadrangles_number[f]); i_face != face_number_id_map.end()) {
const int other_face_id = i_face->second;
- std::swap(descriptor.face_number_vector[face_id],
- descriptor.face_number_vector[other_face_id]);
+ std::swap(descriptor.face_number_vector[face_id], descriptor.face_number_vector[other_face_id]);
face_number_id_map.erase(descriptor.face_number_vector[face_id]);
- face_number_id_map.erase(
- descriptor.face_number_vector[other_face_id]);
+ face_number_id_map.erase(descriptor.face_number_vector[other_face_id]);
- face_number_id_map[descriptor.face_number_vector[face_id]] =
- face_id;
- face_number_id_map[descriptor.face_number_vector[other_face_id]] =
- other_face_id;
+ face_number_id_map[descriptor.face_number_vector[face_id]] = face_id;
+ face_number_id_map[descriptor.face_number_vector[other_face_id]] = other_face_id;
} else {
face_number_id_map.erase(descriptor.face_number_vector[face_id]);
- descriptor.face_number_vector[face_id] = __quadrangles_number[f];
- face_number_id_map[descriptor.face_number_vector[face_id]] =
- face_id;
+ descriptor.face_number_vector[face_id] = __quadrangles_number[f];
+ face_number_id_map[descriptor.face_number_vector[face_id]] = face_id;
}
}
}
for (unsigned int f = 0; f < __quadrangles.size(); ++f) {
const unsigned int face_id = [&] {
- auto i =
- face_to_id_map.find(Face({__quadrangles[f][0], __quadrangles[f][1],
- __quadrangles[f][2], __quadrangles[f][3]},
- node_number_vector));
+ auto i = face_to_id_map.find(
+ Face({__quadrangles[f][0], __quadrangles[f][1], __quadrangles[f][2], __quadrangles[f][3]},
+ node_number_vector));
if (i == face_to_id_map.end()) {
std::cerr << "face not found!\n";
std::terminate();
@@ -1535,25 +1436,19 @@ GmshReader::__proceedData()
ref_faces_map[ref].push_back(face_id);
if (descriptor.face_number_vector[face_id] != __quadrangles_number[f]) {
- if (auto i_face = face_number_id_map.find(__quadrangles_number[f]);
- i_face != face_number_id_map.end()) {
+ if (auto i_face = face_number_id_map.find(__quadrangles_number[f]); i_face != face_number_id_map.end()) {
const int other_face_id = i_face->second;
- std::swap(descriptor.face_number_vector[face_id],
- descriptor.face_number_vector[other_face_id]);
+ std::swap(descriptor.face_number_vector[face_id], descriptor.face_number_vector[other_face_id]);
face_number_id_map.erase(descriptor.face_number_vector[face_id]);
- face_number_id_map.erase(
- descriptor.face_number_vector[other_face_id]);
+ face_number_id_map.erase(descriptor.face_number_vector[other_face_id]);
- face_number_id_map[descriptor.face_number_vector[face_id]] =
- face_id;
- face_number_id_map[descriptor.face_number_vector[other_face_id]] =
- other_face_id;
+ face_number_id_map[descriptor.face_number_vector[face_id]] = face_id;
+ face_number_id_map[descriptor.face_number_vector[other_face_id]] = other_face_id;
} else {
face_number_id_map.erase(descriptor.face_number_vector[face_id]);
- descriptor.face_number_vector[face_id] = __quadrangles_number[f];
- face_number_id_map[descriptor.face_number_vector[face_id]] =
- face_id;
+ descriptor.face_number_vector[face_id] = __quadrangles_number[f];
+ face_number_id_map[descriptor.face_number_vector[face_id]] = face_id;
}
}
}
@@ -1563,42 +1458,37 @@ GmshReader::__proceedData()
for (size_t j = 0; j < ref_face_list.second.size(); ++j) {
face_list[j] = ref_face_list.second[j];
}
- const PhysicalRefId& physical_ref_id =
- m_physical_ref_map.at(ref_face_list.first);
- descriptor.addRefItemList(
- RefFaceList{physical_ref_id.refId(), face_list});
+ const PhysicalRefId& physical_ref_id = m_physical_ref_map.at(ref_face_list.first);
+ descriptor.addRefItemList(RefFaceList{physical_ref_id.refId(), face_list});
}
}
this->__computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities<3>(descriptor);
{
- using Edge = ConnectivityFace<2>;
- const auto& node_number_vector = descriptor.node_number_vector;
- const std::unordered_map<Edge, EdgeId, typename Edge::Hash>
- edge_to_id_map = [&] {
- std::unordered_map<Edge, EdgeId, typename Edge::Hash> edge_to_id_map;
- for (EdgeId l = 0; l < descriptor.edge_to_node_vector.size(); ++l) {
- const auto& node_vector = descriptor.edge_to_node_vector[l];
- edge_to_id_map[Edge(node_vector, node_number_vector)] = l;
- }
- return edge_to_id_map;
- }();
+ using Edge = ConnectivityFace<2>;
+ const auto& node_number_vector = descriptor.node_number_vector;
+ const std::unordered_map<Edge, EdgeId, typename Edge::Hash> edge_to_id_map = [&] {
+ std::unordered_map<Edge, EdgeId, typename Edge::Hash> edge_to_id_map;
+ for (EdgeId l = 0; l < descriptor.edge_to_node_vector.size(); ++l) {
+ const auto& node_vector = descriptor.edge_to_node_vector[l];
+ edge_to_id_map[Edge(node_vector, node_number_vector)] = l;
+ }
+ return edge_to_id_map;
+ }();
std::unordered_map<int, EdgeId> edge_number_id_map = [&] {
std::unordered_map<int, EdgeId> edge_number_id_map;
for (size_t l = 0; l < descriptor.edge_number_vector.size(); ++l) {
edge_number_id_map[descriptor.edge_number_vector[l]] = l;
}
- Assert(edge_number_id_map.size() ==
- descriptor.edge_number_vector.size());
+ Assert(edge_number_id_map.size() == descriptor.edge_number_vector.size());
return edge_number_id_map;
}();
std::map<unsigned int, std::vector<unsigned int>> ref_edges_map;
for (unsigned int e = 0; e < __edges.size(); ++e) {
const unsigned int edge_id = [&] {
- auto i = edge_to_id_map.find(
- Edge({__edges[e][0], __edges[e][1]}, node_number_vector));
+ auto i = edge_to_id_map.find(Edge({__edges[e][0], __edges[e][1]}, node_number_vector));
if (i == edge_to_id_map.end()) {
std::cerr << "edge " << __edges[e][0] << " not found!\n";
std::terminate();
@@ -1609,25 +1499,19 @@ GmshReader::__proceedData()
ref_edges_map[ref].push_back(edge_id);
if (descriptor.edge_number_vector[edge_id] != __edges_number[e]) {
- if (auto i_edge = edge_number_id_map.find(__edges_number[e]);
- i_edge != edge_number_id_map.end()) {
+ if (auto i_edge = edge_number_id_map.find(__edges_number[e]); i_edge != edge_number_id_map.end()) {
const int other_edge_id = i_edge->second;
- std::swap(descriptor.edge_number_vector[edge_id],
- descriptor.edge_number_vector[other_edge_id]);
+ std::swap(descriptor.edge_number_vector[edge_id], descriptor.edge_number_vector[other_edge_id]);
edge_number_id_map.erase(descriptor.edge_number_vector[edge_id]);
- edge_number_id_map.erase(
- descriptor.edge_number_vector[other_edge_id]);
+ edge_number_id_map.erase(descriptor.edge_number_vector[other_edge_id]);
- edge_number_id_map[descriptor.edge_number_vector[edge_id]] =
- edge_id;
- edge_number_id_map[descriptor.edge_number_vector[other_edge_id]] =
- other_edge_id;
+ edge_number_id_map[descriptor.edge_number_vector[edge_id]] = edge_id;
+ edge_number_id_map[descriptor.edge_number_vector[other_edge_id]] = other_edge_id;
} else {
edge_number_id_map.erase(descriptor.edge_number_vector[edge_id]);
- descriptor.edge_number_vector[edge_id] = __edges_number[e];
- edge_number_id_map[descriptor.edge_number_vector[edge_id]] =
- edge_id;
+ descriptor.edge_number_vector[edge_id] = __edges_number[e];
+ edge_number_id_map[descriptor.edge_number_vector[edge_id]] = edge_id;
}
}
}
@@ -1637,10 +1521,8 @@ GmshReader::__proceedData()
for (size_t j = 0; j < ref_edge_list.second.size(); ++j) {
edge_list[j] = ref_edge_list.second[j];
}
- const PhysicalRefId& physical_ref_id =
- m_physical_ref_map.at(ref_edge_list.first);
- descriptor.addRefItemList(
- RefEdgeList{physical_ref_id.refId(), edge_list});
+ const PhysicalRefId& physical_ref_id = m_physical_ref_map.at(ref_edge_list.first);
+ descriptor.addRefItemList(RefEdgeList{physical_ref_id.refId(), edge_list});
}
}
@@ -1656,27 +1538,21 @@ GmshReader::__proceedData()
for (size_t j = 0; j < ref_point_list.second.size(); ++j) {
point_list[j] = ref_point_list.second[j];
}
- const PhysicalRefId& physical_ref_id =
- m_physical_ref_map.at(ref_point_list.first);
- descriptor.addRefItemList(
- RefNodeList(physical_ref_id.refId(), point_list));
+ const PhysicalRefId& physical_ref_id = m_physical_ref_map.at(ref_point_list.first);
+ descriptor.addRefItemList(RefNodeList(physical_ref_id.refId(), point_list));
}
descriptor.cell_owner_vector.resize(nb_cells);
- std::fill(descriptor.cell_owner_vector.begin(),
- descriptor.cell_owner_vector.end(), parallel::rank());
+ std::fill(descriptor.cell_owner_vector.begin(), descriptor.cell_owner_vector.end(), parallel::rank());
descriptor.face_owner_vector.resize(descriptor.face_number_vector.size());
- std::fill(descriptor.face_owner_vector.begin(),
- descriptor.face_owner_vector.end(), parallel::rank());
+ std::fill(descriptor.face_owner_vector.begin(), descriptor.face_owner_vector.end(), parallel::rank());
descriptor.edge_owner_vector.resize(descriptor.edge_number_vector.size());
- std::fill(descriptor.edge_owner_vector.begin(),
- descriptor.edge_owner_vector.end(), parallel::rank());
+ std::fill(descriptor.edge_owner_vector.begin(), descriptor.edge_owner_vector.end(), parallel::rank());
descriptor.node_owner_vector.resize(descriptor.node_number_vector.size());
- std::fill(descriptor.node_owner_vector.begin(),
- descriptor.node_owner_vector.end(), parallel::rank());
+ std::fill(descriptor.node_owner_vector.begin(), descriptor.node_owner_vector.end(), parallel::rank());
std::shared_ptr p_connectivity = Connectivity3D::build(descriptor);
Connectivity3D& connectivity = *p_connectivity;
@@ -1741,25 +1617,22 @@ GmshReader::__proceedData()
for (size_t j = 0; j < ref_cell_list.second.size(); ++j) {
cell_list[j] = ref_cell_list.second[j];
}
- const PhysicalRefId& physical_ref_id =
- m_physical_ref_map.at(ref_cell_list.first);
- descriptor.addRefItemList(
- RefCellList(physical_ref_id.refId(), cell_list));
+ const PhysicalRefId& physical_ref_id = m_physical_ref_map.at(ref_cell_list.first);
+ descriptor.addRefItemList(RefCellList(physical_ref_id.refId(), cell_list));
}
this->__computeCellFaceAndFaceNodeConnectivities<2>(descriptor);
- using Face = ConnectivityFace<2>;
- const auto& node_number_vector = descriptor.node_number_vector;
- const std::unordered_map<Face, FaceId, typename Face::Hash> face_to_id_map =
- [&] {
- std::unordered_map<Face, FaceId, typename Face::Hash> face_to_id_map;
- for (FaceId l = 0; l < descriptor.face_to_node_vector.size(); ++l) {
- const auto& node_vector = descriptor.face_to_node_vector[l];
- face_to_id_map[Face(node_vector, node_number_vector)] = l;
- }
- return face_to_id_map;
- }();
+ using Face = ConnectivityFace<2>;
+ const auto& node_number_vector = descriptor.node_number_vector;
+ const std::unordered_map<Face, FaceId, typename Face::Hash> face_to_id_map = [&] {
+ std::unordered_map<Face, FaceId, typename Face::Hash> face_to_id_map;
+ for (FaceId l = 0; l < descriptor.face_to_node_vector.size(); ++l) {
+ const auto& node_vector = descriptor.face_to_node_vector[l];
+ face_to_id_map[Face(node_vector, node_number_vector)] = l;
+ }
+ return face_to_id_map;
+ }();
std::unordered_map<int, FaceId> face_number_id_map = [&] {
std::unordered_map<int, FaceId> face_number_id_map;
@@ -1773,8 +1646,7 @@ GmshReader::__proceedData()
std::map<unsigned int, std::vector<unsigned int>> ref_faces_map;
for (unsigned int e = 0; e < __edges.size(); ++e) {
const unsigned int edge_id = [&] {
- auto i = face_to_id_map.find(
- Face({__edges[e][0], __edges[e][1]}, node_number_vector));
+ auto i = face_to_id_map.find(Face({__edges[e][0], __edges[e][1]}, node_number_vector));
if (i == face_to_id_map.end()) {
std::cerr << "face " << __edges[e][0] << " not found!\n";
std::terminate();
@@ -1785,22 +1657,18 @@ GmshReader::__proceedData()
ref_faces_map[ref].push_back(edge_id);
if (descriptor.face_number_vector[edge_id] != __edges_number[e]) {
- if (auto i_face = face_number_id_map.find(__edges_number[e]);
- i_face != face_number_id_map.end()) {
+ if (auto i_face = face_number_id_map.find(__edges_number[e]); i_face != face_number_id_map.end()) {
const int other_edge_id = i_face->second;
- std::swap(descriptor.face_number_vector[edge_id],
- descriptor.face_number_vector[other_edge_id]);
+ std::swap(descriptor.face_number_vector[edge_id], descriptor.face_number_vector[other_edge_id]);
face_number_id_map.erase(descriptor.face_number_vector[edge_id]);
- face_number_id_map.erase(
- descriptor.face_number_vector[other_edge_id]);
+ face_number_id_map.erase(descriptor.face_number_vector[other_edge_id]);
- face_number_id_map[descriptor.face_number_vector[edge_id]] = edge_id;
- face_number_id_map[descriptor.face_number_vector[other_edge_id]] =
- other_edge_id;
+ face_number_id_map[descriptor.face_number_vector[edge_id]] = edge_id;
+ face_number_id_map[descriptor.face_number_vector[other_edge_id]] = other_edge_id;
} else {
face_number_id_map.erase(descriptor.face_number_vector[edge_id]);
- descriptor.face_number_vector[edge_id] = __edges_number[e];
+ descriptor.face_number_vector[edge_id] = __edges_number[e];
face_number_id_map[descriptor.face_number_vector[edge_id]] = edge_id;
}
}
@@ -1811,10 +1679,8 @@ GmshReader::__proceedData()
for (size_t j = 0; j < ref_face_list.second.size(); ++j) {
face_list[j] = ref_face_list.second[j];
}
- const PhysicalRefId& physical_ref_id =
- m_physical_ref_map.at(ref_face_list.first);
- descriptor.addRefItemList(
- RefFaceList{physical_ref_id.refId(), face_list});
+ const PhysicalRefId& physical_ref_id = m_physical_ref_map.at(ref_face_list.first);
+ descriptor.addRefItemList(RefFaceList{physical_ref_id.refId(), face_list});
}
std::map<unsigned int, std::vector<unsigned int>> ref_points_map;
@@ -1829,23 +1695,18 @@ GmshReader::__proceedData()
for (size_t j = 0; j < ref_point_list.second.size(); ++j) {
point_list[j] = ref_point_list.second[j];
}
- const PhysicalRefId& physical_ref_id =
- m_physical_ref_map.at(ref_point_list.first);
- descriptor.addRefItemList(
- RefNodeList(physical_ref_id.refId(), point_list));
+ const PhysicalRefId& physical_ref_id = m_physical_ref_map.at(ref_point_list.first);
+ descriptor.addRefItemList(RefNodeList(physical_ref_id.refId(), point_list));
}
descriptor.cell_owner_vector.resize(nb_cells);
- std::fill(descriptor.cell_owner_vector.begin(),
- descriptor.cell_owner_vector.end(), parallel::rank());
+ std::fill(descriptor.cell_owner_vector.begin(), descriptor.cell_owner_vector.end(), parallel::rank());
descriptor.face_owner_vector.resize(descriptor.face_number_vector.size());
- std::fill(descriptor.face_owner_vector.begin(),
- descriptor.face_owner_vector.end(), parallel::rank());
+ std::fill(descriptor.face_owner_vector.begin(), descriptor.face_owner_vector.end(), parallel::rank());
descriptor.node_owner_vector.resize(descriptor.node_number_vector.size());
- std::fill(descriptor.node_owner_vector.begin(),
- descriptor.node_owner_vector.end(), parallel::rank());
+ std::fill(descriptor.node_owner_vector.begin(), descriptor.node_owner_vector.end(), parallel::rank());
std::shared_ptr p_connectivity = Connectivity2D::build(descriptor);
Connectivity2D& connectivity = *p_connectivity;
@@ -1891,19 +1752,15 @@ GmshReader::__proceedData()
for (size_t j = 0; j < ref_point_list.second.size(); ++j) {
point_list[j] = ref_point_list.second[j];
}
- const PhysicalRefId& physical_ref_id =
- m_physical_ref_map.at(ref_point_list.first);
- descriptor.addRefItemList(
- RefNodeList(physical_ref_id.refId(), point_list));
+ const PhysicalRefId& physical_ref_id = m_physical_ref_map.at(ref_point_list.first);
+ descriptor.addRefItemList(RefNodeList(physical_ref_id.refId(), point_list));
}
descriptor.cell_owner_vector.resize(nb_cells);
- std::fill(descriptor.cell_owner_vector.begin(),
- descriptor.cell_owner_vector.end(), parallel::rank());
+ std::fill(descriptor.cell_owner_vector.begin(), descriptor.cell_owner_vector.end(), parallel::rank());
descriptor.node_owner_vector.resize(descriptor.node_number_vector.size());
- std::fill(descriptor.node_owner_vector.begin(),
- descriptor.node_owner_vector.end(), parallel::rank());
+ std::fill(descriptor.node_owner_vector.begin(), descriptor.node_owner_vector.end(), parallel::rank());
std::shared_ptr p_connectivity = Connectivity1D::build(descriptor);
Connectivity1D& connectivity = *p_connectivity;
@@ -1944,9 +1801,7 @@ GmshReader::__nextKeyword()
return kw;
}
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename + "': unknown keyword '" +
- aKeyword + "'",
+ throw ErrorHandler(__FILE__, __LINE__, "reading file '" + m_filename + "': unknown keyword '" + aKeyword + "'",
ErrorHandler::normal);
kw.first = aKeyword;
@@ -1962,50 +1817,42 @@ GmshReader::__readGmshFormat2_2()
while (kw.second != EndOfFile) {
kw = this->__nextKeyword();
switch (kw.second) {
- case NODES: {
- this->__readVertices();
- if (this->__nextKeyword().second != ENDNODES) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': expecting $EndNodes, '" + kw.first +
- "' was found",
- ErrorHandler::normal);
- }
- break;
- }
- case ELEMENTS: {
- this->__readElements2_2();
- kw = this->__nextKeyword();
- if (kw.second != ENDELEMENTS) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': expecting $EndElements, '" + kw.first +
- "' was found",
- ErrorHandler::normal);
- }
- break;
- }
- case PHYSICALNAMES: {
- this->__readPhysicalNames2_2();
- if (this->__nextKeyword().second != ENDPHYSICALNAMES) {
- throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename +
- "': expecting $EndNodes, '" + kw.first +
- "' was found",
- ErrorHandler::normal);
- }
- break;
+ case NODES: {
+ this->__readVertices();
+ if (this->__nextKeyword().second != ENDNODES) {
+ throw ErrorHandler(__FILE__, __LINE__,
+ "reading file '" + m_filename + "': expecting $EndNodes, '" + kw.first + "' was found",
+ ErrorHandler::normal);
}
-
- case EndOfFile: {
- break;
+ break;
+ }
+ case ELEMENTS: {
+ this->__readElements2_2();
+ kw = this->__nextKeyword();
+ if (kw.second != ENDELEMENTS) {
+ throw ErrorHandler(__FILE__, __LINE__,
+ "reading file '" + m_filename + "': expecting $EndElements, '" + kw.first + "' was found",
+ ErrorHandler::normal);
}
- default: {
+ break;
+ }
+ case PHYSICALNAMES: {
+ this->__readPhysicalNames2_2();
+ if (this->__nextKeyword().second != ENDPHYSICALNAMES) {
throw ErrorHandler(__FILE__, __LINE__,
- "reading file '" + m_filename + "': unexpected '" +
- kw.first + "'",
+ "reading file '" + m_filename + "': expecting $EndNodes, '" + kw.first + "' was found",
ErrorHandler::normal);
}
+ break;
+ }
+
+ case EndOfFile: {
+ break;
+ }
+ default: {
+ throw ErrorHandler(__FILE__, __LINE__, "reading file '" + m_filename + "': unexpected '" + kw.first + "'",
+ ErrorHandler::normal);
+ }
}
}
}
diff --git a/src/mesh/GmshReader.hpp b/src/mesh/GmshReader.hpp
index 616532476e3c1710ce0d9155c5a7b49c6c3a2d58..d6d5f3887eff282833ec169cd410bd3026188181 100644
--- a/src/mesh/GmshReader.hpp
+++ b/src/mesh/GmshReader.hpp
@@ -31,8 +31,7 @@ class GmshReader
friend std::ostream&
operator<<(std::ostream& os, const PhysicalRefId& physical_ref_id)
{
- os << physical_ref_id.m_ref_id << "[dimension "
- << physical_ref_id.m_dimension << "]";
+ os << physical_ref_id.m_ref_id << "[dimension " << physical_ref_id.m_dimension << "]";
return os;
}
@@ -62,8 +61,7 @@ class GmshReader
PhysicalRefId& operator=(const PhysicalRefId&) = default;
PhysicalRefId& operator=(PhysicalRefId&&) = default;
- PhysicalRefId(const int& dimension, const RefId& ref_id)
- : m_dimension(dimension), m_ref_id(ref_id)
+ PhysicalRefId(const int& dimension, const RefId& ref_id) : m_dimension(dimension), m_ref_id(ref_id)
{
;
}
@@ -266,12 +264,10 @@ class GmshReader
void __readPhysicalNames2_2();
template <size_t Dimension>
- void __computeCellFaceAndFaceNodeConnectivities(
- ConnectivityDescriptor& descriptor);
+ void __computeCellFaceAndFaceNodeConnectivities(ConnectivityDescriptor& descriptor);
template <size_t Dimension>
- void __computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(
- ConnectivityDescriptor& descriptor);
+ void __computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(ConnectivityDescriptor& descriptor);
template <int Dimension>
void _dispatch();
diff --git a/src/mesh/IConnectivity.hpp b/src/mesh/IConnectivity.hpp
index 136ff17c080fb27c07b574562d2a7b58f1d22e9b..d548be0a4177036ca082e990d50aa222ba44368f 100644
--- a/src/mesh/IConnectivity.hpp
+++ b/src/mesh/IConnectivity.hpp
@@ -12,9 +12,7 @@ class IConnectivity : public std::enable_shared_from_this<IConnectivity>
template <typename DataType, typename ItemOfItem, typename ConnectivityPtr>
friend class SubItemValuePerItem;
- virtual const ConnectivityMatrix& _getMatrix(
- const ItemType& item_type_0,
- const ItemType& item_type_1) const = 0;
+ virtual const ConnectivityMatrix& _getMatrix(const ItemType& item_type_0, const ItemType& item_type_1) const = 0;
public:
virtual size_t dimension() const = 0;
diff --git a/src/mesh/ItemOfItemType.hpp b/src/mesh/ItemOfItemType.hpp
index 027e35c96795e3727158a13399fbbf98721a70d3..9921eea68ef8393b11bf386a93086bf3c1d31786 100644
--- a/src/mesh/ItemOfItemType.hpp
+++ b/src/mesh/ItemOfItemType.hpp
@@ -6,8 +6,7 @@
template <ItemType sub_item_t, ItemType item_t>
struct ItemOfItemType
{
- static_assert(sub_item_t != item_t,
- "item and its sub-item cannot be of same type");
+ static_assert(sub_item_t != item_t, "item and its sub-item cannot be of same type");
constexpr static ItemType sub_item_type = sub_item_t;
constexpr static ItemType item_type = item_t;
diff --git a/src/mesh/ItemToItemMatrix.hpp b/src/mesh/ItemToItemMatrix.hpp
index 2438da59d96cc5b23583f191c715fc4c332ba06e..04b8a7b7487cb22789f4ff48c09292b403476695 100644
--- a/src/mesh/ItemToItemMatrix.hpp
+++ b/src/mesh/ItemToItemMatrix.hpp
@@ -82,15 +82,13 @@ class ItemToItemMatrix
template <typename IndexType>
PUGS_INLINE const auto& operator[](const IndexType& source_id) const
{
- static_assert(std::is_same_v<IndexType, SourceItemId>,
- "ItemToItemMatrix must be indexed using correct ItemId");
+ static_assert(std::is_same_v<IndexType, SourceItemId>, "ItemToItemMatrix must be indexed using correct ItemId");
using RowType = decltype(m_connectivity_matrix.rowConst(source_id));
return SubItemList<RowType>(m_connectivity_matrix.rowConst(source_id));
}
PUGS_INLINE
- ItemToItemMatrix(const ConnectivityMatrix& connectivity_matrix)
- : m_connectivity_matrix{connectivity_matrix}
+ ItemToItemMatrix(const ConnectivityMatrix& connectivity_matrix) : m_connectivity_matrix{connectivity_matrix}
{
;
}
diff --git a/src/mesh/ItemType.hpp b/src/mesh/ItemType.hpp
index ea5c2648629457fa2858bc1854db5a0810444ddb..1f4cbbd745514fc589fad56ad342a353dd581a94 100644
--- a/src/mesh/ItemType.hpp
+++ b/src/mesh/ItemType.hpp
@@ -19,29 +19,30 @@ itemName(const ItemType& item_type)
{
std::string_view name;
switch (item_type) {
- case ItemType::node: {
- name = "node";
- break;
- }
- case ItemType::edge: {
- name = "edge";
- break;
- }
- case ItemType::face: {
- name = "face";
- break;
- }
- case ItemType::cell: {
- name = "cell";
- break;
- }
+ case ItemType::node: {
+ name = "node";
+ break;
+ }
+ case ItemType::edge: {
+ name = "edge";
+ break;
+ }
+ case ItemType::face: {
+ name = "face";
+ break;
+ }
+ case ItemType::cell: {
+ name = "cell";
+ break;
+ }
}
return name;
}
template <size_t Dimension>
struct ItemTypeId
-{};
+{
+};
template <>
struct ItemTypeId<1>
@@ -52,17 +53,17 @@ struct ItemTypeId<1>
{
size_t i = std::numeric_limits<size_t>::max();
switch (item_type) {
- case ItemType::cell: {
- i = 0;
- break;
- }
- case ItemType::edge:
- case ItemType::face:
- case ItemType::node: {
- // in 1d, faces, edges and nodes are the same
- i = 1;
- break;
- }
+ case ItemType::cell: {
+ i = 0;
+ break;
+ }
+ case ItemType::edge:
+ case ItemType::face:
+ case ItemType::node: {
+ // in 1d, faces, edges and nodes are the same
+ i = 1;
+ break;
+ }
}
return i;
}
@@ -77,20 +78,20 @@ struct ItemTypeId<2>
{
size_t i = std::numeric_limits<size_t>::max();
switch (item_type) {
- case ItemType::cell: {
- i = 0;
- break;
- }
- case ItemType::edge:
- case ItemType::face: {
- // in 2d, faces and edges are the same
- i = 1;
- break;
- }
- case ItemType::node: {
- i = 2;
- break;
- }
+ case ItemType::cell: {
+ i = 0;
+ break;
+ }
+ case ItemType::edge:
+ case ItemType::face: {
+ // in 2d, faces and edges are the same
+ i = 1;
+ break;
+ }
+ case ItemType::node: {
+ i = 2;
+ break;
+ }
}
return i;
}
@@ -105,22 +106,22 @@ struct ItemTypeId<3>
{
size_t i = std::numeric_limits<size_t>::max();
switch (item_type) {
- case ItemType::cell: {
- i = 0;
- break;
- }
- case ItemType::edge: {
- i = 1;
- break;
- }
- case ItemType::face: {
- i = 2;
- break;
- }
- case ItemType::node: {
- i = 3;
- break;
- }
+ case ItemType::cell: {
+ i = 0;
+ break;
+ }
+ case ItemType::edge: {
+ i = 1;
+ break;
+ }
+ case ItemType::face: {
+ i = 2;
+ break;
+ }
+ case ItemType::node: {
+ i = 3;
+ break;
+ }
}
return i;
}
diff --git a/src/mesh/ItemValue.hpp b/src/mesh/ItemValue.hpp
index d2ff6bedb048a3ca2f25a6ed3da20c17b4dca9fb..38b53ea79190724014241f50fc8cfd37d7599e40 100644
--- a/src/mesh/ItemValue.hpp
+++ b/src/mesh/ItemValue.hpp
@@ -12,9 +12,7 @@
#include <IConnectivity.hpp>
#include <memory>
-template <typename DataType,
- ItemType item_type,
- typename ConnectivityPtr = std::shared_ptr<const IConnectivity>>
+template <typename DataType, ItemType item_type, typename ConnectivityPtr = std::shared_ptr<const IConnectivity>>
class ItemValue
{
public:
@@ -36,19 +34,15 @@ class ItemValue
Array<DataType> m_values;
// Allow const std:shared_ptr version to access our data
- friend ItemValue<std::add_const_t<DataType>,
- item_type,
- ConnectivitySharedPtr>;
+ friend ItemValue<std::add_const_t<DataType>, item_type, ConnectivitySharedPtr>;
// Allow const std:weak_ptr version to access our data
friend ItemValue<std::add_const_t<DataType>, item_type, ConnectivityWeakPtr>;
- friend PUGS_INLINE
- ItemValue<std::remove_const_t<DataType>, item_type, ConnectivityPtr>
- copy(const ItemValue<DataType, item_type, ConnectivityPtr>& source)
+ friend PUGS_INLINE ItemValue<std::remove_const_t<DataType>, item_type, ConnectivityPtr>
+ copy(const ItemValue<DataType, item_type, ConnectivityPtr>& source)
{
- ItemValue<std::remove_const_t<DataType>, item_type, ConnectivityPtr> image(
- source);
+ ItemValue<std::remove_const_t<DataType>, item_type, ConnectivityPtr> image(source);
image.m_values = copy(source.m_values);
return image;
@@ -85,8 +79,7 @@ class ItemValue
void
fill(const DataType& data) const noexcept
{
- static_assert(not std::is_const_v<DataType>,
- "Cannot modify ItemValue of const");
+ static_assert(not std::is_const_v<DataType>, "Cannot modify ItemValue of const");
m_values.fill(data);
}
@@ -102,8 +95,7 @@ class ItemValue
template <typename IndexType>
DataType& operator[](const IndexType&) const noexcept(NO_ASSERT)
{
- static_assert(std::is_same_v<IndexType, ItemId>,
- "ItemValue must be indexed by ItemId");
+ static_assert(std::is_same_v<IndexType, ItemId>, "ItemValue must be indexed by ItemId");
}
PUGS_INLINE
@@ -119,19 +111,15 @@ class ItemValue
operator=(const Array<DataType2>& values) noexcept(NO_ASSERT)
{
// ensures that DataType is the same as source DataType2
- static_assert(std::is_same_v<std::remove_const_t<DataType>,
- std::remove_const_t<DataType2>>,
+ static_assert(std::is_same_v<std::remove_const_t<DataType>, std::remove_const_t<DataType2>>,
"Cannot assign ItemValue of different type");
// ensures that const is not lost through copy
- static_assert(((std::is_const_v<DataType2> and std::is_const_v<DataType>) or
- not std::is_const_v<DataType2>),
+ static_assert(((std::is_const_v<DataType2> and std::is_const_v<DataType>) or not std::is_const_v<DataType2>),
"Cannot assign ItemValue of const to ItemValue of non-const");
- Assert((m_values.size() == values.size()),
- "Cannot assign an array of values of a different size\n");
+ Assert((m_values.size() == values.size()), "Cannot assign an array of values of a different size\n");
- Assert((values.size() == 0) or this->isBuilt(),
- "Cannot assign array of values to a non-built ItemValue\n");
+ Assert((values.size() == 0) or this->isBuilt(), "Cannot assign array of values to a non-built ItemValue\n");
m_values = values;
@@ -140,16 +128,13 @@ class ItemValue
template <typename DataType2, typename ConnectivityPtr2>
PUGS_INLINE ItemValue&
- operator=(const ItemValue<DataType2, item_type, ConnectivityPtr2>&
- value_per_item) noexcept
+ operator=(const ItemValue<DataType2, item_type, ConnectivityPtr2>& value_per_item) noexcept
{
// ensures that DataType is the same as source DataType2
- static_assert(std::is_same_v<std::remove_const_t<DataType>,
- std::remove_const_t<DataType2>>,
+ static_assert(std::is_same_v<std::remove_const_t<DataType>, std::remove_const_t<DataType2>>,
"Cannot assign ItemValue of different type");
// ensures that const is not lost through copy
- static_assert(((std::is_const_v<DataType2> and std::is_const_v<DataType>) or
- not std::is_const_v<DataType2>),
+ static_assert(((std::is_const_v<DataType2> and std::is_const_v<DataType>) or not std::is_const_v<DataType2>),
"Cannot assign ItemValue of const to ItemValue of non-const");
m_values = value_per_item.m_values;
@@ -165,8 +150,7 @@ class ItemValue
template <typename DataType2, typename ConnectivityPtr2>
PUGS_INLINE
- ItemValue(const ItemValue<DataType2, item_type, ConnectivityPtr2>&
- value_per_item) noexcept
+ ItemValue(const ItemValue<DataType2, item_type, ConnectivityPtr2>& value_per_item) noexcept
{
this->operator=(value_per_item);
}
@@ -176,12 +160,10 @@ class ItemValue
PUGS_INLINE
ItemValue(const IConnectivity& connectivity) noexcept
- : m_connectivity_ptr{connectivity.shared_ptr()},
- m_values{connectivity.numberOf<item_type>()}
+ : m_connectivity_ptr{connectivity.shared_ptr()}, m_values{connectivity.numberOf<item_type>()}
{
- static_assert(
- not std::is_const_v<DataType>,
- "Cannot allocate ItemValue of const data: only view is supported");
+ static_assert(not std::is_const_v<DataType>, "Cannot allocate ItemValue of const data: only view is "
+ "supported");
;
}
@@ -204,8 +186,7 @@ using CellValue = ItemValue<DataType, ItemType::cell>;
// Weak versions: should not be used outside of Connectivity
template <typename DataType, ItemType item_type>
-using WeakItemValue =
- ItemValue<DataType, item_type, std::weak_ptr<const IConnectivity>>;
+using WeakItemValue = ItemValue<DataType, item_type, std::weak_ptr<const IConnectivity>>;
template <typename DataType>
using WeakNodeValue = WeakItemValue<DataType, ItemType::node>;
diff --git a/src/mesh/ItemValueUtils.hpp b/src/mesh/ItemValueUtils.hpp
index 2013dcc2ae44ecbaf818c3a8ade0a6cf16d8e776..33a4a988a98bf9cf92524a5eb5da4948360bc00f 100644
--- a/src/mesh/ItemValueUtils.hpp
+++ b/src/mesh/ItemValueUtils.hpp
@@ -18,32 +18,28 @@ min(const ItemValue<DataType, item_type>& item_value)
using index_type = typename ItemValueType::index_type;
const auto& is_owned = [&](const IConnectivity& connectivity) {
- Assert((connectivity.dimension() > 0) and (connectivity.dimension() <= 3),
- "unexpected connectivity dimension");
+ Assert((connectivity.dimension() > 0) and (connectivity.dimension() <= 3), "unexpected connectivity dimension");
switch (connectivity.dimension()) {
- case 1: {
- const auto& connectivity_1d =
- static_cast<const Connectivity1D&>(connectivity);
- return connectivity_1d.isOwned<item_type>();
- break;
- }
- case 2: {
- const auto& connectivity_2d =
- static_cast<const Connectivity2D&>(connectivity);
- return connectivity_2d.isOwned<item_type>();
- break;
- }
- case 3: {
- const auto& connectivity_3d =
- static_cast<const Connectivity3D&>(connectivity);
- return connectivity_3d.isOwned<item_type>();
- break;
- }
- default: {
- perr() << __FILE__ << ':' << __LINE__ << ": unexpected dimension\n";
- std::terminate();
- }
+ case 1: {
+ const auto& connectivity_1d = static_cast<const Connectivity1D&>(connectivity);
+ return connectivity_1d.isOwned<item_type>();
+ break;
+ }
+ case 2: {
+ const auto& connectivity_2d = static_cast<const Connectivity2D&>(connectivity);
+ return connectivity_2d.isOwned<item_type>();
+ break;
+ }
+ case 3: {
+ const auto& connectivity_3d = static_cast<const Connectivity3D&>(connectivity);
+ return connectivity_3d.isOwned<item_type>();
+ break;
+ }
+ default: {
+ perr() << __FILE__ << ':' << __LINE__ << ": unexpected dimension\n";
+ std::terminate();
+ }
}
}(*item_value.connectivity_ptr());
@@ -113,32 +109,28 @@ max(const ItemValue<DataType, item_type>& item_value)
using index_type = typename ItemValueType::index_type;
const auto& is_owned = [&](const IConnectivity& connectivity) {
- Assert((connectivity.dimension() > 0) and (connectivity.dimension() <= 3),
- "unexpected connectivity dimension");
+ Assert((connectivity.dimension() > 0) and (connectivity.dimension() <= 3), "unexpected connectivity dimension");
switch (connectivity.dimension()) {
- case 1: {
- const auto& connectivity_1d =
- static_cast<const Connectivity1D&>(connectivity);
- return connectivity_1d.isOwned<item_type>();
- break;
- }
- case 2: {
- const auto& connectivity_2d =
- static_cast<const Connectivity2D&>(connectivity);
- return connectivity_2d.isOwned<item_type>();
- break;
- }
- case 3: {
- const auto& connectivity_3d =
- static_cast<const Connectivity3D&>(connectivity);
- return connectivity_3d.isOwned<item_type>();
- break;
- }
- default: {
- perr() << __FILE__ << ':' << __LINE__ << ": unexpected dimension\n";
- std::terminate();
- }
+ case 1: {
+ const auto& connectivity_1d = static_cast<const Connectivity1D&>(connectivity);
+ return connectivity_1d.isOwned<item_type>();
+ break;
+ }
+ case 2: {
+ const auto& connectivity_2d = static_cast<const Connectivity2D&>(connectivity);
+ return connectivity_2d.isOwned<item_type>();
+ break;
+ }
+ case 3: {
+ const auto& connectivity_3d = static_cast<const Connectivity3D&>(connectivity);
+ return connectivity_3d.isOwned<item_type>();
+ break;
+ }
+ default: {
+ perr() << __FILE__ << ':' << __LINE__ << ": unexpected dimension\n";
+ std::terminate();
+ }
}
}(*item_value.connectivity_ptr());
@@ -208,32 +200,28 @@ sum(const ItemValue<DataType, item_type>& item_value)
using index_type = typename ItemValueType::index_type;
const auto& is_owned = [&](const IConnectivity& connectivity) {
- Assert((connectivity.dimension() > 0) and (connectivity.dimension() <= 3),
- "unexpected connectivity dimension");
+ Assert((connectivity.dimension() > 0) and (connectivity.dimension() <= 3), "unexpected connectivity dimension");
switch (connectivity.dimension()) {
- case 1: {
- const auto& connectivity_1d =
- static_cast<const Connectivity1D&>(connectivity);
- return connectivity_1d.isOwned<item_type>();
- break;
- }
- case 2: {
- const auto& connectivity_2d =
- static_cast<const Connectivity2D&>(connectivity);
- return connectivity_2d.isOwned<item_type>();
- break;
- }
- case 3: {
- const auto& connectivity_3d =
- static_cast<const Connectivity3D&>(connectivity);
- return connectivity_3d.isOwned<item_type>();
- break;
- }
- default: {
- perr() << __FILE__ << ':' << __LINE__ << ": unexpected dimension\n";
- std::terminate();
- }
+ case 1: {
+ const auto& connectivity_1d = static_cast<const Connectivity1D&>(connectivity);
+ return connectivity_1d.isOwned<item_type>();
+ break;
+ }
+ case 2: {
+ const auto& connectivity_2d = static_cast<const Connectivity2D&>(connectivity);
+ return connectivity_2d.isOwned<item_type>();
+ break;
+ }
+ case 3: {
+ const auto& connectivity_3d = static_cast<const Connectivity3D&>(connectivity);
+ return connectivity_3d.isOwned<item_type>();
+ break;
+ }
+ default: {
+ perr() << __FILE__ << ':' << __LINE__ << ": unexpected dimension\n";
+ std::terminate();
+ }
}
}(*item_value.connectivity_ptr());
@@ -300,13 +288,11 @@ template <typename DataType, ItemType item_type, typename ConnectivityPtr>
void
synchronize(ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
{
- static_assert(not std::is_const_v<DataType>,
- "cannot synchronize ItemValue of const data");
+ static_assert(not std::is_const_v<DataType>, "cannot synchronize ItemValue of const data");
if (parallel::size() > 1) {
auto& manager = SynchronizerManager::instance();
const IConnectivity* connectivity = item_value.connectivity_ptr().get();
- Synchronizer& synchronizer =
- manager.getConnectivitySynchronizer(connectivity);
+ Synchronizer& synchronizer = manager.getConnectivitySynchronizer(connectivity);
synchronizer.synchronize(item_value);
}
}
diff --git a/src/mesh/Mesh.hpp b/src/mesh/Mesh.hpp
index af76417d50e1ea686548e6270147c2f0480cebe8..a8e9411007783bb5a6406510c38c2bd40eb03d54 100644
--- a/src/mesh/Mesh.hpp
+++ b/src/mesh/Mesh.hpp
@@ -79,8 +79,7 @@ class Mesh final : public IMesh
}
PUGS_INLINE
- Mesh(const std::shared_ptr<const Connectivity>& connectivity,
- NodeValue<Rd>& xr)
+ Mesh(const std::shared_ptr<const Connectivity>& connectivity, NodeValue<Rd>& xr)
: m_connectivity{connectivity}, m_xr{xr}, m_mutable_xr{xr}
{
;
diff --git a/src/mesh/MeshData.hpp b/src/mesh/MeshData.hpp
index 0c512e4d14b1d862721431089d3a8a4d708a2a6a..17a1ac4c38a7eee7dc90a5584f8d91f4a7413d73 100644
--- a/src/mesh/MeshData.hpp
+++ b/src/mesh/MeshData.hpp
@@ -37,32 +37,31 @@ class MeshData
if constexpr (Dimension == 1) {
const NodeValue<const Rd>& xr = m_mesh.xr();
- const auto& cell_to_node_matrix =
- m_mesh.connectivity().cellToNodeMatrix();
+ const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
CellValue<Rd> xj(m_mesh.connectivity());
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- const auto& cell_nodes = cell_to_node_matrix[j];
- xj[j] = 0.5 * (xr[cell_nodes[0]] + xr[cell_nodes[1]]);
- });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ const auto& cell_nodes = cell_to_node_matrix[j];
+ xj[j] = 0.5 * (xr[cell_nodes[0]] + xr[cell_nodes[1]]);
+ });
m_xj = xj;
} else {
const NodeValue<const Rd>& xr = m_mesh.xr();
- const CellValue<const double>& inv_cell_nb_nodes =
- m_mesh.connectivity().invCellNbNodes();
+ const CellValue<const double>& inv_cell_nb_nodes = m_mesh.connectivity().invCellNbNodes();
- const auto& cell_to_node_matrix =
- m_mesh.connectivity().cellToNodeMatrix();
+ const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
CellValue<Rd> xj(m_mesh.connectivity());
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- Rd X = zero;
- const auto& cell_nodes = cell_to_node_matrix[j];
- for (size_t R = 0; R < cell_nodes.size(); ++R) {
- X += xr[cell_nodes[R]];
- }
- xj[j] = inv_cell_nb_nodes[j] * X;
- });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ Rd X = zero;
+ const auto& cell_nodes = cell_to_node_matrix[j];
+ for (size_t R = 0; R < cell_nodes.size(); ++R) {
+ X += xr[cell_nodes[R]];
+ }
+ xj[j] = inv_cell_nb_nodes[j] * X;
+ });
m_xj = xj;
}
}
@@ -75,15 +74,16 @@ class MeshData
const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
CellValue<double> Vj(m_mesh.connectivity());
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- double sum_cjr_xr = 0;
- const auto& cell_nodes = cell_to_node_matrix[j];
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ double sum_cjr_xr = 0;
+ const auto& cell_nodes = cell_to_node_matrix[j];
- for (size_t R = 0; R < cell_nodes.size(); ++R) {
- sum_cjr_xr += (xr[cell_nodes[R]], m_Cjr(j, R));
- }
- Vj[j] = inv_Dimension * sum_cjr_xr;
- });
+ for (size_t R = 0; R < cell_nodes.size(); ++R) {
+ sum_cjr_xr += (xr[cell_nodes[R]], m_Cjr(j, R));
+ }
+ Vj[j] = inv_Dimension * sum_cjr_xr;
+ });
m_Vj = Vj;
}
@@ -94,130 +94,123 @@ class MeshData
if constexpr (Dimension == 1) {
// Cjr/njr/ljr are constant overtime
} else if constexpr (Dimension == 2) {
- const NodeValue<const Rd>& xr = m_mesh.xr();
- const auto& cell_to_node_matrix =
- m_mesh.connectivity().cellToNodeMatrix();
+ const NodeValue<const Rd>& xr = m_mesh.xr();
+ const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
{
NodeValuePerCell<Rd> Cjr(m_mesh.connectivity());
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- const auto& cell_nodes = cell_to_node_matrix[j];
- for (size_t R = 0; R < cell_nodes.size(); ++R) {
- int Rp1 = (R + 1) % cell_nodes.size();
- int Rm1 = (R + cell_nodes.size() - 1) % cell_nodes.size();
- Rd half_xrp_xrm = 0.5 * (xr[cell_nodes[Rp1]] - xr[cell_nodes[Rm1]]);
- Cjr(j, R) = Rd{-half_xrp_xrm[1], half_xrp_xrm[0]};
- }
- });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ const auto& cell_nodes = cell_to_node_matrix[j];
+ for (size_t R = 0; R < cell_nodes.size(); ++R) {
+ int Rp1 = (R + 1) % cell_nodes.size();
+ int Rm1 = (R + cell_nodes.size() - 1) % cell_nodes.size();
+ Rd half_xrp_xrm = 0.5 * (xr[cell_nodes[Rp1]] - xr[cell_nodes[Rm1]]);
+ Cjr(j, R) = Rd{-half_xrp_xrm[1], half_xrp_xrm[0]};
+ }
+ });
m_Cjr = Cjr;
}
{
NodeValuePerCell<double> ljr(m_mesh.connectivity());
- parallel_for(m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) {
- ljr[jr] = l2Norm(m_Cjr[jr]);
- });
+ parallel_for(
+ m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { ljr[jr] = l2Norm(m_Cjr[jr]); });
m_ljr = ljr;
}
{
NodeValuePerCell<Rd> njr(m_mesh.connectivity());
- parallel_for(m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) {
- njr[jr] = (1. / m_ljr[jr]) * m_Cjr[jr];
- });
+ parallel_for(
+ m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { njr[jr] = (1. / m_ljr[jr]) * m_Cjr[jr]; });
m_njr = njr;
}
} else if (Dimension == 3) {
const NodeValue<const Rd>& xr = m_mesh.xr();
NodeValuePerFace<Rd> Nlr(m_mesh.connectivity());
- const auto& face_to_node_matrix =
- m_mesh.connectivity().faceToNodeMatrix();
-
- parallel_for(m_mesh.numberOfFaces(), PUGS_LAMBDA(const FaceId& l) {
- const auto& face_nodes = face_to_node_matrix[l];
- const size_t nb_nodes = face_nodes.size();
- std::vector<Rd> dxr(nb_nodes);
- for (size_t r = 0; r < nb_nodes; ++r) {
- dxr[r] = xr[face_nodes[(r + 1) % nb_nodes]] -
- xr[face_nodes[(r + nb_nodes - 1) % nb_nodes]];
- }
- const double inv_12_nb_nodes = 1. / (12. * nb_nodes);
- for (size_t r = 0; r < nb_nodes; ++r) {
- Rd Nr = zero;
- const Rd two_dxr = 2 * dxr[r];
- for (size_t s = 0; s < nb_nodes; ++s) {
- Nr += crossProduct((two_dxr - dxr[s]), xr[face_nodes[s]]);
+ const auto& face_to_node_matrix = m_mesh.connectivity().faceToNodeMatrix();
+
+ parallel_for(
+ m_mesh.numberOfFaces(), PUGS_LAMBDA(const FaceId& l) {
+ const auto& face_nodes = face_to_node_matrix[l];
+ const size_t nb_nodes = face_nodes.size();
+ std::vector<Rd> dxr(nb_nodes);
+ for (size_t r = 0; r < nb_nodes; ++r) {
+ dxr[r] = xr[face_nodes[(r + 1) % nb_nodes]] - xr[face_nodes[(r + nb_nodes - 1) % nb_nodes]];
}
- Nr *= inv_12_nb_nodes;
- Nr -= (1. / 6.) * crossProduct(dxr[r], xr[face_nodes[r]]);
- Nlr(l, r) = Nr;
- }
- });
+ const double inv_12_nb_nodes = 1. / (12. * nb_nodes);
+ for (size_t r = 0; r < nb_nodes; ++r) {
+ Rd Nr = zero;
+ const Rd two_dxr = 2 * dxr[r];
+ for (size_t s = 0; s < nb_nodes; ++s) {
+ Nr += crossProduct((two_dxr - dxr[s]), xr[face_nodes[s]]);
+ }
+ Nr *= inv_12_nb_nodes;
+ Nr -= (1. / 6.) * crossProduct(dxr[r], xr[face_nodes[r]]);
+ Nlr(l, r) = Nr;
+ }
+ });
- const auto& cell_to_node_matrix =
- m_mesh.connectivity().cellToNodeMatrix();
+ const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
- const auto& cell_to_face_matrix =
- m_mesh.connectivity().cellToFaceMatrix();
+ const auto& cell_to_face_matrix = m_mesh.connectivity().cellToFaceMatrix();
- const auto& cell_face_is_reversed =
- m_mesh.connectivity().cellFaceIsReversed();
+ const auto& cell_face_is_reversed = m_mesh.connectivity().cellFaceIsReversed();
{
NodeValuePerCell<Rd> Cjr(m_mesh.connectivity());
- parallel_for(Cjr.numberOfValues(),
- PUGS_LAMBDA(const size_t& jr) { Cjr[jr] = zero; });
+ parallel_for(
+ Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { Cjr[jr] = zero; });
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- const auto& cell_nodes = cell_to_node_matrix[j];
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ const auto& cell_nodes = cell_to_node_matrix[j];
- const auto& cell_faces = cell_to_face_matrix[j];
- const auto& face_is_reversed = cell_face_is_reversed.itemValues(j);
+ const auto& cell_faces = cell_to_face_matrix[j];
+ const auto& face_is_reversed = cell_face_is_reversed.itemValues(j);
- for (size_t L = 0; L < cell_faces.size(); ++L) {
- const FaceId& l = cell_faces[L];
- const auto& face_nodes = face_to_node_matrix[l];
+ for (size_t L = 0; L < cell_faces.size(); ++L) {
+ const FaceId& l = cell_faces[L];
+ const auto& face_nodes = face_to_node_matrix[l];
- auto local_node_number_in_cell = [&](const NodeId& node_number) {
- for (size_t i_node = 0; i_node < cell_nodes.size(); ++i_node) {
- if (node_number == cell_nodes[i_node]) {
- return i_node;
+ auto local_node_number_in_cell = [&](const NodeId& node_number) {
+ for (size_t i_node = 0; i_node < cell_nodes.size(); ++i_node) {
+ if (node_number == cell_nodes[i_node]) {
+ return i_node;
+ }
}
- }
- return std::numeric_limits<size_t>::max();
- };
+ return std::numeric_limits<size_t>::max();
+ };
- if (face_is_reversed[L]) {
- for (size_t rl = 0; rl < face_nodes.size(); ++rl) {
- const size_t R = local_node_number_in_cell(face_nodes[rl]);
- Cjr(j, R) -= Nlr(l, rl);
- }
- } else {
- for (size_t rl = 0; rl < face_nodes.size(); ++rl) {
- const size_t R = local_node_number_in_cell(face_nodes[rl]);
- Cjr(j, R) += Nlr(l, rl);
+ if (face_is_reversed[L]) {
+ for (size_t rl = 0; rl < face_nodes.size(); ++rl) {
+ const size_t R = local_node_number_in_cell(face_nodes[rl]);
+ Cjr(j, R) -= Nlr(l, rl);
+ }
+ } else {
+ for (size_t rl = 0; rl < face_nodes.size(); ++rl) {
+ const size_t R = local_node_number_in_cell(face_nodes[rl]);
+ Cjr(j, R) += Nlr(l, rl);
+ }
}
}
- }
- });
+ });
m_Cjr = Cjr;
}
{
NodeValuePerCell<double> ljr(m_mesh.connectivity());
- parallel_for(m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) {
- ljr[jr] = l2Norm(m_Cjr[jr]);
- });
+ parallel_for(
+ m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { ljr[jr] = l2Norm(m_Cjr[jr]); });
m_ljr = ljr;
}
{
NodeValuePerCell<Rd> njr(m_mesh.connectivity());
- parallel_for(m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) {
- njr[jr] = (1. / m_ljr[jr]) * m_Cjr[jr];
- });
+ parallel_for(
+ m_Cjr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { njr[jr] = (1. / m_ljr[jr]) * m_Cjr[jr]; });
m_njr = njr;
}
}
@@ -281,18 +274,19 @@ class MeshData
// in 1d Cjr are computed once for all
{
NodeValuePerCell<Rd> Cjr(m_mesh.connectivity());
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- Cjr(j, 0) = -1;
- Cjr(j, 1) = 1;
- });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ Cjr(j, 0) = -1;
+ Cjr(j, 1) = 1;
+ });
m_Cjr = Cjr;
}
// in 1d njr=Cjr (here performs a shallow copy)
m_njr = m_Cjr;
{
NodeValuePerCell<double> ljr(m_mesh.connectivity());
- parallel_for(ljr.numberOfValues(),
- PUGS_LAMBDA(const size_t& jr) { ljr[jr] = 1; });
+ parallel_for(
+ ljr.numberOfValues(), PUGS_LAMBDA(const size_t& jr) { ljr[jr] = 1; });
m_ljr = ljr;
}
}
diff --git a/src/mesh/MeshNodeBoundary.hpp b/src/mesh/MeshNodeBoundary.hpp
index 9cc040a4a228354f82a5f608d2e1b8ad447de236..8f3b6362d827df82c8838bee8936728d40071ac6 100644
--- a/src/mesh/MeshNodeBoundary.hpp
+++ b/src/mesh/MeshNodeBoundary.hpp
@@ -38,13 +38,14 @@ class MeshNodeBoundary
const auto& face_to_cell_matrix = mesh.connectivity().faceToCellMatrix();
const Array<const FaceId>& face_list = ref_face_list.list();
- parallel_for(face_list.size(), PUGS_LAMBDA(const int& l) {
- const auto& face_cells = face_to_cell_matrix[face_list[l]];
- if (face_cells.size() > 1) {
- perr() << "internal faces cannot be used to define mesh boundaries\n";
- std::exit(1);
- }
- });
+ parallel_for(
+ face_list.size(), PUGS_LAMBDA(const int& l) {
+ const auto& face_cells = face_to_cell_matrix[face_list[l]];
+ if (face_cells.size() > 1) {
+ perr() << "internal faces cannot be used to define mesh boundaries\n";
+ std::exit(1);
+ }
+ });
Kokkos::vector<unsigned int> node_ids;
// not enough but should reduce significantly the number of resizing
@@ -64,14 +65,13 @@ class MeshNodeBoundary
node_ids.resize(std::distance(node_ids.begin(), last));
Array<NodeId> node_list(node_ids.size());
- parallel_for(node_ids.size(),
- PUGS_LAMBDA(const int& r) { node_list[r] = node_ids[r]; });
+ parallel_for(
+ node_ids.size(), PUGS_LAMBDA(const int& r) { node_list[r] = node_ids[r]; });
m_node_list = node_list;
}
template <typename MeshType>
- MeshNodeBoundary(const MeshType&, const RefNodeList& ref_node_list)
- : m_node_list(ref_node_list.list())
+ MeshNodeBoundary(const MeshType&, const RefNodeList& ref_node_list) : m_node_list(ref_node_list.list())
{
static_assert(Dimension == MeshType::Dimension);
}
@@ -115,16 +115,14 @@ class MeshFlatNodeBoundary : public MeshNodeBoundary<Dimension>
template <typename MeshType>
MeshFlatNodeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list)
- : MeshNodeBoundary<Dimension>(mesh, ref_face_list),
- m_outgoing_normal(_getOutgoingNormal(mesh))
+ : MeshNodeBoundary<Dimension>(mesh, ref_face_list), m_outgoing_normal(_getOutgoingNormal(mesh))
{
;
}
template <typename MeshType>
MeshFlatNodeBoundary(const MeshType& mesh, const RefNodeList& ref_node_list)
- : MeshNodeBoundary<Dimension>(mesh, ref_node_list),
- m_outgoing_normal(_getOutgoingNormal(mesh))
+ : MeshNodeBoundary<Dimension>(mesh, ref_node_list), m_outgoing_normal(_getOutgoingNormal(mesh))
{
;
}
@@ -138,11 +136,10 @@ class MeshFlatNodeBoundary : public MeshNodeBoundary<Dimension>
template <>
template <typename MeshType>
void
-MeshFlatNodeBoundary<2>::_checkBoundaryIsFlat(
- const TinyVector<2, double>& normal,
- const TinyVector<2, double>& xmin,
- const TinyVector<2, double>& xmax,
- const MeshType& mesh) const
+MeshFlatNodeBoundary<2>::_checkBoundaryIsFlat(const TinyVector<2, double>& normal,
+ const TinyVector<2, double>& xmin,
+ const TinyVector<2, double>& xmax,
+ const MeshType& mesh) const
{
static_assert(MeshType::Dimension == 2);
using R2 = TinyVector<2, double>;
@@ -152,13 +149,14 @@ MeshFlatNodeBoundary<2>::_checkBoundaryIsFlat(
const NodeValue<const R2>& xr = mesh.xr();
- parallel_for(m_node_list.size(), PUGS_LAMBDA(const size_t& r) {
- const R2& x = xr[m_node_list[r]];
- if ((x - origin, normal) > 1E-13 * length) {
- perr() << "this FlatBoundary is not flat!\n";
- std::exit(1);
- }
- });
+ parallel_for(
+ m_node_list.size(), PUGS_LAMBDA(const size_t& r) {
+ const R2& x = xr[m_node_list[r]];
+ if ((x - origin, normal) > 1E-13 * length) {
+ perr() << "this FlatBoundary is not flat!\n";
+ std::exit(1);
+ }
+ });
}
template <>
@@ -187,11 +185,9 @@ MeshFlatNodeBoundary<2>::_getNormal(const MeshType& mesh)
const NodeValue<const R2>& xr = mesh.xr();
- R2 xmin(std::numeric_limits<double>::max(),
- std::numeric_limits<double>::max());
+ R2 xmin(std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
- R2 xmax(-std::numeric_limits<double>::max(),
- -std::numeric_limits<double>::max());
+ R2 xmax(-std::numeric_limits<double>::max(), -std::numeric_limits<double>::max());
for (size_t r = 0; r < m_node_list.size(); ++r) {
const R2& x = xr[m_node_list[r]];
@@ -219,8 +215,7 @@ MeshFlatNodeBoundary<2>::_getNormal(const MeshType& mesh)
}
if (xmin == xmax) {
- perr() << "xmin==xmax (" << xmin << "==" << xmax
- << ") unable to compute normal";
+ perr() << "xmin==xmax (" << xmin << "==" << xmax << ") unable to compute normal";
std::exit(1);
}
@@ -242,9 +237,7 @@ MeshFlatNodeBoundary<3>::_getNormal(const MeshType& mesh)
static_assert(MeshType::Dimension == 3);
using R3 = TinyVector<3, double>;
- R3 xmin(std::numeric_limits<double>::max(),
- std::numeric_limits<double>::max(),
- std::numeric_limits<double>::max());
+ R3 xmin(std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
R3 ymin = xmin;
R3 zmin = xmin;
;
diff --git a/src/mesh/RefId.hpp b/src/mesh/RefId.hpp
index aebc9d7d7f9ad2b12776dca6cc9b15514a95339d..35b9c4ef2966d151def68f29736b23a496cd8151 100644
--- a/src/mesh/RefId.hpp
+++ b/src/mesh/RefId.hpp
@@ -29,16 +29,14 @@ class RefId
bool
operator==(const RefId& ref_id) const
{
- return ((m_tag_number == ref_id.m_tag_number) and
- (m_tag_name == ref_id.m_tag_name));
+ return ((m_tag_number == ref_id.m_tag_number) and (m_tag_name == ref_id.m_tag_name));
}
bool
operator<(const RefId& ref_id) const
{
return ((m_tag_number < ref_id.m_tag_number) or
- ((m_tag_number == ref_id.m_tag_number) and
- (m_tag_name < ref_id.m_tag_name)));
+ ((m_tag_number == ref_id.m_tag_number) and (m_tag_name < ref_id.m_tag_name)));
}
TagNumberType
@@ -65,8 +63,7 @@ class RefId
;
}
- explicit RefId(const TagNumberType& tag_number)
- : m_tag_number(tag_number), m_tag_name(std::to_string(tag_number))
+ explicit RefId(const TagNumberType& tag_number) : m_tag_number(tag_number), m_tag_name(std::to_string(tag_number))
{
;
}
diff --git a/src/mesh/SubItemValuePerItem.hpp b/src/mesh/SubItemValuePerItem.hpp
index 6f350feb8aac001cfafe16ab53fe5de1de0a5abd..132a0fb83d3d6c9a04a21f59a99e8beccb765d18 100644
--- a/src/mesh/SubItemValuePerItem.hpp
+++ b/src/mesh/SubItemValuePerItem.hpp
@@ -17,9 +17,7 @@
#include <memory>
-template <typename DataType,
- typename ItemOfItem,
- typename ConnectivityPtr = std::shared_ptr<const IConnectivity>>
+template <typename DataType, typename ItemOfItem, typename ConnectivityPtr = std::shared_ptr<const IConnectivity>>
class SubItemValuePerItem
{
public:
@@ -44,18 +42,13 @@ class SubItemValuePerItem
Array<DataType> m_values;
// Allow const std:shared_ptr version to access our data
- friend SubItemValuePerItem<std::add_const_t<DataType>,
- ItemOfItem,
- ConnectivitySharedPtr>;
+ friend SubItemValuePerItem<std::add_const_t<DataType>, ItemOfItem, ConnectivitySharedPtr>;
// Allow const std:weak_ptr version to access our data
- friend SubItemValuePerItem<std::add_const_t<DataType>,
- ItemOfItem,
- ConnectivityWeakPtr>;
+ friend SubItemValuePerItem<std::add_const_t<DataType>, ItemOfItem, ConnectivityWeakPtr>;
public:
- using ToShared =
- SubItemValuePerItem<DataType, ItemOfItem, ConnectivitySharedPtr>;
+ using ToShared = SubItemValuePerItem<DataType, ItemOfItem, ConnectivitySharedPtr>;
class SubView
{
@@ -94,9 +87,7 @@ class SubItemValuePerItem
SubView(SubView&&) noexcept = default;
PUGS_INLINE
- SubView(const Array<DataType>& values,
- const size_t& begin,
- const size_t& end) noexcept(NO_ASSERT)
+ SubView(const Array<DataType>& values, const size_t& begin, const size_t& end) noexcept(NO_ASSERT)
: m_sub_values(&(values[begin])), m_size(end - begin)
{
Assert(begin <= end);
@@ -125,8 +116,7 @@ class SubItemValuePerItem
PUGS_FORCEINLINE DataType&
operator()(const IndexType& j, const size_t& r) const noexcept(NO_ASSERT)
{
- static_assert(std::is_same_v<IndexType, ItemId>,
- "SubItemValuePerItem indexed by ItemId");
+ static_assert(std::is_same_v<IndexType, ItemId>, "SubItemValuePerItem indexed by ItemId");
Assert(this->isBuilt());
return m_values[m_host_row_map(size_t{j}) + r];
}
@@ -151,9 +141,8 @@ class SubItemValuePerItem
template <typename IndexType>
DataType& operator[](const IndexType& i) const noexcept(NO_ASSERT)
{
- static_assert(
- std::is_same_v<IndexType, size_t>,
- "Access to SubItemValuePerItem's array must be indexed by size_t");
+ static_assert(std::is_same_v<IndexType, size_t>, "Access to SubItemValuePerItem's array must be indexed by "
+ "size_t");
Assert(this->isBuilt());
return m_values[i];
}
@@ -199,16 +188,13 @@ class SubItemValuePerItem
template <typename DataType2, typename ConnectivityPtr2>
PUGS_INLINE SubItemValuePerItem&
- operator=(const SubItemValuePerItem<DataType2, ItemOfItem, ConnectivityPtr2>&
- sub_item_value_per_item) noexcept
+ operator=(const SubItemValuePerItem<DataType2, ItemOfItem, ConnectivityPtr2>& sub_item_value_per_item) noexcept
{
// ensures that DataType is the same as source DataType2
- static_assert(std::is_same_v<std::remove_const_t<DataType>,
- std::remove_const_t<DataType2>>,
+ static_assert(std::is_same_v<std::remove_const_t<DataType>, std::remove_const_t<DataType2>>,
"Cannot assign SubItemValuePerItem of different type");
// ensures that const is not lost through copy
- static_assert(((std::is_const_v<DataType2> and std::is_const_v<DataType>) or
- not std::is_const_v<DataType2>),
+ static_assert(((std::is_const_v<DataType2> and std::is_const_v<DataType>) or not std::is_const_v<DataType2>),
"Cannot assign SubItemValuePerItem of const data to "
"SubItemValuePerItem of non-const data");
m_host_row_map = sub_item_value_per_item.m_host_row_map;
@@ -227,28 +213,23 @@ class SubItemValuePerItem
template <typename DataType2, typename ConnectivityPtr2>
PUGS_INLINE
SubItemValuePerItem(
- const SubItemValuePerItem<DataType2, ItemOfItem, ConnectivityPtr2>&
- sub_item_value_per_item) noexcept
+ const SubItemValuePerItem<DataType2, ItemOfItem, ConnectivityPtr2>& sub_item_value_per_item) noexcept
{
this->operator=(sub_item_value_per_item);
}
SubItemValuePerItem() = default;
- SubItemValuePerItem(const IConnectivity& connectivity) noexcept
- : m_connectivity_ptr{connectivity.shared_ptr()}
+ SubItemValuePerItem(const IConnectivity& connectivity) noexcept : m_connectivity_ptr{connectivity.shared_ptr()}
{
- static_assert(not std::is_const_v<DataType>,
- "Cannot allocate SubItemValuePerItem of const data: only "
- "view is supported");
+ static_assert(not std::is_const_v<DataType>, "Cannot allocate SubItemValuePerItem of const data: only "
+ "view is supported");
;
- ConnectivityMatrix connectivity_matrix =
- connectivity._getMatrix(item_type, sub_item_type);
+ ConnectivityMatrix connectivity_matrix = connectivity._getMatrix(item_type, sub_item_type);
m_host_row_map = connectivity_matrix.rowsMap();
- m_values =
- Array<std::remove_const_t<DataType>>(connectivity_matrix.numEntries());
+ m_values = Array<std::remove_const_t<DataType>>(connectivity_matrix.numEntries());
}
~SubItemValuePerItem() = default;
@@ -302,8 +283,7 @@ using CellValuePerFace = SubItemValuePerItem<DataType, CellOfFace>;
// Item values at nodes
template <typename DataType, typename ItemOfItem>
-using WeakSubItemValuePerItem =
- SubItemValuePerItem<DataType, ItemOfItem, std::weak_ptr<const IConnectivity>>;
+using WeakSubItemValuePerItem = SubItemValuePerItem<DataType, ItemOfItem, std::weak_ptr<const IConnectivity>>;
template <typename DataType>
using WeakNodeValuePerEdge = WeakSubItemValuePerItem<DataType, NodeOfEdge>;
diff --git a/src/mesh/Synchronizer.hpp b/src/mesh/Synchronizer.hpp
index ed378365dba4e1c9745ca71785fd2d554733bfb7..30781a63a0d67bbc9ee4031f82d579d92a6a2194 100644
--- a/src/mesh/Synchronizer.hpp
+++ b/src/mesh/Synchronizer.hpp
@@ -62,53 +62,44 @@ class Synchronizer
auto& requested_item_info = this->_getRequestedItemInfo<item_type>();
requested_item_info = [&]() {
- std::vector<std::vector<ItemId>> requested_item_vector_info(
- parallel::size());
+ std::vector<std::vector<ItemId>> requested_item_vector_info(parallel::size());
for (ItemId item_id = 0; item_id < item_owner.size(); ++item_id) {
- if (const size_t owner = item_owner[item_id];
- owner != parallel::rank()) {
+ if (const size_t owner = item_owner[item_id]; owner != parallel::rank()) {
requested_item_vector_info[owner].emplace_back(item_id);
}
}
std::vector<Array<const ItemId>> requested_item_info(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
const auto& requested_item_vector = requested_item_vector_info[i_rank];
- requested_item_info[i_rank] = convert_to_array(requested_item_vector);
+ requested_item_info[i_rank] = convert_to_array(requested_item_vector);
}
return requested_item_info;
}();
Array<unsigned int> local_number_of_requested_values(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- local_number_of_requested_values[i_rank] =
- requested_item_info[i_rank].size();
+ local_number_of_requested_values[i_rank] = requested_item_info[i_rank].size();
}
- Array<unsigned int> local_number_of_values_to_send =
- parallel::allToAll(local_number_of_requested_values);
+ Array<unsigned int> local_number_of_values_to_send = parallel::allToAll(local_number_of_requested_values);
- std::vector<Array<const int>> requested_item_number_list_by_proc(
- parallel::size());
+ std::vector<Array<const int>> requested_item_number_list_by_proc(parallel::size());
const auto& item_number = connectivity.template number<item_type>();
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
const auto& requested_item_info_from_rank = requested_item_info[i_rank];
Array<int> item_number_list{requested_item_info_from_rank.size()};
- parallel_for(requested_item_info_from_rank.size(),
- PUGS_LAMBDA(size_t i_item) {
- item_number_list[i_item] =
- item_number[requested_item_info_from_rank[i_item]];
- });
+ parallel_for(
+ requested_item_info_from_rank.size(),
+ PUGS_LAMBDA(size_t i_item) { item_number_list[i_item] = item_number[requested_item_info_from_rank[i_item]]; });
requested_item_number_list_by_proc[i_rank] = item_number_list;
}
std::vector<Array<int>> provided_item_number_list_by_rank(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- provided_item_number_list_by_rank[i_rank] =
- Array<int>{local_number_of_values_to_send[i_rank]};
+ provided_item_number_list_by_rank[i_rank] = Array<int>{local_number_of_values_to_send[i_rank]};
}
- parallel::exchange(requested_item_number_list_by_proc,
- provided_item_number_list_by_rank);
+ parallel::exchange(requested_item_number_list_by_proc, provided_item_number_list_by_rank);
std::map<int, ItemId> item_number_to_id_correspondance;
for (ItemId item_id = 0; item_id < item_number.size(); ++item_id) {
@@ -119,14 +110,10 @@ class Synchronizer
provided_item_info = [&]() {
std::vector<Array<const ItemId>> provided_item_info(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- Array<ItemId> provided_item_id_to_rank{
- local_number_of_values_to_send[i_rank]};
- const Array<int>& provided_item_number_to_rank =
- provided_item_number_list_by_rank[i_rank];
+ Array<ItemId> provided_item_id_to_rank{local_number_of_values_to_send[i_rank]};
+ const Array<int>& provided_item_number_to_rank = provided_item_number_list_by_rank[i_rank];
for (size_t i = 0; i < provided_item_number_to_rank.size(); ++i) {
- provided_item_id_to_rank[i] = item_number_to_id_correspondance
- .find(provided_item_number_to_rank[i])
- ->second;
+ provided_item_id_to_rank[i] = item_number_to_id_correspondance.find(provided_item_number_to_rank[i])->second;
}
provided_item_info[i_rank] = provided_item_id_to_rank;
}
@@ -134,16 +121,11 @@ class Synchronizer
}();
}
- template <typename ConnectivityType,
- typename DataType,
- ItemType item_type,
- typename ConnectivityPtr>
+ template <typename ConnectivityType, typename DataType, ItemType item_type, typename ConnectivityPtr>
PUGS_INLINE void
- _synchronize(const ConnectivityType& connectivity,
- ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
+ _synchronize(const ConnectivityType& connectivity, ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
{
- static_assert(not std::is_abstract_v<ConnectivityType>,
- "_synchronize must be called on a concrete connectivity");
+ static_assert(not std::is_abstract_v<ConnectivityType>, "_synchronize must be called on a concrete connectivity");
using ItemId = ItemIdT<item_type>;
@@ -158,20 +140,18 @@ class Synchronizer
std::vector<Array<const DataType>> provided_data_list(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
- const Array<const ItemId>& provided_item_info_to_rank =
- provided_item_info[i_rank];
+ const Array<const ItemId>& provided_item_info_to_rank = provided_item_info[i_rank];
Array<DataType> provided_data{provided_item_info_to_rank.size()};
- parallel_for(provided_item_info_to_rank.size(), PUGS_LAMBDA(size_t i) {
- provided_data[i] = item_value[provided_item_info_to_rank[i]];
- });
+ parallel_for(
+ provided_item_info_to_rank.size(),
+ PUGS_LAMBDA(size_t i) { provided_data[i] = item_value[provided_item_info_to_rank[i]]; });
provided_data_list[i_rank] = provided_data;
}
std::vector<Array<DataType>> requested_data_list(parallel::size());
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
const auto& requested_item_info_from_rank = requested_item_info[i_rank];
- requested_data_list[i_rank] =
- Array<DataType>{requested_item_info_from_rank.size()};
+ requested_data_list[i_rank] = Array<DataType>{requested_item_info_from_rank.size()};
}
parallel::exchange(provided_data_list, requested_data_list);
@@ -179,9 +159,9 @@ class Synchronizer
for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
const auto& requested_item_info_from_rank = requested_item_info[i_rank];
const auto& requested_data = requested_data_list[i_rank];
- parallel_for(requested_item_info_from_rank.size(), PUGS_LAMBDA(size_t i) {
- item_value[requested_item_info_from_rank[i]] = requested_data[i];
- });
+ parallel_for(
+ requested_item_info_from_rank.size(),
+ PUGS_LAMBDA(size_t i) { item_value[requested_item_info_from_rank[i]] = requested_data[i]; });
}
}
@@ -190,30 +170,26 @@ class Synchronizer
PUGS_INLINE void
synchronize(ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
{
- Assert(item_value.connectivity_ptr().use_count() > 0,
- "No connectivity is associated to this ItemValue");
+ Assert(item_value.connectivity_ptr().use_count() > 0, "No connectivity is associated to this ItemValue");
const IConnectivity& connectivity = *item_value.connectivity_ptr();
switch (connectivity.dimension()) {
- case 1: {
- this->_synchronize(static_cast<const Connectivity1D&>(connectivity),
- item_value);
- break;
- }
- case 2: {
- this->_synchronize(static_cast<const Connectivity2D&>(connectivity),
- item_value);
- break;
- }
- case 3: {
- this->_synchronize(static_cast<const Connectivity3D&>(connectivity),
- item_value);
- break;
- }
- default: {
- perr() << __FILE__ << ':' << __LINE__ << ": unexpected dimension\n";
- std::terminate();
- }
+ case 1: {
+ this->_synchronize(static_cast<const Connectivity1D&>(connectivity), item_value);
+ break;
+ }
+ case 2: {
+ this->_synchronize(static_cast<const Connectivity2D&>(connectivity), item_value);
+ break;
+ }
+ case 3: {
+ this->_synchronize(static_cast<const Connectivity3D&>(connectivity), item_value);
+ break;
+ }
+ default: {
+ perr() << __FILE__ << ':' << __LINE__ << ": unexpected dimension\n";
+ std::terminate();
+ }
}
}
diff --git a/src/mesh/SynchronizerManager.cpp b/src/mesh/SynchronizerManager.cpp
index 7854eb768be58ac4881c95c66ddddd38f80784f4..e739394e3fa24708a0165904d6e03d7934f48c69 100644
--- a/src/mesh/SynchronizerManager.cpp
+++ b/src/mesh/SynchronizerManager.cpp
@@ -9,8 +9,7 @@ SynchronizerManager* SynchronizerManager::m_instance{nullptr};
SynchronizerManager::~SynchronizerManager()
{
if (m_connectivity_synchronizer_map.size() > 0) {
- perr() << __FILE__ << ':' << __LINE__
- << ": warning: some connectivities are still registered\n";
+ perr() << __FILE__ << ':' << __LINE__ << ": warning: some connectivities are still registered\n";
;
}
}
@@ -31,22 +30,19 @@ SynchronizerManager::destroy()
}
void
-SynchronizerManager::deleteConnectivitySynchronizer(
- const IConnectivity* connectivity)
+SynchronizerManager::deleteConnectivitySynchronizer(const IConnectivity* connectivity)
{
m_connectivity_synchronizer_map.erase(connectivity);
}
Synchronizer&
-SynchronizerManager::getConnectivitySynchronizer(
- const IConnectivity* connectivity)
+SynchronizerManager::getConnectivitySynchronizer(const IConnectivity* connectivity)
{
- if (auto connectivity_synchronizer =
- m_connectivity_synchronizer_map.find(connectivity);
+ if (auto connectivity_synchronizer = m_connectivity_synchronizer_map.find(connectivity);
connectivity_synchronizer != m_connectivity_synchronizer_map.end()) {
return (*connectivity_synchronizer->second);
} else {
- std::shared_ptr synchronizer = std::make_shared<Synchronizer>();
+ std::shared_ptr synchronizer = std::make_shared<Synchronizer>();
m_connectivity_synchronizer_map[connectivity] = synchronizer;
return *synchronizer;
}
diff --git a/src/mesh/SynchronizerManager.hpp b/src/mesh/SynchronizerManager.hpp
index 4ba1911d3e7d57c4fd48957c4abe742434098925..da01e98458a43f619932a3ad5b85ecead22e28f5 100644
--- a/src/mesh/SynchronizerManager.hpp
+++ b/src/mesh/SynchronizerManager.hpp
@@ -13,8 +13,7 @@ class Synchronizer;
class SynchronizerManager
{
private:
- std::map<const IConnectivity*, std::shared_ptr<Synchronizer>>
- m_connectivity_synchronizer_map;
+ std::map<const IConnectivity*, std::shared_ptr<Synchronizer>> m_connectivity_synchronizer_map;
static SynchronizerManager* m_instance;
SynchronizerManager() = default;
diff --git a/src/output/OutputNamedItemValueSet.hpp b/src/output/OutputNamedItemValueSet.hpp
index 301652cf0326c0b7550c2eb0f31fca26a7b9d4c5..a893ab31cc01c9ec6e44900db229ad08dd478160 100644
--- a/src/output/OutputNamedItemValueSet.hpp
+++ b/src/output/OutputNamedItemValueSet.hpp
@@ -33,16 +33,13 @@ class NamedItemValue
NamedItemValue& operator=(NamedItemValue&&) = default;
template <typename ConnectivityPtr>
- NamedItemValue(
- const std::string& name,
- const ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
+ NamedItemValue(const std::string& name, const ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
: m_name(name), m_item_value(item_value)
{
;
}
- NamedItemValue(const std::string& name,
- const ItemValue<const DataType, item_type>& item_value)
+ NamedItemValue(const std::string& name, const ItemValue<const DataType, item_type>& item_value)
: m_name(name), m_item_value(item_value)
{
;
@@ -77,18 +74,14 @@ class OutputNamedItemValueSet
PUGS_FORCEINLINE constexpr void
_doInsert(const NamedItemValue<DataType, item_type>& named_itemvalue)
{
- if (m_name_itemvariant_map.find(named_itemvalue.name()) ==
- m_name_itemvariant_map.end()) {
- m_name_itemvariant_map[named_itemvalue.name()] =
- named_itemvalue.itemValue();
+ if (m_name_itemvariant_map.find(named_itemvalue.name()) == m_name_itemvariant_map.end()) {
+ m_name_itemvariant_map[named_itemvalue.name()] = named_itemvalue.itemValue();
}
}
template <typename DataType, ItemType item_type, typename... Args>
PUGS_FORCEINLINE constexpr void
- _unpackVariadicInput(
- const NamedItemValue<DataType, item_type>& named_itemvalue,
- Args&&... args)
+ _unpackVariadicInput(const NamedItemValue<DataType, item_type>& named_itemvalue, Args&&... args)
{
_doInsert(named_itemvalue);
if constexpr (sizeof...(args) > 0) {
@@ -110,8 +103,7 @@ class OutputNamedItemValueSet
}
template <typename... DataType, ItemType... item_type>
- OutputNamedItemValueSet(
- NamedItemValue<DataType, item_type>... named_itemvalue)
+ OutputNamedItemValueSet(NamedItemValue<DataType, item_type>... named_itemvalue)
{
_unpackVariadicInput(named_itemvalue...);
}
diff --git a/src/output/VTKWriter.hpp b/src/output/VTKWriter.hpp
index 5a5fe82cbcbdf606981c7a6f0d87b7008d6fa68b..4793c1bf29c511fca2437a353aef229d9f5f0e8e 100644
--- a/src/output/VTKWriter.hpp
+++ b/src/output/VTKWriter.hpp
@@ -25,8 +25,7 @@ class VTKWriter
{
std::ostringstream sout;
sout << m_base_filename;
- sout << '.' << std::setfill('0') << std::setw(4) << m_file_number
- << ".pvtu";
+ sout << '.' << std::setfill('0') << std::setw(4) << m_file_number << ".pvtu";
return sout.str();
}
std::string
@@ -43,72 +42,55 @@ class VTKWriter
template <typename DataType>
void
- _write_node_pvtu(std::ofstream& os,
- const std::string& name,
- const NodeValue<const DataType>&)
+ _write_node_pvtu(std::ofstream& os, const std::string& name, const NodeValue<const DataType>&)
{
- os << "<PDataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\"/>\n";
+ os << "<PDataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\"/>\n";
}
template <size_t N, typename DataType>
void
- _write_node_pvtu(std::ofstream& os,
- const std::string& name,
- const NodeValue<const TinyVector<N, DataType>>&)
+ _write_node_pvtu(std::ofstream& os, const std::string& name, const NodeValue<const TinyVector<N, DataType>>&)
{
- os << "<PDataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\" NumberOfComponents=\"" << N << "\"/>\n";
+ os << "<PDataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\" NumberOfComponents=\"" << N
+ << "\"/>\n";
}
template <typename DataType>
void
- _write_node_pvtu(std::ofstream&,
- const std::string&,
- const CellValue<const DataType>&)
+ _write_node_pvtu(std::ofstream&, const std::string&, const CellValue<const DataType>&)
{}
template <typename DataType>
void
- _write_cell_pvtu(std::ofstream& os,
- const std::string& name,
- const CellValue<const DataType>&)
+ _write_cell_pvtu(std::ofstream& os, const std::string& name, const CellValue<const DataType>&)
{
- os << "<PDataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\"/>\n";
+ os << "<PDataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\"/>\n";
}
template <size_t N, typename DataType>
void
- _write_cell_pvtu(std::ofstream& os,
- const std::string& name,
- const CellValue<const TinyVector<N, DataType>>&)
+ _write_cell_pvtu(std::ofstream& os, const std::string& name, const CellValue<const TinyVector<N, DataType>>&)
{
- os << "<PDataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\" NumberOfComponents=\"" << N << "\"/>\n";
+ os << "<PDataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\" NumberOfComponents=\"" << N
+ << "\"/>\n";
}
template <typename DataType>
void
- _write_cell_pvtu(std::ofstream&,
- const std::string&,
- const NodeValue<const DataType>&)
+ _write_cell_pvtu(std::ofstream&, const std::string&, const NodeValue<const DataType>&)
{}
template <typename DataType>
struct VTKType
- {};
+ {
+ };
template <typename DataType>
void
- _write_array(std::ofstream& os,
- const std::string& name,
- const Array<DataType>& item_value)
+ _write_array(std::ofstream& os, const std::string& name, const Array<DataType>& item_value)
{
- os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\">\n";
- for (typename Array<DataType>::index_type i = 0; i < item_value.size();
- ++i) {
+ os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\">\n";
+ for (typename Array<DataType>::index_type i = 0; i < item_value.size(); ++i) {
// The following '+' enforces integer output for char types
os << +item_value[i] << ' ';
}
@@ -117,14 +99,11 @@ class VTKWriter
template <size_t N, typename DataType>
void
- _write_array(std::ofstream& os,
- const std::string& name,
- const Array<TinyVector<N, DataType>>& item_value)
+ _write_array(std::ofstream& os, const std::string& name, const Array<TinyVector<N, DataType>>& item_value)
{
- os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\" NumberOfComponents=\"" << N << "\">\n";
- for (typename Array<DataType>::index_type i = 0; i < item_value.size();
- ++i) {
+ os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\" NumberOfComponents=\"" << N
+ << "\">\n";
+ for (typename Array<DataType>::index_type i = 0; i < item_value.size(); ++i) {
for (size_t j = 0; j < N; ++j) {
// The following '+' enforces integer output for char types
os << +item_value[i][j] << ' ';
@@ -135,12 +114,9 @@ class VTKWriter
template <typename DataType>
void
- _write_node_value(std::ofstream& os,
- const std::string& name,
- const NodeValue<const DataType>& item_value)
+ _write_node_value(std::ofstream& os, const std::string& name, const NodeValue<const DataType>& item_value)
{
- os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\">\n";
+ os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\">\n";
for (NodeId i = 0; i < item_value.size(); ++i) {
// The following '+' enforces integer output for char types
os << +item_value[i] << ' ';
@@ -154,8 +130,8 @@ class VTKWriter
const std::string& name,
const NodeValue<const TinyVector<N, DataType>>& item_value)
{
- os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\" NumberOfComponents=\"" << N << "\">\n";
+ os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\" NumberOfComponents=\"" << N
+ << "\">\n";
for (NodeId i = 0; i < item_value.size(); ++i) {
for (size_t j = 0; j < N; ++j) {
// The following '+' enforces integer output for char types
@@ -167,19 +143,14 @@ class VTKWriter
template <typename DataType>
void
- _write_node_value(std::ofstream&,
- const std::string&,
- const CellValue<const DataType>&)
+ _write_node_value(std::ofstream&, const std::string&, const CellValue<const DataType>&)
{}
template <typename DataType>
void
- _write_cell_value(std::ofstream& os,
- const std::string& name,
- const CellValue<const DataType>& item_value)
+ _write_cell_value(std::ofstream& os, const std::string& name, const CellValue<const DataType>& item_value)
{
- os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\">\n";
+ os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\">\n";
for (CellId i = 0; i < item_value.size(); ++i) {
// The following '+' enforces integer output for char types
os << +item_value[i] << ' ';
@@ -193,8 +164,8 @@ class VTKWriter
const std::string& name,
const CellValue<const TinyVector<N, DataType>>& item_value)
{
- os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\""
- << name << "\" NumberOfComponents=\"" << N << "\">\n";
+ os << "<DataArray type=\"" << VTKType<DataType>::name << "\" Name=\"" << name << "\" NumberOfComponents=\"" << N
+ << "\">\n";
for (CellId i = 0; i < item_value.size(); ++i) {
for (size_t j = 0; j < N; ++j) {
// The following '+' enforces integer output for char types
@@ -206,9 +177,7 @@ class VTKWriter
template <typename DataType>
void
- _write_cell_value(std::ofstream&,
- const std::string&,
- const NodeValue<const DataType>&)
+ _write_cell_value(std::ofstream&, const std::string&, const NodeValue<const DataType>&)
{}
public:
@@ -245,35 +214,23 @@ class VTKWriter
"NumberOfComponents=\"1\"/>\n";
fout << "<PDataArray type=\"Int8\" Name=\"types\" "
"NumberOfComponents=\"1\"/>\n";
- for (const auto& [name, item_value_variant] :
- output_named_item_value_set) {
- std::visit(
- [&, name = name](auto&& item_value) {
- return this->_write_cell_pvtu(fout, name, item_value);
- },
- item_value_variant);
+ for (const auto& [name, item_value_variant] : output_named_item_value_set) {
+ std::visit([&, name = name](auto&& item_value) { return this->_write_cell_pvtu(fout, name, item_value); },
+ item_value_variant);
}
fout << "</PCells>\n";
fout << "<PPointData>\n";
- for (const auto& [name, item_value_variant] :
- output_named_item_value_set) {
- std::visit(
- [&, name = name](auto&& item_value) {
- return this->_write_node_pvtu(fout, name, item_value);
- },
- item_value_variant);
+ for (const auto& [name, item_value_variant] : output_named_item_value_set) {
+ std::visit([&, name = name](auto&& item_value) { return this->_write_node_pvtu(fout, name, item_value); },
+ item_value_variant);
}
fout << "</PPointData>\n";
fout << "<PCellData>\n";
- for (const auto& [name, item_value_variant] :
- output_named_item_value_set) {
- std::visit(
- [&, name = name](auto&& item_value) {
- return this->_write_cell_pvtu(fout, name, item_value);
- },
- item_value_variant);
+ for (const auto& [name, item_value_variant] : output_named_item_value_set) {
+ std::visit([&, name = name](auto&& item_value) { return this->_write_cell_pvtu(fout, name, item_value); },
+ item_value_variant);
}
fout << "</PCellData>\n";
@@ -289,26 +246,18 @@ class VTKWriter
fout << "<?xml version=\"1.0\"?>\n";
fout << "<VTKFile type=\"UnstructuredGrid\">\n";
fout << "<UnstructuredGrid>\n";
- fout << "<Piece NumberOfPoints=\"" << mesh.numberOfNodes()
- << "\" NumberOfCells=\"" << mesh.numberOfCells() << "\">\n";
+ fout << "<Piece NumberOfPoints=\"" << mesh.numberOfNodes() << "\" NumberOfCells=\"" << mesh.numberOfCells()
+ << "\">\n";
fout << "<CellData>\n";
- for (const auto& [name, item_value_variant] :
- output_named_item_value_set) {
- std::visit(
- [&, name = name](auto&& item_value) {
- return this->_write_cell_value(fout, name, item_value);
- },
- item_value_variant);
+ for (const auto& [name, item_value_variant] : output_named_item_value_set) {
+ std::visit([&, name = name](auto&& item_value) { return this->_write_cell_value(fout, name, item_value); },
+ item_value_variant);
}
fout << "</CellData>\n";
fout << "<PointData>\n";
- for (const auto& [name, item_value_variant] :
- output_named_item_value_set) {
- std::visit(
- [&, name = name](auto&& item_value) {
- return this->_write_node_value(fout, name, item_value);
- },
- item_value_variant);
+ for (const auto& [name, item_value_variant] : output_named_item_value_set) {
+ std::visit([&, name = name](auto&& item_value) { return this->_write_node_value(fout, name, item_value); },
+ item_value_variant);
}
fout << "</PointData>\n";
fout << "<Points>\n";
@@ -316,29 +265,28 @@ class VTKWriter
using Rd = TinyVector<MeshType::Dimension>;
const NodeValue<const Rd>& xr = mesh.xr();
Array<TinyVector<3>> positions(mesh.numberOfNodes());
- parallel_for(mesh.numberOfNodes(), PUGS_LAMBDA(NodeId r) {
- for (unsigned short i = 0; i < MeshType::Dimension; ++i) {
- positions[r][i] = xr[r][i];
- }
- for (unsigned short i = MeshType::Dimension; i < 3; ++i) {
- positions[r][i] = 0;
- }
- });
+ parallel_for(
+ mesh.numberOfNodes(), PUGS_LAMBDA(NodeId r) {
+ for (unsigned short i = 0; i < MeshType::Dimension; ++i) {
+ positions[r][i] = xr[r][i];
+ }
+ for (unsigned short i = MeshType::Dimension; i < 3; ++i) {
+ positions[r][i] = 0;
+ }
+ });
_write_array(fout, "Positions", positions);
}
fout << "</Points>\n";
fout << "<Cells>\n";
{
- const auto& cell_to_node_matrix =
- mesh.connectivity().cellToNodeMatrix();
+ const auto& cell_to_node_matrix = mesh.connectivity().cellToNodeMatrix();
_write_array(fout, "connectivity", cell_to_node_matrix.entries());
}
{
- const auto& cell_to_node_matrix =
- mesh.connectivity().cellToNodeMatrix();
+ const auto& cell_to_node_matrix = mesh.connectivity().cellToNodeMatrix();
Array<unsigned int> offsets(mesh.numberOfCells());
unsigned int offset = 0;
for (CellId j = 0; j < mesh.numberOfCells(); ++j) {
@@ -352,8 +300,9 @@ class VTKWriter
{
Array<int8_t> types(mesh.numberOfCells());
const auto& cell_type = mesh.connectivity().cellType();
- parallel_for(mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- switch (cell_type[j]) {
+ parallel_for(
+ mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ switch (cell_type[j]) {
case CellType::Line: {
types[j] = 3;
break;
@@ -383,12 +332,11 @@ class VTKWriter
break;
}
default: {
- std::cerr << __FILE__ << ':' << __LINE__
- << ": unknown cell type\n";
+ std::cerr << __FILE__ << ':' << __LINE__ << ": unknown cell type\n";
std::exit(1);
}
- }
- });
+ }
+ });
_write_array(fout, "types", types);
}
diff --git a/src/scheme/AcousticSolver.hpp b/src/scheme/AcousticSolver.hpp
index caf300bd8f9715a920099158809a2aaab1c227ae..01b485f5f9007b2d73328fd10bbac4ba1b6df154 100644
--- a/src/scheme/AcousticSolver.hpp
+++ b/src/scheme/AcousticSolver.hpp
@@ -38,12 +38,10 @@ class AcousticSolver
private:
PUGS_INLINE
const CellValue<const double>
- computeRhoCj(const CellValue<const double>& rhoj,
- const CellValue<const double>& cj)
+ computeRhoCj(const CellValue<const double>& rhoj, const CellValue<const double>& cj)
{
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- m_rhocj[j] = rhoj[j] * cj[j];
- });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_rhocj[j] = rhoj[j] * cj[j]; });
return m_rhocj;
}
@@ -54,36 +52,36 @@ class AcousticSolver
const NodeValuePerCell<const double>& /* ljr */,
const NodeValuePerCell<const Rd>& njr)
{
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- const size_t& nb_nodes = m_Ajr.numberOfSubValues(j);
- const double& rho_c = rhocj[j];
- for (size_t r = 0; r < nb_nodes; ++r) {
- m_Ajr(j, r) = tensorProduct(rho_c * Cjr(j, r), njr(j, r));
- }
- });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ const size_t& nb_nodes = m_Ajr.numberOfSubValues(j);
+ const double& rho_c = rhocj[j];
+ for (size_t r = 0; r < nb_nodes; ++r) {
+ m_Ajr(j, r) = tensorProduct(rho_c * Cjr(j, r), njr(j, r));
+ }
+ });
}
PUGS_INLINE
const NodeValue<const Rdd>
computeAr(const NodeValuePerCell<const Rdd>& Ajr)
{
- const auto& node_to_cell_matrix = m_connectivity.nodeToCellMatrix();
- const auto& node_local_numbers_in_their_cells =
- m_connectivity.nodeLocalNumbersInTheirCells();
-
- parallel_for(m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) {
- Rdd sum = zero;
- const auto& node_to_cell = node_to_cell_matrix[r];
- const auto& node_local_number_in_its_cells =
- node_local_numbers_in_their_cells.itemValues(r);
-
- for (size_t j = 0; j < node_to_cell.size(); ++j) {
- const CellId J = node_to_cell[j];
- const unsigned int R = node_local_number_in_its_cells[j];
- sum += Ajr(J, R);
- }
- m_Ar[r] = sum;
- });
+ const auto& node_to_cell_matrix = m_connectivity.nodeToCellMatrix();
+ const auto& node_local_numbers_in_their_cells = m_connectivity.nodeLocalNumbersInTheirCells();
+
+ parallel_for(
+ m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) {
+ Rdd sum = zero;
+ const auto& node_to_cell = node_to_cell_matrix[r];
+ const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemValues(r);
+
+ for (size_t j = 0; j < node_to_cell.size(); ++j) {
+ const CellId J = node_to_cell[j];
+ const unsigned int R = node_local_number_in_its_cells[j];
+ sum += Ajr(J, R);
+ }
+ m_Ar[r] = sum;
+ });
return m_Ar;
}
@@ -95,22 +93,21 @@ class AcousticSolver
const CellValue<const Rd>& uj,
const CellValue<const double>& pj)
{
- const auto& node_to_cell_matrix = m_connectivity.nodeToCellMatrix();
- const auto& node_local_numbers_in_their_cells =
- m_connectivity.nodeLocalNumbersInTheirCells();
-
- parallel_for(m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) {
- Rd& br = m_br[r];
- br = zero;
- const auto& node_to_cell = node_to_cell_matrix[r];
- const auto& node_local_number_in_its_cells =
- node_local_numbers_in_their_cells.itemValues(r);
- for (size_t j = 0; j < node_to_cell.size(); ++j) {
- const CellId J = node_to_cell[j];
- const unsigned int R = node_local_number_in_its_cells[j];
- br += Ajr(J, R) * uj[J] + pj[J] * Cjr(J, R);
- }
- });
+ const auto& node_to_cell_matrix = m_connectivity.nodeToCellMatrix();
+ const auto& node_local_numbers_in_their_cells = m_connectivity.nodeLocalNumbersInTheirCells();
+
+ parallel_for(
+ m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) {
+ Rd& br = m_br[r];
+ br = zero;
+ const auto& node_to_cell = node_to_cell_matrix[r];
+ const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemValues(r);
+ for (size_t j = 0; j < node_to_cell.size(); ++j) {
+ const CellId J = node_to_cell[j];
+ const unsigned int R = node_local_number_in_its_cells[j];
+ br += Ajr(J, R) * uj[J] + pj[J] * Cjr(J, R);
+ }
+ });
return m_br;
}
@@ -120,44 +117,43 @@ class AcousticSolver
{
for (const auto& handler : m_boundary_condition_list) {
switch (handler.boundaryCondition().type()) {
- case BoundaryCondition::normal_velocity: {
- perr() << __FILE__ << ':' << __LINE__ << ": normal_velocity BC NIY\n";
- std::exit(0);
- break;
- }
- case BoundaryCondition::velocity: {
- perr() << __FILE__ << ':' << __LINE__ << ": velocity BC NIY\n";
- std::exit(0);
- break;
- }
- case BoundaryCondition::pressure: {
- // const PressureBoundaryCondition& pressure_bc
- // = dynamic_cast<const
- // PressureBoundaryCondition&>(handler.boundaryCondition());
- perr() << __FILE__ << ':' << __LINE__ << ": pressure BC NIY\n";
- std::exit(0);
- break;
- }
- case BoundaryCondition::symmetry: {
- const SymmetryBoundaryCondition<Dimension>& symmetry_bc =
- dynamic_cast<const SymmetryBoundaryCondition<Dimension>&>(
- handler.boundaryCondition());
- const Rd& n = symmetry_bc.outgoingNormal();
-
- const Rdd I = identity;
- const Rdd nxn = tensorProduct(n, n);
- const Rdd P = I - nxn;
-
- const Array<const NodeId>& node_list = symmetry_bc.nodeList();
- parallel_for(symmetry_bc.numberOfNodes(),
- PUGS_LAMBDA(const int& r_number) {
- const NodeId r = node_list[r_number];
-
- m_Ar[r] = P * m_Ar[r] * P + nxn;
- m_br[r] = P * m_br[r];
- });
- break;
- }
+ case BoundaryCondition::normal_velocity: {
+ perr() << __FILE__ << ':' << __LINE__ << ": normal_velocity BC NIY\n";
+ std::exit(0);
+ break;
+ }
+ case BoundaryCondition::velocity: {
+ perr() << __FILE__ << ':' << __LINE__ << ": velocity BC NIY\n";
+ std::exit(0);
+ break;
+ }
+ case BoundaryCondition::pressure: {
+ // const PressureBoundaryCondition& pressure_bc
+ // = dynamic_cast<const
+ // PressureBoundaryCondition&>(handler.boundaryCondition());
+ perr() << __FILE__ << ':' << __LINE__ << ": pressure BC NIY\n";
+ std::exit(0);
+ break;
+ }
+ case BoundaryCondition::symmetry: {
+ const SymmetryBoundaryCondition<Dimension>& symmetry_bc =
+ dynamic_cast<const SymmetryBoundaryCondition<Dimension>&>(handler.boundaryCondition());
+ const Rd& n = symmetry_bc.outgoingNormal();
+
+ const Rdd I = identity;
+ const Rdd nxn = tensorProduct(n, n);
+ const Rdd P = I - nxn;
+
+ const Array<const NodeId>& node_list = symmetry_bc.nodeList();
+ parallel_for(
+ symmetry_bc.numberOfNodes(), PUGS_LAMBDA(const int& r_number) {
+ const NodeId r = node_list[r_number];
+
+ m_Ar[r] = P * m_Ar[r] * P + nxn;
+ m_br[r] = P * m_br[r];
+ });
+ break;
+ }
}
}
}
@@ -167,8 +163,8 @@ class AcousticSolver
{
inverse(Ar, m_inv_Ar);
const NodeValue<const Rdd> invAr = m_inv_Ar;
- parallel_for(m_mesh.numberOfNodes(),
- PUGS_LAMBDA(const NodeId& r) { m_ur[r] = invAr[r] * br[r]; });
+ parallel_for(
+ m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) { m_ur[r] = invAr[r] * br[r]; });
return m_ur;
}
@@ -182,21 +178,21 @@ class AcousticSolver
{
const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- const auto& cell_nodes = cell_to_node_matrix[j];
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ const auto& cell_nodes = cell_to_node_matrix[j];
- for (size_t r = 0; r < cell_nodes.size(); ++r) {
- m_Fjr(j, r) =
- Ajr(j, r) * (uj[j] - ur[cell_nodes[r]]) + pj[j] * Cjr(j, r);
- }
- });
+ for (size_t r = 0; r < cell_nodes.size(); ++r) {
+ m_Fjr(j, r) = Ajr(j, r) * (uj[j] - ur[cell_nodes[r]]) + pj[j] * Cjr(j, r);
+ }
+ });
}
void
inverse(const NodeValue<const Rdd>& A, NodeValue<Rdd>& inv_A) const
{
- parallel_for(m_mesh.numberOfNodes(),
- PUGS_LAMBDA(const NodeId& r) { inv_A[r] = ::inverse(A[r]); });
+ parallel_for(
+ m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) { inv_A[r] = ::inverse(A[r]); });
}
PUGS_INLINE
@@ -236,8 +232,7 @@ class AcousticSolver
CellValue<double> m_Vj_over_cj;
public:
- AcousticSolver(MeshData& mesh_data,
- const std::vector<BoundaryConditionHandler>& bc_list)
+ AcousticSolver(MeshData& mesh_data, const std::vector<BoundaryConditionHandler>& bc_list)
: m_mesh_data(mesh_data),
m_mesh(mesh_data.mesh()),
m_connectivity(m_mesh.connectivity()),
@@ -256,21 +251,21 @@ class AcousticSolver
PUGS_INLINE
double
- acoustic_dt(const CellValue<const double>& Vj,
- const CellValue<const double>& cj) const
+ acoustic_dt(const CellValue<const double>& Vj, const CellValue<const double>& cj) const
{
const NodeValuePerCell<const double>& ljr = m_mesh_data.ljr();
- const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
+ const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- const auto& cell_nodes = cell_to_node_matrix[j];
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ const auto& cell_nodes = cell_to_node_matrix[j];
- double S = 0;
- for (size_t r = 0; r < cell_nodes.size(); ++r) {
- S += ljr(j, r);
- }
- m_Vj_over_cj[j] = 2 * Vj[j] / (S * cj[j]);
- });
+ double S = 0;
+ for (size_t r = 0; r < cell_nodes.size(); ++r) {
+ S += ljr(j, r);
+ }
+ m_Vj_over_cj[j] = 2 * Vj[j] / (S * cj[j]);
+ });
return min(m_Vj_over_cj);
}
@@ -298,32 +293,32 @@ class AcousticSolver
const auto& cell_to_node_matrix = m_mesh.connectivity().cellToNodeMatrix();
const CellValue<const double> inv_mj = unknowns.invMj();
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- const auto& cell_nodes = cell_to_node_matrix[j];
-
- Rd momentum_fluxes = zero;
- double energy_fluxes = 0;
- for (size_t R = 0; R < cell_nodes.size(); ++R) {
- const NodeId r = cell_nodes[R];
- momentum_fluxes += Fjr(j, R);
- energy_fluxes += (Fjr(j, R), ur[r]);
- }
- uj[j] -= (dt * inv_mj[j]) * momentum_fluxes;
- Ej[j] -= (dt * inv_mj[j]) * energy_fluxes;
- });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ const auto& cell_nodes = cell_to_node_matrix[j];
+
+ Rd momentum_fluxes = zero;
+ double energy_fluxes = 0;
+ for (size_t R = 0; R < cell_nodes.size(); ++R) {
+ const NodeId r = cell_nodes[R];
+ momentum_fluxes += Fjr(j, R);
+ energy_fluxes += (Fjr(j, R), ur[r]);
+ }
+ uj[j] -= (dt * inv_mj[j]) * momentum_fluxes;
+ Ej[j] -= (dt * inv_mj[j]) * energy_fluxes;
+ });
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- ej[j] = Ej[j] - 0.5 * (uj[j], uj[j]);
- });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { ej[j] = Ej[j] - 0.5 * (uj[j], uj[j]); });
NodeValue<Rd> mutable_xr = m_mesh.mutableXr();
- parallel_for(m_mesh.numberOfNodes(),
- PUGS_LAMBDA(const NodeId& r) { mutable_xr[r] += dt * ur[r]; });
+ parallel_for(
+ m_mesh.numberOfNodes(), PUGS_LAMBDA(const NodeId& r) { mutable_xr[r] += dt * ur[r]; });
m_mesh_data.updateAllData();
const CellValue<const double> mj = unknowns.mj();
- parallel_for(m_mesh.numberOfCells(),
- PUGS_LAMBDA(const CellId& j) { rhoj[j] = mj[j] / Vj[j]; });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { rhoj[j] = mj[j] / Vj[j]; });
}
};
diff --git a/src/scheme/BlockPerfectGas.hpp b/src/scheme/BlockPerfectGas.hpp
index 1ae68273247ac8bd9f3fe310a163fed209f15b5a..69f1c24e8064c5201e371f271503f39eebea26d2 100644
--- a/src/scheme/BlockPerfectGas.hpp
+++ b/src/scheme/BlockPerfectGas.hpp
@@ -31,11 +31,12 @@ struct BlockPerfectGas
const CellValue<const double>& e = m_ej;
const CellValue<const double>& gamma = m_gammaj;
- parallel_for(nj, PUGS_LAMBDA(const CellId& j) {
- const double gamma_minus_one = gamma[j] - 1;
- m_pj[j] = gamma_minus_one * rho[j] * e[j];
- m_cj[j] = std::sqrt(gamma[j] * gamma_minus_one * e[j]);
- });
+ parallel_for(
+ nj, PUGS_LAMBDA(const CellId& j) {
+ const double gamma_minus_one = gamma[j] - 1;
+ m_pj[j] = gamma_minus_one * rho[j] * e[j];
+ m_cj[j] = std::sqrt(gamma[j] * gamma_minus_one * e[j]);
+ });
}
void
@@ -46,14 +47,12 @@ struct BlockPerfectGas
const CellValue<const double>& p = m_pj;
const CellValue<const double>& gamma = m_gammaj;
- parallel_for(nj, PUGS_LAMBDA(const CellId& j) {
- m_ej[j] = p[j] / (rho[j] * (gamma[j] - 1));
- });
+ parallel_for(
+ nj, PUGS_LAMBDA(const CellId& j) { m_ej[j] = p[j] / (rho[j] * (gamma[j] - 1)); });
const CellValue<const double>& e = m_ej;
- parallel_for(nj, PUGS_LAMBDA(const CellId& j) {
- m_cj[j] = std::sqrt(gamma[j] * (gamma[j] - 1) * e[j]);
- });
+ parallel_for(
+ nj, PUGS_LAMBDA(const CellId& j) { m_cj[j] = std::sqrt(gamma[j] * (gamma[j] - 1) * e[j]); });
}
};
diff --git a/src/scheme/BoundaryCondition.hpp b/src/scheme/BoundaryCondition.hpp
index ae09c0271a12859581c461263c261d107e69546e..23aaaa8995d4cda0e118200932f45d44f20065c6 100644
--- a/src/scheme/BoundaryCondition.hpp
+++ b/src/scheme/BoundaryCondition.hpp
@@ -65,15 +65,12 @@ class PressureBoundaryCondition : public BoundaryCondition
return m_face_list;
}
- PressureBoundaryCondition(const double& value,
- const std::vector<unsigned int>& faces)
- : BoundaryCondition(BoundaryCondition::pressure),
- m_value(value),
- m_number_of_faces(faces.size())
+ PressureBoundaryCondition(const double& value, const std::vector<unsigned int>& faces)
+ : BoundaryCondition(BoundaryCondition::pressure), m_value(value), m_number_of_faces(faces.size())
{
Array<unsigned int> face_list(faces.size());
- parallel_for(m_number_of_faces,
- PUGS_LAMBDA(const int& f) { face_list[f] = faces[f]; });
+ parallel_for(
+ m_number_of_faces, PUGS_LAMBDA(const int& f) { face_list[f] = faces[f]; });
m_face_list = face_list;
}
@@ -108,10 +105,8 @@ class SymmetryBoundaryCondition : public BoundaryCondition
return m_mesh_flat_node_boundary.nodeList();
}
- SymmetryBoundaryCondition(
- const MeshFlatNodeBoundary<dimension>& mesh_flat_node_boundary)
- : BoundaryCondition(BoundaryCondition::symmetry),
- m_mesh_flat_node_boundary(mesh_flat_node_boundary)
+ SymmetryBoundaryCondition(const MeshFlatNodeBoundary<dimension>& mesh_flat_node_boundary)
+ : BoundaryCondition(BoundaryCondition::symmetry), m_mesh_flat_node_boundary(mesh_flat_node_boundary)
{
;
}
@@ -141,8 +136,7 @@ class BoundaryConditionHandler
BoundaryConditionHandler(BoundaryConditionHandler&&) = default;
PUGS_INLINE
- BoundaryConditionHandler(
- std::shared_ptr<BoundaryCondition> boundary_condition)
+ BoundaryConditionHandler(std::shared_ptr<BoundaryCondition> boundary_condition)
: m_boundary_condition(boundary_condition)
{}
diff --git a/src/scheme/BoundaryConditionDescriptor.hpp b/src/scheme/BoundaryConditionDescriptor.hpp
index 97b57dbdfce4cade2e17e2dcd435fc801f62d1eb..78a2ba947095672f452f4ed72d0498fcc6757321 100644
--- a/src/scheme/BoundaryConditionDescriptor.hpp
+++ b/src/scheme/BoundaryConditionDescriptor.hpp
@@ -129,8 +129,7 @@ class BoundaryConditionDescriptor
return *m_boundary_descriptor;
}
- BoundaryConditionDescriptor(
- std::shared_ptr<BoundaryDescriptor> boundary_descriptor)
+ BoundaryConditionDescriptor(std::shared_ptr<BoundaryDescriptor> boundary_descriptor)
: m_boundary_descriptor(boundary_descriptor)
{
;
@@ -156,16 +155,14 @@ class SymmetryBoundaryConditionDescriptor : public BoundaryConditionDescriptor
return Type::symmetry;
}
- SymmetryBoundaryConditionDescriptor(
- std::shared_ptr<BoundaryDescriptor> boundary_descriptor)
+ SymmetryBoundaryConditionDescriptor(std::shared_ptr<BoundaryDescriptor> boundary_descriptor)
: BoundaryConditionDescriptor(boundary_descriptor)
{
;
}
- SymmetryBoundaryConditionDescriptor(
- const SymmetryBoundaryConditionDescriptor&) = default;
- ~SymmetryBoundaryConditionDescriptor() = default;
+ SymmetryBoundaryConditionDescriptor(const SymmetryBoundaryConditionDescriptor&) = default;
+ ~SymmetryBoundaryConditionDescriptor() = default;
};
#endif // BOUNDARY_CONDITION_DESCRIPTOR_HPP
diff --git a/src/scheme/FiniteVolumesEulerUnknowns.hpp b/src/scheme/FiniteVolumesEulerUnknowns.hpp
index 52d4ca15a8aed2e623f25e9175a77b2abd015290..d433e74af51fba3998cba8c2d65b7f0ae37eca35 100644
--- a/src/scheme/FiniteVolumesEulerUnknowns.hpp
+++ b/src/scheme/FiniteVolumesEulerUnknowns.hpp
@@ -143,41 +143,42 @@ class FiniteVolumesEulerUnknowns
{
const CellValue<const Rd>& xj = m_mesh_data.xj();
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- if (xj[j][0] < 0.5) {
- m_rhoj[j] = 1;
- } else {
- m_rhoj[j] = 0.125;
- }
- });
-
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- if (xj[j][0] < 0.5) {
- m_pj[j] = 1;
- } else {
- m_pj[j] = 0.1;
- }
- });
-
- parallel_for(m_mesh.numberOfCells(),
- PUGS_LAMBDA(const CellId& j) { m_uj[j] = zero; });
-
- parallel_for(m_mesh.numberOfCells(),
- PUGS_LAMBDA(const CellId& j) { m_gammaj[j] = 1.4; });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ if (xj[j][0] < 0.5) {
+ m_rhoj[j] = 1;
+ } else {
+ m_rhoj[j] = 0.125;
+ }
+ });
+
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
+ if (xj[j][0] < 0.5) {
+ m_pj[j] = 1;
+ } else {
+ m_pj[j] = 0.1;
+ }
+ });
+
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_uj[j] = zero; });
+
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_gammaj[j] = 1.4; });
BlockPerfectGas block_eos(m_rhoj, m_ej, m_pj, m_gammaj, m_cj);
block_eos.updateEandCFromRhoP();
- parallel_for(m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) {
- m_Ej[j] = m_ej[j] + 0.5 * (m_uj[j], m_uj[j]);
- });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_Ej[j] = m_ej[j] + 0.5 * (m_uj[j], m_uj[j]); });
const CellValue<const double>& Vj = m_mesh_data.Vj();
- parallel_for(m_mesh.numberOfCells(),
- PUGS_LAMBDA(const CellId& j) { m_mj[j] = m_rhoj[j] * Vj[j]; });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_mj[j] = m_rhoj[j] * Vj[j]; });
- parallel_for(m_mesh.numberOfCells(),
- PUGS_LAMBDA(const CellId& j) { m_inv_mj[j] = 1. / m_mj[j]; });
+ parallel_for(
+ m_mesh.numberOfCells(), PUGS_LAMBDA(const CellId& j) { m_inv_mj[j] = 1. / m_mj[j]; });
}
FiniteVolumesEulerUnknowns(const MeshDataType& mesh_data)
diff --git a/src/utils/Array.hpp b/src/utils/Array.hpp
index 84ea65aa1edc5b1ee67ea798691dc403603aec04..eaf368b3e7207e6ce849ff111a0dfff6ab113c6d 100644
--- a/src/utils/Array.hpp
+++ b/src/utils/Array.hpp
@@ -40,8 +40,7 @@ class Array
}
template <typename DataType2, typename... RT>
- friend PUGS_INLINE Array<DataType2> encapsulate(
- const Kokkos::View<DataType2*, RT...>& values);
+ friend PUGS_INLINE Array<DataType2> encapsulate(const Kokkos::View<DataType2*, RT...>& values);
PUGS_INLINE
DataType& operator[](const index_type& i) const noexcept(NO_ASSERT)
@@ -54,12 +53,11 @@ class Array
void
fill(const DataType& data) const
{
- static_assert(not std::is_const<DataType>(),
- "Cannot modify Array of const");
+ static_assert(not std::is_const<DataType>(), "Cannot modify Array of const");
// could consider to use std::fill
- parallel_for(this->size(),
- PUGS_LAMBDA(const index_type& i) { m_values[i] = data; });
+ parallel_for(
+ this->size(), PUGS_LAMBDA(const index_type& i) { m_values[i] = data; });
}
template <typename DataType2>
@@ -67,12 +65,10 @@ class Array
operator=(const Array<DataType2>& array) noexcept
{
// ensures that DataType is the same as source DataType2
- static_assert(std::is_same<std::remove_const_t<DataType>,
- std::remove_const_t<DataType2>>(),
+ static_assert(std::is_same<std::remove_const_t<DataType>, std::remove_const_t<DataType2>>(),
"Cannot assign Array of different type");
// ensures that const is not lost through copy
- static_assert(((std::is_const<DataType2>() and std::is_const<DataType>()) or
- not std::is_const<DataType2>()),
+ static_assert(((std::is_const<DataType2>() and std::is_const<DataType>()) or not std::is_const<DataType2>()),
"Cannot assign Array of const to Array of non-const");
m_values = array.m_values;
return *this;
@@ -87,9 +83,8 @@ class Array
PUGS_INLINE
Array(const size_t& size) : m_values("anonymous", size)
{
- static_assert(
- not std::is_const<DataType>(),
- "Cannot allocate Array of const data: only view is supported");
+ static_assert(not std::is_const<DataType>(), "Cannot allocate Array of const data: only view is "
+ "supported");
}
PUGS_INLINE
diff --git a/src/utils/ArrayUtils.hpp b/src/utils/ArrayUtils.hpp
index f07b07d525a8b1c2dd0461893411883aa29082b9..54f5497bc7b96b8f8b9f23644d9280e9c7fb7eb9 100644
--- a/src/utils/ArrayUtils.hpp
+++ b/src/utils/ArrayUtils.hpp
@@ -192,21 +192,18 @@ template <template <typename... SourceT> typename SourceArray,
typename... SourceT,
typename... ImageT>
void
-value_copy(const SourceArray<SourceT...>& source_array,
- ImageArray<ImageT...>& image_array)
+value_copy(const SourceArray<SourceT...>& source_array, ImageArray<ImageT...>& image_array)
{
using SourceDataType = typename SourceArray<SourceT...>::data_type;
using ImageDataType = typename ImageArray<ImageT...>::data_type;
- static_assert(
- std::is_same_v<std::remove_const_t<SourceDataType>, ImageDataType>);
+ static_assert(std::is_same_v<std::remove_const_t<SourceDataType>, ImageDataType>);
static_assert(not std::is_const_v<ImageDataType>);
Assert(source_array.size() == image_array.size());
- parallel_for(source_array.size(), PUGS_LAMBDA(const size_t& i) {
- image_array[i] = source_array[i];
- });
+ parallel_for(
+ source_array.size(), PUGS_LAMBDA(const size_t& i) { image_array[i] = source_array[i]; });
}
#endif // ARRAY_UTILS_HPP
diff --git a/src/utils/BacktraceManager.cpp b/src/utils/BacktraceManager.cpp
index 4de2a3f7c82e66bdc7884f8458f1c5a9678003f3..80d9473444436e6c20ef9e47fbc81b733806047e 100644
--- a/src/utils/BacktraceManager.cpp
+++ b/src/utils/BacktraceManager.cpp
@@ -33,20 +33,17 @@ operator<<(std::ostream& os, const BacktraceManager& btm)
for (size_t i_line = 0; i_line < lines.size(); ++i_line) {
const auto& line = lines[i_line];
- os << rang::fg::green << "[" << std::setw(width) << i_line + 1 << '/'
- << lines.size() << "] " << rang::fg::reset;
+ os << rang::fg::green << "[" << std::setw(width) << i_line + 1 << '/' << lines.size() << "] " << rang::fg::reset;
std::smatch matchex;
int status = -1;
if (std::regex_search(line, matchex, mangled_function)) {
- std::string prefix = matchex.prefix().str();
- std::string function =
- line.substr(matchex.position() + 1, matchex.length() - 2);
- std::string suffix = matchex.suffix().str();
+ std::string prefix = matchex.prefix().str();
+ std::string function = line.substr(matchex.position() + 1, matchex.length() - 2);
+ std::string suffix = matchex.suffix().str();
os << prefix << '(';
if (function.size() > 0) {
- char* demangled =
- abi::__cxa_demangle(function.c_str(), NULL, NULL, &status);
+ char* demangled = abi::__cxa_demangle(function.c_str(), NULL, NULL, &status);
if (status == 0) {
os << rang::style::bold << demangled << rang::style::reset;
free(demangled);
diff --git a/src/utils/BacktraceManager.hpp b/src/utils/BacktraceManager.hpp
index 9b4162ac519cad75ae1b967152ff557d5ed89011..0ff2d2d42575ee42498a33fa2fd1c235a3e20b22 100644
--- a/src/utils/BacktraceManager.hpp
+++ b/src/utils/BacktraceManager.hpp
@@ -12,8 +12,7 @@ class BacktraceManager
public:
BacktraceManager();
- friend std::ostream& operator<<(std::ostream& os,
- const BacktraceManager& btm);
+ friend std::ostream& operator<<(std::ostream& os, const BacktraceManager& btm);
BacktraceManager(const BacktraceManager&) = default;
~BacktraceManager() = default;
diff --git a/src/utils/BuildInfo.cpp b/src/utils/BuildInfo.cpp
index 636ef9efb297d9ef4b992498c11582962649a37a..2f46fb37174f83e7cf88d2f7fd299cfc91d3919c 100644
--- a/src/utils/BuildInfo.cpp
+++ b/src/utils/BuildInfo.cpp
@@ -18,8 +18,7 @@ std::string
BuildInfo::compiler()
{
std::stringstream compiler_info;
- compiler_info << PUGS_BUILD_COMPILER << " (" << PUGS_BUILD_COMPILER_VERSION
- << ")" << std::ends;
+ compiler_info << PUGS_BUILD_COMPILER << " (" << PUGS_BUILD_COMPILER_VERSION << ")" << std::ends;
return compiler_info.str();
}
diff --git a/src/utils/CSRGraph.hpp b/src/utils/CSRGraph.hpp
index 2ef9aafc02d403c6a1310ee2171b8329570197d9..52a7989a9922bbccfc4c7e8633934d47581f4d39 100644
--- a/src/utils/CSRGraph.hpp
+++ b/src/utils/CSRGraph.hpp
@@ -32,8 +32,7 @@ class CSRGraph
CSRGraph& operator=(CSRGraph&&) = default;
CSRGraph& operator=(const CSRGraph&) = default;
- CSRGraph(Array<int> entries, Array<int> neighbors)
- : m_entries(entries), m_neighbors(neighbors)
+ CSRGraph(Array<int> entries, Array<int> neighbors) : m_entries(entries), m_neighbors(neighbors)
{
Assert(m_entries.size() > 0);
}
diff --git a/src/utils/CastArray.hpp b/src/utils/CastArray.hpp
index 8720117858a4db4fb8f085b20bca5930dce4d745..e9f0cdd07d35255a7c4df9583732f0d84c1e231f 100644
--- a/src/utils/CastArray.hpp
+++ b/src/utils/CastArray.hpp
@@ -46,14 +46,10 @@ class CastArray
CastArray(const Array<DataType>& array)
: m_array(array),
m_size(sizeof(DataType) * array.size() / sizeof(CastDataType)),
- m_values((array.size() == 0)
- ? nullptr
- : reinterpret_cast<CastDataType*>(&(array[0])))
+ m_values((array.size() == 0) ? nullptr : reinterpret_cast<CastDataType*>(&(array[0])))
{
- static_assert(
- (std::is_const_v<CastDataType> and std::is_const_v<DataType>) or
- (not std::is_const_v<DataType>),
- "CastArray cannot remove const attribute");
+ static_assert((std::is_const_v<CastDataType> and std::is_const_v<DataType>) or (not std::is_const_v<DataType>),
+ "CastArray cannot remove const attribute");
if (sizeof(DataType) * array.size() % sizeof(CastDataType)) {
std::cerr << "cannot cast array to the chosen data type\n";
@@ -63,16 +59,12 @@ class CastArray
PUGS_INLINE
CastArray(DataType& value)
- : m_size(sizeof(DataType) / sizeof(CastDataType)),
- m_values(reinterpret_cast<CastDataType*>(&(value)))
+ : m_size(sizeof(DataType) / sizeof(CastDataType)), m_values(reinterpret_cast<CastDataType*>(&(value)))
{
- static_assert(
- (std::is_const_v<CastDataType> and std::is_const_v<DataType>) or
- (not std::is_const_v<DataType>),
- "CastArray cannot remove const attribute");
- static_assert(
- is_trivially_castable<DataType>,
- "Defining CastArray from non trivially castable type is not allowed");
+ static_assert((std::is_const_v<CastDataType> and std::is_const_v<DataType>) or (not std::is_const_v<DataType>),
+ "CastArray cannot remove const attribute");
+ static_assert(is_trivially_castable<DataType>, "Defining CastArray from non trivially castable type is not "
+ "allowed");
}
PUGS_INLINE
diff --git a/src/utils/ConsoleManager.cpp b/src/utils/ConsoleManager.cpp
index 2f819f27b7ccdcf2d65f44e266e6e3378f81a377..64ba8473376a8975e5a7d23b4b50e22bfbf0ed5f 100644
--- a/src/utils/ConsoleManager.cpp
+++ b/src/utils/ConsoleManager.cpp
@@ -15,18 +15,15 @@ ConsoleManager::init(const std::string& colorize)
pout() << "Console management: color ";
if (colorize == "auto") {
if (isTerminal(pout())) {
- pout() << rang::style::bold << rang::fgB::green << "enabled"
- << rang::fg::reset << rang::style::reset;
+ pout() << rang::style::bold << rang::fgB::green << "enabled" << rang::fg::reset << rang::style::reset;
} else {
pout() << "disabled";
}
pout() << " [auto]\n";
} else if (colorize == "yes") {
rang::setControlMode(rang::control::Force);
- pout() << rang::style::bold << rang::fgB::green << "enabled"
- << rang::fg::reset << rang::style::reset;
- pout() << " [" << rang::style::bold << rang::fgB::red << "forced"
- << rang::fg::reset << rang::style::reset << "]\n";
+ pout() << rang::style::bold << rang::fgB::green << "enabled" << rang::fg::reset << rang::style::reset;
+ pout() << " [" << rang::style::bold << rang::fgB::red << "forced" << rang::fg::reset << rang::style::reset << "]\n";
} else if (colorize == "no") {
rang::setControlMode(rang::control::Off);
pout() << "disabled [forced]\n";
diff --git a/src/utils/FPEManager.cpp b/src/utils/FPEManager.cpp
index 543357f22293b316dd1a246f30f84943608fa807..2c61e89209bc462c243cfd379a6a88b7bfa4fbfa 100644
--- a/src/utils/FPEManager.cpp
+++ b/src/utils/FPEManager.cpp
@@ -62,16 +62,16 @@ fedisableexcept(unsigned int excepts)
void
FPEManager::enable()
{
- pout() << "FE management: " << rang::style::bold << rang::fgB::green
- << "enabled" << rang::fg::reset << rang::style::reset << '\n';
+ pout() << "FE management: " << rang::style::bold << rang::fgB::green << "enabled" << rang::fg::reset
+ << rang::style::reset << '\n';
::feenableexcept(MANAGED_FPE);
}
void
FPEManager::disable()
{
- pout() << "FE management: " << rang::style::bold << rang::fgB::red
- << "disabled" << rang::fg::reset << rang::style::reset << '\n';
+ pout() << "FE management: " << rang::style::bold << rang::fgB::red << "disabled" << rang::fg::reset
+ << rang::style::reset << '\n';
::fedisableexcept(MANAGED_FPE);
}
@@ -80,15 +80,13 @@ FPEManager::disable()
void
FPEManager::enable()
{
- pout() << "FE management: enabled " << rang::fg::red << "[not supported]"
- << rang::fg::reset << '\n';
+ pout() << "FE management: enabled " << rang::fg::red << "[not supported]" << rang::fg::reset << '\n';
}
void
FPEManager::disable()
{
- pout() << "FE management: disable " << rang::fg::red << "[not supported]"
- << rang::fg::reset << '\n';
+ pout() << "FE management: disable " << rang::fg::red << "[not supported]" << rang::fg::reset << '\n';
}
#endif // PUGS_HAS_FENV_H
diff --git a/src/utils/Messenger.cpp b/src/utils/Messenger.cpp
index 1e0984a8eac88603d7002fec8b9558f04afbd1cd..f1d18053557fc8dbd9d4f1dea27ba74d61147129 100644
--- a/src/utils/Messenger.cpp
+++ b/src/utils/Messenger.cpp
@@ -1,8 +1,8 @@
#include <Messenger.hpp>
#include <PugsOStream.hpp>
-namespace parallel {
-
+namespace parallel
+{
Messenger* Messenger::m_instance = nullptr;
void
diff --git a/src/utils/Messenger.hpp b/src/utils/Messenger.hpp
index ecdab71d1d73c2d653c607b5ab3ca141cb12b6ba..d697d61cd8839aafe4fb85345d3b19bc33feef8b 100644
--- a/src/utils/Messenger.hpp
+++ b/src/utils/Messenger.hpp
@@ -19,8 +19,8 @@
#include <PugsTraits.hpp>
-namespace parallel {
-
+namespace parallel
+{
class Messenger
{
private:
@@ -34,10 +34,8 @@ class Messenger
if constexpr (std::is_const_v<DataType>) {
return mpiType<std::remove_const_t<DataType>>();
} else {
- static_assert(std::is_arithmetic_v<DataType>,
- "Unexpected arithmetic type! Should not occur!");
- static_assert(is_false_v<DataType>,
- "MPI_Datatype are only defined for arithmetic types!");
+ static_assert(std::is_arithmetic_v<DataType>, "Unexpected arithmetic type! Should not occur!");
+ static_assert(is_false_v<DataType>, "MPI_Datatype are only defined for arithmetic types!");
return MPI_Datatype();
}
}
@@ -46,7 +44,8 @@ class Messenger
private:
template <typename T, typename Allowed = void>
struct split_cast
- {};
+ {
+ };
template <typename T>
struct split_cast<T, std::enable_if_t<not(sizeof(T) % sizeof(int64_t))>>
@@ -56,9 +55,7 @@ class Messenger
};
template <typename T>
- struct split_cast<T,
- std::enable_if_t<not(sizeof(T) % sizeof(int32_t)) and
- (sizeof(T) % sizeof(int64_t))>>
+ struct split_cast<T, std::enable_if_t<not(sizeof(T) % sizeof(int32_t)) and (sizeof(T) % sizeof(int64_t))>>
{
using type = int32_t;
static_assert(not(sizeof(T) % sizeof(int32_t)));
@@ -66,8 +63,7 @@ class Messenger
template <typename T>
struct split_cast<T,
- std::enable_if_t<not(sizeof(T) % sizeof(int16_t)) and
- (sizeof(T) % sizeof(int32_t)) and
+ std::enable_if_t<not(sizeof(T) % sizeof(int16_t)) and (sizeof(T) % sizeof(int32_t)) and
(sizeof(T) % sizeof(int64_t))>>
{
using type = int16_t;
@@ -75,11 +71,9 @@ class Messenger
};
template <typename T>
- struct split_cast<
- T,
- std::enable_if_t<
- not(sizeof(T) % sizeof(int8_t)) and (sizeof(T) % sizeof(int16_t)) and
- (sizeof(T) % sizeof(int32_t)) and (sizeof(T) % sizeof(int64_t))>>
+ struct split_cast<T,
+ std::enable_if_t<not(sizeof(T) % sizeof(int8_t)) and (sizeof(T) % sizeof(int16_t)) and
+ (sizeof(T) % sizeof(int32_t)) and (sizeof(T) % sizeof(int64_t))>>
{
using type = int8_t;
static_assert(not(sizeof(T) % sizeof(int8_t)));
@@ -106,8 +100,7 @@ class Messenger
#ifdef PUGS_HAS_MPI
MPI_Datatype mpi_datatype = Messenger::helper::mpiType<DataType>();
- MPI_Allgather(&data, 1, mpi_datatype, &(gather[0]), 1, mpi_datatype,
- MPI_COMM_WORLD);
+ MPI_Allgather(&data, 1, mpi_datatype, &(gather[0]), 1, mpi_datatype, MPI_COMM_WORLD);
#else // PUGS_HAS_MPI
gather[0] = data;
#endif // PUGS_HAS_MPI
@@ -119,25 +112,21 @@ class Messenger
typename... SendT,
typename... RecvT>
void
- _allGather(const SendArrayType<SendT...>& data_array,
- RecvArrayType<RecvT...> gather_array) const
+ _allGather(const SendArrayType<SendT...>& data_array, RecvArrayType<RecvT...> gather_array) const
{
- Assert(gather_array.size() ==
- data_array.size() * m_size); // LCOV_EXCL_LINE
+ Assert(gather_array.size() == data_array.size() * m_size); // LCOV_EXCL_LINE
using SendDataType = typename SendArrayType<SendT...>::data_type;
using RecvDataType = typename RecvArrayType<RecvT...>::data_type;
- static_assert(
- std::is_same_v<std::remove_const_t<SendDataType>, RecvDataType>);
+ static_assert(std::is_same_v<std::remove_const_t<SendDataType>, RecvDataType>);
static_assert(std::is_arithmetic_v<SendDataType>);
#ifdef PUGS_HAS_MPI
MPI_Datatype mpi_datatype = Messenger::helper::mpiType<RecvDataType>();
- MPI_Allgather(&(data_array[0]), data_array.size(), mpi_datatype,
- &(gather_array[0]), data_array.size(), mpi_datatype,
- MPI_COMM_WORLD);
+ MPI_Allgather(&(data_array[0]), data_array.size(), mpi_datatype, &(gather_array[0]), data_array.size(),
+ mpi_datatype, MPI_COMM_WORLD);
#else // PUGS_HAS_MPI
value_copy(data_array, gather_array);
#endif // PUGS_HAS_MPI
@@ -145,8 +134,7 @@ class Messenger
template <typename DataType>
void
- _broadcast_value([[maybe_unused]] DataType& data,
- [[maybe_unused]] const size_t& root_rank) const
+ _broadcast_value([[maybe_unused]] DataType& data, [[maybe_unused]] const size_t& root_rank) const
{
static_assert(not std::is_const_v<DataType>);
static_assert(std::is_arithmetic_v<DataType>);
@@ -160,8 +148,7 @@ class Messenger
template <typename ArrayType>
void
- _broadcast_array([[maybe_unused]] ArrayType& array,
- [[maybe_unused]] const size_t& root_rank) const
+ _broadcast_array([[maybe_unused]] ArrayType& array, [[maybe_unused]] const size_t& root_rank) const
{
using DataType = typename ArrayType::data_type;
static_assert(not std::is_const_v<DataType>);
@@ -169,8 +156,7 @@ class Messenger
#ifdef PUGS_HAS_MPI
MPI_Datatype mpi_datatype = Messenger::helper::mpiType<DataType>();
- MPI_Bcast(&(array[0]), array.size(), mpi_datatype, root_rank,
- MPI_COMM_WORLD);
+ MPI_Bcast(&(array[0]), array.size(), mpi_datatype, root_rank, MPI_COMM_WORLD);
#endif // PUGS_HAS_MPI
}
@@ -180,15 +166,13 @@ class Messenger
typename... SendT,
typename... RecvT>
RecvArrayType<RecvT...>
- _allToAll(const SendArrayType<SendT...>& sent_array,
- RecvArrayType<RecvT...>& recv_array) const
+ _allToAll(const SendArrayType<SendT...>& sent_array, RecvArrayType<RecvT...>& recv_array) const
{
#ifdef PUGS_HAS_MPI
using SendDataType = typename SendArrayType<SendT...>::data_type;
using RecvDataType = typename RecvArrayType<RecvT...>::data_type;
- static_assert(
- std::is_same_v<std::remove_const_t<SendDataType>, RecvDataType>);
+ static_assert(std::is_same_v<std::remove_const_t<SendDataType>, RecvDataType>);
static_assert(std::is_arithmetic_v<SendDataType>);
Assert((sent_array.size() % m_size) == 0); // LCOV_EXCL_LINE
@@ -198,8 +182,7 @@ class Messenger
MPI_Datatype mpi_datatype = Messenger::helper::mpiType<SendDataType>();
- MPI_Alltoall(&(sent_array[0]), count, mpi_datatype, &(recv_array[0]), count,
- mpi_datatype, MPI_COMM_WORLD);
+ MPI_Alltoall(&(sent_array[0]), count, mpi_datatype, &(recv_array[0]), count, mpi_datatype, MPI_COMM_WORLD);
#else // PUGS_HAS_MPI
value_copy(sent_array, recv_array);
#endif // PUGS_HAS_MPI
@@ -218,8 +201,7 @@ class Messenger
using SendDataType = typename SendArrayType<SendT...>::data_type;
using RecvDataType = typename RecvArrayType<RecvT...>::data_type;
- static_assert(
- std::is_same_v<std::remove_const_t<SendDataType>, RecvDataType>);
+ static_assert(std::is_same_v<std::remove_const_t<SendDataType>, RecvDataType>);
static_assert(std::is_arithmetic_v<SendDataType>);
#ifdef PUGS_HAS_MPI
@@ -231,8 +213,7 @@ class Messenger
const auto sent_array = sent_array_list[i_send];
if (sent_array.size() > 0) {
MPI_Request request;
- MPI_Isend(&(sent_array[0]), sent_array.size(), mpi_datatype, i_send, 0,
- MPI_COMM_WORLD, &request);
+ MPI_Isend(&(sent_array[0]), sent_array.size(), mpi_datatype, i_send, 0, MPI_COMM_WORLD, &request);
request_list.push_back(request);
}
}
@@ -241,16 +222,14 @@ class Messenger
auto recv_array = recv_array_list[i_recv];
if (recv_array.size() > 0) {
MPI_Request request;
- MPI_Irecv(&(recv_array[0]), recv_array.size(), mpi_datatype, i_recv, 0,
- MPI_COMM_WORLD, &request);
+ MPI_Irecv(&(recv_array[0]), recv_array.size(), mpi_datatype, i_recv, 0, MPI_COMM_WORLD, &request);
request_list.push_back(request);
}
}
if (request_list.size() > 0) {
std::vector<MPI_Status> status_list(request_list.size());
- if (MPI_SUCCESS != MPI_Waitall(request_list.size(), &(request_list[0]),
- &(status_list[0]))) {
+ if (MPI_SUCCESS != MPI_Waitall(request_list.size(), &(request_list[0]), &(status_list[0]))) {
// LCOV_EXCL_START
std::cerr << "Communication error!\n";
std::exit(1);
@@ -268,14 +247,12 @@ class Messenger
template <typename DataType, typename CastDataType>
void
- _exchange_through_cast(
- const std::vector<Array<DataType>>& sent_array_list,
- std::vector<Array<std::remove_const_t<DataType>>>& recv_array_list) const
+ _exchange_through_cast(const std::vector<Array<DataType>>& sent_array_list,
+ std::vector<Array<std::remove_const_t<DataType>>>& recv_array_list) const
{
std::vector<CastArray<DataType, const CastDataType>> sent_cast_array_list;
for (size_t i = 0; i < sent_array_list.size(); ++i) {
- sent_cast_array_list.emplace_back(
- cast_array_to<const CastDataType>::from(sent_array_list[i]));
+ sent_cast_array_list.emplace_back(cast_array_to<const CastDataType>::from(sent_array_list[i]));
}
using MutableDataType = std::remove_const_t<DataType>;
@@ -372,8 +349,7 @@ class Messenger
MPI_Datatype mpi_datatype = Messenger::helper::mpiType<InnerDataType>();
const int size = sizeof(DataType) / sizeof(InnerDataType);
DataType data_sum = data;
- MPI_Allreduce(&data, &data_sum, size, mpi_datatype, MPI_SUM,
- MPI_COMM_WORLD);
+ MPI_Allreduce(&data, &data_sum, size, mpi_datatype, MPI_SUM, MPI_COMM_WORLD);
return data_sum;
}
@@ -418,9 +394,8 @@ class Messenger
using CastType = helper::split_cast_t<DataType>;
using MutableCastType = helper::split_cast_t<MutableDataType>;
- CastArray cast_array = cast_array_to<CastType>::from(array);
- CastArray cast_gather_array =
- cast_array_to<MutableCastType>::from(gather_array);
+ CastArray cast_array = cast_array_to<CastType>::from(array);
+ CastArray cast_gather_array = cast_array_to<MutableCastType>::from(gather_array);
_allGather(cast_array, cast_gather_array);
} else {
@@ -482,8 +457,7 @@ class Messenger
PUGS_INLINE void
broadcast(Array<DataType>& array, const size_t& root_rank) const
{
- static_assert(not std::is_const_v<DataType>,
- "cannot broadcast array of const");
+ static_assert(not std::is_const_v<DataType>, "cannot broadcast array of const");
if constexpr (std::is_arithmetic_v<DataType>) {
size_t size = array.size();
_broadcast_value(size, root_rank);
@@ -511,11 +485,9 @@ class Messenger
exchange(const std::vector<Array<SendDataType>>& send_array_list,
std::vector<Array<RecvDataType>>& recv_array_list) const
{
- static_assert(
- std::is_same_v<std::remove_const_t<SendDataType>, RecvDataType>,
- "send and receive data type do not match");
- static_assert(not std::is_const_v<RecvDataType>,
- "receive data type cannot be const");
+ static_assert(std::is_same_v<std::remove_const_t<SendDataType>, RecvDataType>,
+ "send and receive data type do not match");
+ static_assert(not std::is_const_v<RecvDataType>, "receive data type cannot be const");
using DataType = std::remove_const_t<SendDataType>;
Assert(send_array_list.size() == m_size); // LCOV_EXCL_LINE
@@ -537,8 +509,7 @@ class Messenger
_exchange(send_array_list, recv_array_list);
} else if constexpr (is_trivially_castable<DataType>) {
using CastType = helper::split_cast_t<DataType>;
- _exchange_through_cast<SendDataType, CastType>(send_array_list,
- recv_array_list);
+ _exchange_through_cast<SendDataType, CastType>(send_array_list, recv_array_list);
} else {
static_assert(is_false_v<RecvDataType>, "unexpected type of data");
}
@@ -634,13 +605,11 @@ broadcast(Array<DataType>& array, const size_t& root_rank)
template <typename SendDataType, typename RecvDataType>
PUGS_INLINE void
-exchange(const std::vector<Array<SendDataType>>& sent_array_list,
- std::vector<Array<RecvDataType>>& recv_array_list)
+exchange(const std::vector<Array<SendDataType>>& sent_array_list, std::vector<Array<RecvDataType>>& recv_array_list)
{
static_assert(std::is_same_v<std::remove_const_t<SendDataType>, RecvDataType>,
"send and receive data type do not match");
- static_assert(not std::is_const_v<RecvDataType>,
- "receive data type cannot be const");
+ static_assert(not std::is_const_v<RecvDataType>, "receive data type cannot be const");
messenger().exchange(sent_array_list, recv_array_list);
}
diff --git a/src/utils/Partitioner.cpp b/src/utils/Partitioner.cpp
index 7d6cd98cd1e54451988dfc1209c49fd2da5050e4..8d3f46512fa7de558320b211ad22679d36beef13 100644
--- a/src/utils/Partitioner.cpp
+++ b/src/utils/Partitioner.cpp
@@ -15,8 +15,7 @@
Array<int>
Partitioner::partition(const CSRGraph& graph)
{
- pout() << "Partitioning graph into " << rang::style::bold << parallel::size()
- << rang::style::reset << " parts\n";
+ pout() << "Partitioning graph into " << rang::style::bold << parallel::size() << rang::style::reset << " parts\n";
int wgtflag = 0;
int numflag = 0;
@@ -34,8 +33,7 @@ Partitioner::partition(const CSRGraph& graph)
MPI_Group mesh_group;
std::vector<int> group_ranks = [&]() {
- Array<int> graph_node_owners =
- parallel::allGather(static_cast<int>(graph.numberOfNodes()));
+ Array<int> graph_node_owners = parallel::allGather(static_cast<int>(graph.numberOfNodes()));
std::vector<int> group_ranks;
group_ranks.reserve(graph_node_owners.size());
for (size_t i = 0; i < graph_node_owners.size(); ++i) {
@@ -46,8 +44,7 @@ Partitioner::partition(const CSRGraph& graph)
return group_ranks;
}();
- MPI_Group_incl(world_group, group_ranks.size(), &(group_ranks[0]),
- &mesh_group);
+ MPI_Group_incl(world_group, group_ranks.size(), &(group_ranks[0]), &mesh_group);
MPI_Comm parmetis_comm;
MPI_Comm_create_group(MPI_COMM_WORLD, mesh_group, 1, &parmetis_comm);
@@ -61,10 +58,9 @@ Partitioner::partition(const CSRGraph& graph)
const Array<int>& entries = graph.entries();
const Array<int>& neighbors = graph.neighbors();
- int result = ParMETIS_V3_PartKway(
- &(vtxdist[0]), &(entries[0]), &(neighbors[0]), NULL, NULL, &wgtflag,
- &numflag, &ncon, &npart, &(tpwgts[0]), &(ubvec[0]), &(options[0]),
- &edgecut, &(part[0]), &parmetis_comm);
+ int result =
+ ParMETIS_V3_PartKway(&(vtxdist[0]), &(entries[0]), &(neighbors[0]), NULL, NULL, &wgtflag, &numflag, &ncon, &npart,
+ &(tpwgts[0]), &(ubvec[0]), &(options[0]), &edgecut, &(part[0]), &parmetis_comm);
if (result == METIS_ERROR) {
perr() << "Metis Error\n";
std::exit(1);
diff --git a/src/utils/PugsAssert.hpp b/src/utils/PugsAssert.hpp
index b0f2603827325caa80e471fa3ba113e76d5e6c5b..1ca85e009d7e3013d34e2ef2dbce39c0351b5052 100644
--- a/src/utils/PugsAssert.hpp
+++ b/src/utils/PugsAssert.hpp
@@ -31,29 +31,18 @@ class AssertError
<< rang::style::bold << "---------- Assertion error -----------\n"
<< " at " << assert_error.m_file << ':' << assert_error.m_line << '\n'
<< " in " << assert_error.m_function << '\n'
- << " assertion (" << rang::fgB::red << assert_error.m_test
- << rang::fg::reset << ") failed!\n";
+ << " assertion (" << rang::fgB::red << assert_error.m_test << rang::fg::reset << ") failed!\n";
if (not assert_error.m_message.empty()) {
- os << ' ' << rang::fgB::yellow << assert_error.m_message
- << rang::fg::reset << '\n';
+ os << ' ' << rang::fgB::yellow << assert_error.m_message << rang::fg::reset << '\n';
}
- os << "--------------------------------------" << rang::style::reset
- << '\n';
+ os << "--------------------------------------" << rang::style::reset << '\n';
return os;
}
AssertError(const AssertError&) = default;
- AssertError(std::string file,
- int line,
- std::string function,
- std::string test,
- std::string message = "")
- : m_file(file),
- m_line(line),
- m_function(function),
- m_test(test),
- m_message(message)
+ AssertError(std::string file, int line, std::string function, std::string test, std::string message = "")
+ : m_file(file), m_line(line), m_function(function), m_test(test), m_message(message)
{
;
}
@@ -79,17 +68,15 @@ PRAGMA_DIAGNOSTIC_POP
#else // NDEBUG
-#define Assert(assertion, ...) \
- if (not _pugs_assert(assertion)) { \
- using vargs_t = decltype(std::make_tuple(__VA_ARGS__)); \
- static_assert(std::tuple_size_v<vargs_t> <= 1, "too many arguments"); \
- if constexpr (std::tuple_size_v<vargs_t> == 0) { \
- printAndThrow( \
- AssertError(__FILE__, __LINE__, __PRETTY_FUNCTION__, #assertion)); \
- } else { \
- printAndThrow(AssertError(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
- #assertion, #__VA_ARGS__)); \
- } \
+#define Assert(assertion, ...) \
+ if (not _pugs_assert(assertion)) { \
+ using vargs_t = decltype(std::make_tuple(__VA_ARGS__)); \
+ static_assert(std::tuple_size_v<vargs_t> <= 1, "too many arguments"); \
+ if constexpr (std::tuple_size_v<vargs_t> == 0) { \
+ printAndThrow(AssertError(__FILE__, __LINE__, __PRETTY_FUNCTION__, #assertion)); \
+ } else { \
+ printAndThrow(AssertError(__FILE__, __LINE__, __PRETTY_FUNCTION__, #assertion, #__VA_ARGS__)); \
+ } \
}
#endif // NDEBUG
diff --git a/src/utils/PugsMacros.hpp b/src/utils/PugsMacros.hpp
index 94ac59789b214965c97fc1b2ecb417866aaf64f6..eb0697ba866f2c9b1d8e0c67d22c1e0a3bd4e03d 100644
--- a/src/utils/PugsMacros.hpp
+++ b/src/utils/PugsMacros.hpp
@@ -14,8 +14,7 @@
#if !defined(__clang__) and defined(__GNUC__)
-#define PRAGMA_DIAGNOSTIC_IGNORED_WATTRIBUTES \
- _Pragma("GCC diagnostic ignored \"-Wattributes\"")
+#define PRAGMA_DIAGNOSTIC_IGNORED_WATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wattributes\"")
#define PRAGMA_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
#else // !defined(__clang__) and defined(__GNUC__)
diff --git a/src/utils/PugsTraits.hpp b/src/utils/PugsTraits.hpp
index 0699c209d7003ed70f9a4a631bd487f031a06a9d..3846e141ebe6986b02d4fdb2f87816cb6c4bb277 100644
--- a/src/utils/PugsTraits.hpp
+++ b/src/utils/PugsTraits.hpp
@@ -12,18 +12,14 @@ template <typename T>
inline constexpr bool is_trivially_castable = std::is_trivial_v<T>;
template <size_t N, typename T>
-inline constexpr bool is_trivially_castable<TinyVector<N, T>> =
- is_trivially_castable<T>;
+inline constexpr bool is_trivially_castable<TinyVector<N, T>> = is_trivially_castable<T>;
template <size_t N, typename T>
-inline constexpr bool is_trivially_castable<const TinyVector<N, T>> =
- is_trivially_castable<T>;
+inline constexpr bool is_trivially_castable<const TinyVector<N, T>> = is_trivially_castable<T>;
template <size_t N, typename T>
-inline constexpr bool is_trivially_castable<TinyMatrix<N, T>> =
- is_trivially_castable<T>;
+inline constexpr bool is_trivially_castable<TinyMatrix<N, T>> = is_trivially_castable<T>;
template <size_t N, typename T>
-inline constexpr bool is_trivially_castable<const TinyMatrix<N, T>> =
- is_trivially_castable<T>;
+inline constexpr bool is_trivially_castable<const TinyMatrix<N, T>> = is_trivially_castable<T>;
template <typename T>
inline constexpr bool is_false_v = false;
diff --git a/src/utils/PugsUtils.cpp b/src/utils/PugsUtils.cpp
index e95105acc40402c445f3395fb670ce67fc15c3f3..b0092006fd7bb24743abfc3629d3b123cba17e94 100644
--- a/src/utils/PugsUtils.cpp
+++ b/src/utils/PugsUtils.cpp
@@ -24,17 +24,13 @@ initialize(int& argc, char* argv[])
long unsigned number = 10;
std::string filename;
- pout() << "Pugs version: " << rang::style::bold << RevisionInfo::version()
- << rang::style::reset << '\n';
-
- pout() << "-------------------- " << rang::fg::green << "git info"
- << rang::fg::reset << " -------------------------" << '\n';
- pout() << "tag: " << rang::style::bold << RevisionInfo::gitTag()
- << rang::style::reset << '\n';
- pout() << "HEAD: " << rang::style::bold << RevisionInfo::gitHead()
- << rang::style::reset << '\n';
- pout() << "hash: " << rang::style::bold << RevisionInfo::gitHash()
- << rang::style::reset << " (";
+ pout() << "Pugs version: " << rang::style::bold << RevisionInfo::version() << rang::style::reset << '\n';
+
+ pout() << "-------------------- " << rang::fg::green << "git info" << rang::fg::reset << " -------------------------"
+ << '\n';
+ pout() << "tag: " << rang::style::bold << RevisionInfo::gitTag() << rang::style::reset << '\n';
+ pout() << "HEAD: " << rang::style::bold << RevisionInfo::gitHead() << rang::style::reset << '\n';
+ pout() << "hash: " << rang::style::bold << RevisionInfo::gitHash() << rang::style::reset << " (";
if (RevisionInfo::gitIsClean()) {
pout() << rang::fgB::green << "clean" << rang::fg::reset;
@@ -42,16 +38,12 @@ initialize(int& argc, char* argv[])
pout() << rang::fgB::red << "dirty" << rang::fg::reset;
}
pout() << ")\n";
- pout() << "-------------------- " << rang::fg::green << "build info"
- << rang::fg::reset << " -----------------------" << '\n';
- pout() << "type: " << rang::style::bold << BuildInfo::type()
- << rang::style::reset << '\n';
- pout() << "compiler: " << rang::style::bold << BuildInfo::compiler()
- << rang::style::reset << '\n';
- pout() << "kokkos: " << rang::style::bold << BuildInfo::kokkosDevices()
- << rang::style::reset << '\n';
- pout() << "mpi: " << rang::style::bold << BuildInfo::mpiLibrary()
- << rang::style::reset << '\n';
+ pout() << "-------------------- " << rang::fg::green << "build info" << rang::fg::reset << " -----------------------"
+ << '\n';
+ pout() << "type: " << rang::style::bold << BuildInfo::type() << rang::style::reset << '\n';
+ pout() << "compiler: " << rang::style::bold << BuildInfo::compiler() << rang::style::reset << '\n';
+ pout() << "kokkos: " << rang::style::bold << BuildInfo::kokkosDevices() << rang::style::reset << '\n';
+ pout() << "mpi: " << rang::style::bold << BuildInfo::mpiLibrary() << rang::style::reset << '\n';
pout() << "-------------------------------------------------------\n";
{
CLI::App app{"Pugs help"};
@@ -66,23 +58,22 @@ initialize(int& argc, char* argv[])
->check(CLI::Range(1, std::numeric_limits<decltype(threads)>::max()));
std::string colorize = "auto";
- app.add_set("--colorize", colorize, {"auto", "yes", "no"},
- "Colorize console output", true);
+ app.add_set("--colorize", colorize, {"auto", "yes", "no"}, "Colorize console output", true);
bool disable_fpe = false;
- app.add_flag("--no-fpe", disable_fpe,
- "Do not trap floating point exceptions");
+ app.add_flag("--no-fpe", disable_fpe, "Do not trap floating point exceptions");
bool disable_signals = false;
app.add_flag("--no-signal", disable_signals, "Do not catches signals");
std::string pause_on_error = "auto";
- app.add_set("--pause-on-error", pause_on_error, {"auto", "yes", "no"},
- "Pause for debugging on unexpected error", true);
+ app.add_set("--pause-on-error", pause_on_error, {"auto", "yes", "no"}, "Pause for debugging on unexpected error",
+ true);
std::atexit([]() { pout() << rang::style::reset; });
try {
app.parse(argc, argv);
- } catch (const CLI::ParseError& e) {
+ }
+ catch (const CLI::ParseError& e) {
parallel::Messenger::destroy();
std::exit(app.exit(e, pout(), perr()));
}
@@ -94,8 +85,8 @@ initialize(int& argc, char* argv[])
}
Kokkos::initialize(argc, argv);
- pout() << "-------------------- " << rang::fg::green << "exec info"
- << rang::fg::reset << " ------------------------" << '\n';
+ pout() << "-------------------- " << rang::fg::green << "exec info" << rang::fg::reset << " ------------------------"
+ << '\n';
pout() << rang::style::bold;
Kokkos::DefaultExecutionSpace::print_configuration(pout());
diff --git a/src/utils/PugsUtils.hpp b/src/utils/PugsUtils.hpp
index f5a41609e3ba9ed5fda4bbb751a1f66e51c44ed8..339f5de531d694ce27f921e38f3336e863569bae 100644
--- a/src/utils/PugsUtils.hpp
+++ b/src/utils/PugsUtils.hpp
@@ -9,19 +9,14 @@
template <typename FunctionType>
PUGS_FORCEINLINE void
-parallel_for(const size_t& size,
- const FunctionType& lambda,
- const std::string& label = "")
+parallel_for(const size_t& size, const FunctionType& lambda, const std::string& label = "")
{
Kokkos::parallel_for(size, lambda, label);
}
template <typename ArrayType, typename ReturnType>
PUGS_FORCEINLINE void
-parallel_reduce(const size_t& size,
- const ArrayType& array,
- ReturnType& value,
- const std::string& label = "")
+parallel_reduce(const size_t& size, const ArrayType& array, ReturnType& value, const std::string& label = "")
{
Kokkos::parallel_reduce(label, size, array, value);
}
diff --git a/src/utils/SignalManager.cpp b/src/utils/SignalManager.cpp
index f258952ddf6101a3ad5282f74d0b5a7e30a8511d..26d6ea537368187af03ba7e393517d24ca026ce3 100644
--- a/src/utils/SignalManager.cpp
+++ b/src/utils/SignalManager.cpp
@@ -25,18 +25,18 @@ std::string
SignalManager::signalName(const int& signal)
{
switch (signal) {
- case SIGILL:
- return "SIGILL";
- case SIGFPE:
- return "SIGFPE";
- case SIGABRT:
- return "SIGABRT";
- case SIGINT:
- return "SIGINT";
- case SIGSEGV:
- return "SIGSEGV";
- case SIGTERM:
- return "SIGTERM";
+ case SIGILL:
+ return "SIGILL";
+ case SIGFPE:
+ return "SIGFPE";
+ case SIGABRT:
+ return "SIGABRT";
+ case SIGINT:
+ return "SIGINT";
+ case SIGSEGV:
+ return "SIGSEGV";
+ case SIGTERM:
+ return "SIGTERM";
}
return "SIGNAL undefined!";
}
@@ -47,13 +47,10 @@ SignalManager::pauseForDebug(const int& signal)
if (std::string(PUGS_BUILD_TYPE) != "Release") {
if (s_pause_on_error == "yes") {
std::cerr << "\n======================================\n"
- << rang::style::reset << rang::fg::reset << rang::style::bold
- << "to attach gdb to this process run\n"
- << "\tgdb -pid " << rang::fg::red << getpid() << rang::fg::reset
- << '\n'
+ << rang::style::reset << rang::fg::reset << rang::style::bold << "to attach gdb to this process run\n"
+ << "\tgdb -pid " << rang::fg::red << getpid() << rang::fg::reset << '\n'
<< "else press Control-C to exit\n"
- << rang::style::reset
- << "======================================\n"
+ << rang::style::reset << "======================================\n"
<< std::flush;
pause();
}
@@ -78,16 +75,16 @@ SignalManager::handler(int signal)
if (eptr) {
std::rethrow_exception(eptr);
}
- } catch (const AssertError& assert_error) {
+ }
+ catch (const AssertError& assert_error) {
std::cerr << assert_error << '\n';
- } catch (...) {
+ }
+ catch (...) {
std::cerr << "Unknown exception!\n";
}
- std::cerr << "\n *** " << rang::style::reset << rang::fg::reset
- << rang::style::bold << "Signal " << rang::fgB::red
- << signalName(signal) << rang::fg::reset << " caught"
- << rang::style::reset << " ***\n";
+ std::cerr << "\n *** " << rang::style::reset << rang::fg::reset << rang::style::bold << "Signal " << rang::fgB::red
+ << signalName(signal) << rang::fg::reset << " caught" << rang::style::reset << " ***\n";
SignalManager::pauseForDebug(signal);
}
@@ -103,10 +100,10 @@ SignalManager::init(const bool& enable)
std::signal(SIGABRT, SignalManager::handler);
std::signal(SIGPIPE, SignalManager::handler);
- pout() << "Signal management: " << rang::style::bold << rang::fgB::green
- << "enabled" << rang::fg::reset << rang::style::reset << '\n';
+ pout() << "Signal management: " << rang::style::bold << rang::fgB::green << "enabled" << rang::fg::reset
+ << rang::style::reset << '\n';
} else {
- pout() << "Signal management: " << rang::style::bold << rang::fgB::red
- << "disabled" << rang::fg::reset << rang::style::reset << '\n';
+ pout() << "Signal management: " << rang::style::bold << rang::fgB::red << "disabled" << rang::fg::reset
+ << rang::style::reset << '\n';
}
}
diff --git a/tests/mpi_test_Messenger.cpp b/tests/mpi_test_Messenger.cpp
index 6f634d60cda03496a9f452af163b2e624c85e432..64dd892751d57041eac1a4cf59c6828ceb7e0214 100644
--- a/tests/mpi_test_Messenger.cpp
+++ b/tests/mpi_test_Messenger.cpp
@@ -13,7 +13,8 @@
#define IF_MPI(INSTRUCTION)
#endif // PUGS_HAS_MPI
-namespace mpi_check {
+namespace mpi_check
+{
struct integer
{
int m_int;
@@ -41,8 +42,7 @@ struct tri_int
bool
operator==(const tri_int& t) const
{
- return ((m_int_0 == t.m_int_0) and (m_int_1 == t.m_int_1) and
- (m_int_2 == t.m_int_2));
+ return ((m_int_0 == t.m_int_0) and (m_int_1 == t.m_int_1) and (m_int_2 == t.m_int_2));
}
};
@@ -157,10 +157,8 @@ TEST_CASE("Messenger", "[mpi]")
Array<int> invalid_all_to_all(parallel::size() + 1);
REQUIRE_THROWS_AS(parallel::allToAll(invalid_all_to_all), AssertError);
- Array<int> different_size_all_to_all(parallel::size() *
- (parallel::rank() + 1));
- REQUIRE_THROWS_AS(parallel::allToAll(different_size_all_to_all),
- AssertError);
+ Array<int> different_size_all_to_all(parallel::size() * (parallel::rank() + 1));
+ REQUIRE_THROWS_AS(parallel::allToAll(different_size_all_to_all), AssertError);
}
}
#endif // NDEBUG
@@ -184,8 +182,7 @@ TEST_CASE("Messenger", "[mpi]")
{
// compound trivial type
- mpi_check::tri_int value{static_cast<int>((3 + parallel::rank()) * 2),
- static_cast<int>(2 + parallel::rank()),
+ mpi_check::tri_int value{static_cast<int>((3 + parallel::rank()) * 2), static_cast<int>(2 + parallel::rank()),
static_cast<int>(4 - parallel::rank())};
parallel::broadcast(value, 0);
REQUIRE((value == mpi_check::tri_int{6, 2, 4}));
@@ -217,20 +214,14 @@ TEST_CASE("Messenger", "[mpi]")
{
// compound trivial type
Array<mpi_check::tri_int> array(3);
- array[0] =
- mpi_check::tri_int{static_cast<int>((3 + parallel::rank()) * 2),
- static_cast<int>(2 + parallel::rank()),
- static_cast<int>(4 - parallel::rank())};
- array[1] =
- mpi_check::tri_int{static_cast<int>((2 + parallel::rank()) * 4),
- static_cast<int>(3 + parallel::rank()),
- static_cast<int>(1 - parallel::rank())};
- array[2] = mpi_check::tri_int{static_cast<int>((5 + parallel::rank())),
- static_cast<int>(-3 + parallel::rank()),
+ array[0] = mpi_check::tri_int{static_cast<int>((3 + parallel::rank()) * 2),
+ static_cast<int>(2 + parallel::rank()), static_cast<int>(4 - parallel::rank())};
+ array[1] = mpi_check::tri_int{static_cast<int>((2 + parallel::rank()) * 4),
+ static_cast<int>(3 + parallel::rank()), static_cast<int>(1 - parallel::rank())};
+ array[2] = mpi_check::tri_int{static_cast<int>((5 + parallel::rank())), static_cast<int>(-3 + parallel::rank()),
static_cast<int>(parallel::rank())};
parallel::broadcast(array, 0);
- REQUIRE(((array[0] == mpi_check::tri_int{6, 2, 4}) and
- (array[1] == mpi_check::tri_int{8, 3, 1}) and
+ REQUIRE(((array[0] == mpi_check::tri_int{6, 2, 4}) and (array[1] == mpi_check::tri_int{8, 3, 1}) and
(array[2] == mpi_check::tri_int{5, -3, 0})));
}
}
@@ -262,15 +253,13 @@ TEST_CASE("Messenger", "[mpi]")
{
// compound trivial type
- mpi_check::tri_int value{static_cast<int>((3 + parallel::rank()) * 2),
- static_cast<int>(2 + parallel::rank()),
+ mpi_check::tri_int value{static_cast<int>((3 + parallel::rank()) * 2), static_cast<int>(2 + parallel::rank()),
static_cast<int>(4 - parallel::rank())};
Array<mpi_check::tri_int> gather_array = parallel::allGather(value);
REQUIRE(gather_array.size() == parallel::size());
for (size_t i = 0; i < gather_array.size(); ++i) {
- mpi_check::tri_int expected_value{static_cast<int>((3 + i) * 2),
- static_cast<int>(2 + i),
+ mpi_check::tri_int expected_value{static_cast<int>((3 + i) * 2), static_cast<int>(2 + i),
static_cast<int>(4 - i)};
REQUIRE((gather_array[i] == expected_value));
}
@@ -289,8 +278,7 @@ TEST_CASE("Messenger", "[mpi]")
REQUIRE(gather_array.size() == array.size() * parallel::size());
for (size_t i = 0; i < gather_array.size(); ++i) {
- const int expected_value =
- (3 + i / array.size()) * 2 + (i % array.size());
+ const int expected_value = (3 + i / array.size()) * 2 + (i % array.size());
REQUIRE((gather_array[i] == expected_value));
}
}
@@ -305,8 +293,7 @@ TEST_CASE("Messenger", "[mpi]")
REQUIRE(gather_array.size() == array.size() * parallel::size());
for (size_t i = 0; i < gather_array.size(); ++i) {
- const int expected_value =
- (3 + i / array.size()) * 2 + (i % array.size());
+ const int expected_value = (3 + i / array.size()) * 2 + (i % array.size());
REQUIRE((gather_array[i] == expected_value));
}
}
@@ -316,18 +303,16 @@ TEST_CASE("Messenger", "[mpi]")
Array<mpi_check::tri_int> array(3);
for (size_t i = 0; i < array.size(); ++i) {
array[i] =
- mpi_check::tri_int{static_cast<int>((3 + parallel::rank()) * 2),
- static_cast<int>(2 + parallel::rank() + i),
+ mpi_check::tri_int{static_cast<int>((3 + parallel::rank()) * 2), static_cast<int>(2 + parallel::rank() + i),
static_cast<int>(4 - parallel::rank() - i)};
}
Array<mpi_check::tri_int> gather_array = parallel::allGather(array);
REQUIRE(gather_array.size() == array.size() * parallel::size());
for (size_t i = 0; i < gather_array.size(); ++i) {
- mpi_check::tri_int expected_value{
- static_cast<int>((3 + i / array.size()) * 2),
- static_cast<int>(2 + i / array.size() + (i % array.size())),
- static_cast<int>(4 - i / array.size() - (i % array.size()))};
+ mpi_check::tri_int expected_value{static_cast<int>((3 + i / array.size()) * 2),
+ static_cast<int>(2 + i / array.size() + (i % array.size())),
+ static_cast<int>(4 - i / array.size() - (i % array.size()))};
REQUIRE((gather_array[i] == expected_value));
}
}
@@ -389,9 +374,8 @@ TEST_CASE("Messenger", "[mpi]")
for (size_t i = 0; i < send_array_list.size(); ++i) {
Array<mpi_check::tri_int> send_array(i + 1);
for (size_t j = 0; j < send_array.size(); ++j) {
- send_array[j] = mpi_check::tri_int{
- static_cast<int>((parallel::rank() + 1) * j),
- static_cast<int>(parallel::rank()), static_cast<int>(j)};
+ send_array[j] = mpi_check::tri_int{static_cast<int>((parallel::rank() + 1) * j),
+ static_cast<int>(parallel::rank()), static_cast<int>(j)};
}
send_array_list[i] = send_array;
}
@@ -405,9 +389,7 @@ TEST_CASE("Messenger", "[mpi]")
for (size_t i = 0; i < parallel::size(); ++i) {
const Array<const mpi_check::tri_int> recv_array = recv_array_list[i];
for (size_t j = 0; j < recv_array.size(); ++j) {
- mpi_check::tri_int expected_value{static_cast<int>((i + 1) * j),
- static_cast<int>(i),
- static_cast<int>(j)};
+ mpi_check::tri_int expected_value{static_cast<int>((i + 1) * j), static_cast<int>(i), static_cast<int>(j)};
REQUIRE((recv_array[j] == expected_value));
}
}
@@ -425,8 +407,7 @@ TEST_CASE("Messenger", "[mpi]")
}
std::vector<Array<int>> recv_array_list(parallel::size());
- REQUIRE_THROWS_AS(parallel::exchange(send_array_list, recv_array_list),
- AssertError);
+ REQUIRE_THROWS_AS(parallel::exchange(send_array_list, recv_array_list), AssertError);
}
#endif // NDEBUG
diff --git a/tests/test_Array.cpp b/tests/test_Array.cpp
index 445edd890a1fe08374793598d499fed587762bab..54610b6e93a3174b018fb14edee8eba68f253c34 100644
--- a/tests/test_Array.cpp
+++ b/tests/test_Array.cpp
@@ -23,29 +23,25 @@ TEST_CASE("Array", "[utils]")
a[i] = 2 * i;
}
- REQUIRE(((a[0] == 0) and (a[1] == 2) and (a[2] == 4) and (a[3] == 6) and
- (a[4] == 8) and (a[5] == 10) and (a[6] == 12) and (a[7] == 14) and
- (a[8] == 16) and (a[9] == 18)));
+ REQUIRE(((a[0] == 0) and (a[1] == 2) and (a[2] == 4) and (a[3] == 6) and (a[4] == 8) and (a[5] == 10) and
+ (a[6] == 12) and (a[7] == 14) and (a[8] == 16) and (a[9] == 18)));
SECTION("checking for copies")
{
Array<const int> b{a};
- REQUIRE(((b[0] == 0) and (b[1] == 2) and (b[2] == 4) and (b[3] == 6) and
- (b[4] == 8) and (b[5] == 10) and (b[6] == 12) and (b[7] == 14) and
- (b[8] == 16) and (b[9] == 18)));
+ REQUIRE(((b[0] == 0) and (b[1] == 2) and (b[2] == 4) and (b[3] == 6) and (b[4] == 8) and (b[5] == 10) and
+ (b[6] == 12) and (b[7] == 14) and (b[8] == 16) and (b[9] == 18)));
Array<int> c{a};
- REQUIRE(((c[0] == 0) and (c[1] == 2) and (c[2] == 4) and (c[3] == 6) and
- (c[4] == 8) and (c[5] == 10) and (c[6] == 12) and (c[7] == 14) and
- (c[8] == 16) and (c[9] == 18)));
+ REQUIRE(((c[0] == 0) and (c[1] == 2) and (c[2] == 4) and (c[3] == 6) and (c[4] == 8) and (c[5] == 10) and
+ (c[6] == 12) and (c[7] == 14) and (c[8] == 16) and (c[9] == 18)));
Array<int> d = std::move(c);
- REQUIRE(((d[0] == 0) and (d[1] == 2) and (d[2] == 4) and (d[3] == 6) and
- (d[4] == 8) and (d[5] == 10) and (d[6] == 12) and (d[7] == 14) and
- (d[8] == 16) and (d[9] == 18)));
+ REQUIRE(((d[0] == 0) and (d[1] == 2) and (d[2] == 4) and (d[3] == 6) and (d[4] == 8) and (d[5] == 10) and
+ (d[6] == 12) and (d[7] == 14) and (d[8] == 16) and (d[9] == 18)));
}
SECTION("checking for fill")
@@ -53,9 +49,8 @@ TEST_CASE("Array", "[utils]")
Array<int> b(10);
b.fill(3);
- REQUIRE(((b[0] == 3) and (b[1] == 3) and (b[2] == 3) and (b[3] == 3) and
- (b[4] == 3) and (b[5] == 3) and (b[6] == 3) and (b[7] == 3) and
- (b[8] == 3) and (b[9] == 3)));
+ REQUIRE(((b[0] == 3) and (b[1] == 3) and (b[2] == 3) and (b[3] == 3) and (b[4] == 3) and (b[5] == 3) and
+ (b[6] == 3) and (b[7] == 3) and (b[8] == 3) and (b[9] == 3)));
}
SECTION("checking for affectations (shallow copy)")
@@ -63,59 +58,50 @@ TEST_CASE("Array", "[utils]")
Array<const int> b;
b = a;
- REQUIRE(((b[0] == 0) and (b[1] == 2) and (b[2] == 4) and (b[3] == 6) and
- (b[4] == 8) and (b[5] == 10) and (b[6] == 12) and (b[7] == 14) and
- (b[8] == 16) and (b[9] == 18)));
+ REQUIRE(((b[0] == 0) and (b[1] == 2) and (b[2] == 4) and (b[3] == 6) and (b[4] == 8) and (b[5] == 10) and
+ (b[6] == 12) and (b[7] == 14) and (b[8] == 16) and (b[9] == 18)));
Array<int> c;
c = a;
- REQUIRE(((c[0] == 0) and (c[1] == 2) and (c[2] == 4) and (c[3] == 6) and
- (c[4] == 8) and (c[5] == 10) and (c[6] == 12) and (c[7] == 14) and
- (c[8] == 16) and (c[9] == 18)));
+ REQUIRE(((c[0] == 0) and (c[1] == 2) and (c[2] == 4) and (c[3] == 6) and (c[4] == 8) and (c[5] == 10) and
+ (c[6] == 12) and (c[7] == 14) and (c[8] == 16) and (c[9] == 18)));
Array<int> d;
d = std::move(c);
- REQUIRE(((d[0] == 0) and (d[1] == 2) and (d[2] == 4) and (d[3] == 6) and
- (d[4] == 8) and (d[5] == 10) and (d[6] == 12) and (d[7] == 14) and
- (d[8] == 16) and (d[9] == 18)));
+ REQUIRE(((d[0] == 0) and (d[1] == 2) and (d[2] == 4) and (d[3] == 6) and (d[4] == 8) and (d[5] == 10) and
+ (d[6] == 12) and (d[7] == 14) and (d[8] == 16) and (d[9] == 18)));
}
SECTION("checking for affectations (deep copy)")
{
Array<int> b(copy(a));
- REQUIRE(((b[0] == 0) and (b[1] == 2) and (b[2] == 4) and (b[3] == 6) and
- (b[4] == 8) and (b[5] == 10) and (b[6] == 12) and (b[7] == 14) and
- (b[8] == 16) and (b[9] == 18)));
+ REQUIRE(((b[0] == 0) and (b[1] == 2) and (b[2] == 4) and (b[3] == 6) and (b[4] == 8) and (b[5] == 10) and
+ (b[6] == 12) and (b[7] == 14) and (b[8] == 16) and (b[9] == 18)));
b.fill(2);
- REQUIRE(((a[0] == 0) and (a[1] == 2) and (a[2] == 4) and (a[3] == 6) and
- (a[4] == 8) and (a[5] == 10) and (a[6] == 12) and (a[7] == 14) and
- (a[8] == 16) and (a[9] == 18)));
+ REQUIRE(((a[0] == 0) and (a[1] == 2) and (a[2] == 4) and (a[3] == 6) and (a[4] == 8) and (a[5] == 10) and
+ (a[6] == 12) and (a[7] == 14) and (a[8] == 16) and (a[9] == 18)));
- REQUIRE(((b[0] == 2) and (b[1] == 2) and (b[2] == 2) and (b[3] == 2) and
- (b[4] == 2) and (b[5] == 2) and (b[6] == 2) and (b[7] == 2) and
- (b[8] == 2) and (b[9] == 2)));
+ REQUIRE(((b[0] == 2) and (b[1] == 2) and (b[2] == 2) and (b[3] == 2) and (b[4] == 2) and (b[5] == 2) and
+ (b[6] == 2) and (b[7] == 2) and (b[8] == 2) and (b[9] == 2)));
Array<int> c;
c = a;
- REQUIRE(((c[0] == 0) and (c[1] == 2) and (c[2] == 4) and (c[3] == 6) and
- (c[4] == 8) and (c[5] == 10) and (c[6] == 12) and (c[7] == 14) and
- (c[8] == 16) and (c[9] == 18)));
+ REQUIRE(((c[0] == 0) and (c[1] == 2) and (c[2] == 4) and (c[3] == 6) and (c[4] == 8) and (c[5] == 10) and
+ (c[6] == 12) and (c[7] == 14) and (c[8] == 16) and (c[9] == 18)));
c = copy(b);
- REQUIRE(((a[0] == 0) and (a[1] == 2) and (a[2] == 4) and (a[3] == 6) and
- (a[4] == 8) and (a[5] == 10) and (a[6] == 12) and (a[7] == 14) and
- (a[8] == 16) and (a[9] == 18)));
+ REQUIRE(((a[0] == 0) and (a[1] == 2) and (a[2] == 4) and (a[3] == 6) and (a[4] == 8) and (a[5] == 10) and
+ (a[6] == 12) and (a[7] == 14) and (a[8] == 16) and (a[9] == 18)));
- REQUIRE(((c[0] == 2) and (c[1] == 2) and (c[2] == 2) and (c[3] == 2) and
- (c[4] == 2) and (c[5] == 2) and (c[6] == 2) and (c[7] == 2) and
- (c[8] == 2) and (c[9] == 2)));
+ REQUIRE(((c[0] == 2) and (c[1] == 2) and (c[2] == 2) and (c[3] == 2) and (c[4] == 2) and (c[5] == 2) and
+ (c[6] == 2) and (c[7] == 2) and (c[8] == 2) and (c[9] == 2)));
}
SECTION("checking for std container conversion")
@@ -126,16 +112,14 @@ TEST_CASE("Array", "[utils]")
Array<int> v_array = convert_to_array(v);
REQUIRE(v_array.size() == v.size());
- REQUIRE(((v_array[0] == 1) and (v_array[1] == 2) and
- (v_array[2] == 5) and (v_array[3] == 3)));
+ REQUIRE(((v_array[0] == 1) and (v_array[1] == 2) and (v_array[2] == 5) and (v_array[3] == 3)));
}
{
Array<const int> v_array = convert_to_array(v);
REQUIRE(v_array.size() == v.size());
- REQUIRE(((v_array[0] == 1) and (v_array[1] == 2) and
- (v_array[2] == 5) and (v_array[3] == 3)));
+ REQUIRE(((v_array[0] == 1) and (v_array[1] == 2) and (v_array[2] == 5) and (v_array[3] == 3)));
}
}
@@ -156,8 +140,7 @@ TEST_CASE("Array", "[utils]")
Array<int> v_array = convert_to_array(v);
REQUIRE(v_array.size() == v.size());
- REQUIRE(((v_array[0] == 1) and (v_array[1] == 2) and (v_array[2] == 5) and
- (v_array[3] == 3)));
+ REQUIRE(((v_array[0] == 1) and (v_array[1] == 2) and (v_array[2] == 5) and (v_array[3] == 3)));
}
{
@@ -165,8 +148,8 @@ TEST_CASE("Array", "[utils]")
Array<int> s_array = convert_to_array(s);
REQUIRE(s_array.size() == s.size());
- REQUIRE(((s_array[0] == 1) and (s_array[1] == 2) and (s_array[2] == 3) and
- (s_array[3] == 4) and (s_array[4] == 5)));
+ REQUIRE(
+ ((s_array[0] == 1) and (s_array[1] == 2) and (s_array[2] == 3) and (s_array[3] == 4) and (s_array[4] == 5)));
}
{
@@ -188,10 +171,8 @@ TEST_CASE("Array", "[utils]")
Array<int> ms_array = convert_to_array(ms);
REQUIRE(ms_array.size() == ms.size());
- REQUIRE(((ms_array[0] == 1) and (ms_array[1] == 2) and
- (ms_array[2] == 2) and (ms_array[3] == 3) and
- (ms_array[4] == 3) and (ms_array[5] == 4) and
- (ms_array[6] == 5)));
+ REQUIRE(((ms_array[0] == 1) and (ms_array[1] == 2) and (ms_array[2] == 2) and (ms_array[3] == 3) and
+ (ms_array[4] == 3) and (ms_array[5] == 4) and (ms_array[6] == 5)));
}
{
@@ -199,8 +180,8 @@ TEST_CASE("Array", "[utils]")
Array<int> l_array = convert_to_array(l);
REQUIRE(l_array.size() == l.size());
- REQUIRE(((l_array[0] == 1) and (l_array[1] == 3) and (l_array[2] == 5) and
- (l_array[3] == 6) and (l_array[4] == 2)));
+ REQUIRE(
+ ((l_array[0] == 1) and (l_array[1] == 3) and (l_array[2] == 5) and (l_array[3] == 6) and (l_array[4] == 2)));
}
{
@@ -209,8 +190,8 @@ TEST_CASE("Array", "[utils]")
Array<int> q_array = convert_to_array(q);
REQUIRE(q_array.size() == q.size());
- REQUIRE(((q_array[0] == 2) and (q_array[1] == 1) and (q_array[2] == 3) and
- (q_array[3] == 5) and (q_array[4] == 6) and (q_array[5] == 2)));
+ REQUIRE(((q_array[0] == 2) and (q_array[1] == 1) and (q_array[2] == 3) and (q_array[3] == 5) and
+ (q_array[4] == 6) and (q_array[5] == 2)));
}
}
diff --git a/tests/test_ItemType.cpp b/tests/test_ItemType.cpp
index e1164ee99c6ec28b8da2b8ea620e00b7240849bf..9b2813dff60ec34bf2bf33a6d52baf0893289f23 100644
--- a/tests/test_ItemType.cpp
+++ b/tests/test_ItemType.cpp
@@ -12,9 +12,8 @@ TEST_CASE("ItemType", "[connectivity]")
SECTION("checking for item type differences")
{
- REQUIRE(((node_type != edge_type) and (node_type != face_type) and
- (node_type != cell_type) and (edge_type != face_type) and
- (edge_type != cell_type) and (face_type != cell_type)));
+ REQUIRE(((node_type != edge_type) and (node_type != face_type) and (node_type != cell_type) and
+ (edge_type != face_type) and (edge_type != cell_type) and (face_type != cell_type)));
}
SECTION("checking for item type names")
diff --git a/tests/test_PugsAssert.cpp b/tests/test_PugsAssert.cpp
index 570763b0a3bab52c4a6eaaefd78c44a77bfee94d..afa6e6d4bef5fee716430e960823a183f735eae4 100644
--- a/tests/test_PugsAssert.cpp
+++ b/tests/test_PugsAssert.cpp
@@ -14,10 +14,9 @@ TEST_CASE("PugsAssert", "[utils]")
AssertError assert_error(filename, line, function, test);
- REQUIRE(Catch::Detail::stringify(assert_error) ==
- "\n---------- Assertion error -----------\n at filename:10\n in "
- "function\n assertion (test) "
- "failed!\n--------------------------------------\n");
+ REQUIRE(Catch::Detail::stringify(assert_error) == "\n---------- Assertion error -----------\n at filename:10\n in "
+ "function\n assertion (test) "
+ "failed!\n--------------------------------------\n");
}
SECTION("checking for assert error with message")
@@ -30,9 +29,8 @@ TEST_CASE("PugsAssert", "[utils]")
AssertError assert_error(filename, line, function, test, message);
- REQUIRE(Catch::Detail::stringify(assert_error) ==
- "\n---------- Assertion error -----------\n at filename:10\n in "
- "function\n assertion (test) failed!\n "
- "message\n--------------------------------------\n");
+ REQUIRE(Catch::Detail::stringify(assert_error) == "\n---------- Assertion error -----------\n at filename:10\n in "
+ "function\n assertion (test) failed!\n "
+ "message\n--------------------------------------\n");
}
}
diff --git a/tests/test_TinyMatrix.cpp b/tests/test_TinyMatrix.cpp
index a12c9a462bcb0f5fdcb194729d7d7a8fdc96cc44..9ae46f62d19bbe6210cf7fc0eb22f9b339d40af7 100644
--- a/tests/test_TinyMatrix.cpp
+++ b/tests/test_TinyMatrix.cpp
@@ -14,27 +14,23 @@ template class TinyMatrix<4, double>;
TEST_CASE("TinyMatrix", "[algebra]")
{
TinyMatrix<3, int> A(1, 2, 3, 4, 5, 6, 7, 8, 9);
- REQUIRE(((A(0, 0) == 1) and (A(0, 1) == 2) and (A(0, 2) == 3) and
- (A(1, 0) == 4) and (A(1, 1) == 5) and (A(1, 2) == 6) and
- (A(2, 0) == 7) and (A(2, 1) == 8) and (A(2, 2) == 9)));
+ REQUIRE(((A(0, 0) == 1) and (A(0, 1) == 2) and (A(0, 2) == 3) and (A(1, 0) == 4) and (A(1, 1) == 5) and
+ (A(1, 2) == 6) and (A(2, 0) == 7) and (A(2, 1) == 8) and (A(2, 2) == 9)));
TinyMatrix<3, int> B(6, 5, 3, 8, 34, 6, 35, 6, 7);
SECTION("checking for opposed matrix")
{
const TinyMatrix<3, int> minus_A = -A;
- REQUIRE(((minus_A(0, 0) == -1) and (minus_A(0, 1) == -2) and
- (minus_A(0, 2) == -3) and (minus_A(1, 0) == -4) and
- (minus_A(1, 1) == -5) and (minus_A(1, 2) == -6) and
- (minus_A(2, 0) == -7) and (minus_A(2, 1) == -8) and
+ REQUIRE(((minus_A(0, 0) == -1) and (minus_A(0, 1) == -2) and (minus_A(0, 2) == -3) and (minus_A(1, 0) == -4) and
+ (minus_A(1, 1) == -5) and (minus_A(1, 2) == -6) and (minus_A(2, 0) == -7) and (minus_A(2, 1) == -8) and
(minus_A(2, 2) == -9)));
}
SECTION("checking for equality and difference tests")
{
const TinyMatrix<3, int> copy_A = A;
- REQUIRE(
- ((copy_A(0, 0) == 1) and (copy_A(0, 1) == 2) and (copy_A(0, 2) == 3) and
- (copy_A(1, 0) == 4) and (copy_A(1, 1) == 5) and (copy_A(1, 2) == 6) and
- (copy_A(2, 0) == 7) and (copy_A(2, 1) == 8) and (copy_A(2, 2) == 9)));
+ REQUIRE(((copy_A(0, 0) == 1) and (copy_A(0, 1) == 2) and (copy_A(0, 2) == 3) and (copy_A(1, 0) == 4) and
+ (copy_A(1, 1) == 5) and (copy_A(1, 2) == 6) and (copy_A(2, 0) == 7) and (copy_A(2, 1) == 8) and
+ (copy_A(2, 2) == 9)));
REQUIRE(copy_A == A);
REQUIRE_FALSE(copy_A != A);
@@ -60,8 +56,7 @@ TEST_CASE("TinyMatrix", "[algebra]")
const int a = 2;
TinyMatrix<3, int> copy_A = A;
- REQUIRE((copy_A *= a) ==
- TinyMatrix<3, int>(2, 4, 6, 8, 10, 12, 14, 16, 18));
+ REQUIRE((copy_A *= a) == TinyMatrix<3, int>(2, 4, 6, 8, 10, 12, 14, 16, 18));
}
SECTION("checking for null matrix management")
@@ -110,8 +105,7 @@ TEST_CASE("TinyMatrix", "[algebra]")
SECTION("checking for matrices product")
{
- REQUIRE(A * B ==
- TinyMatrix<3, int>(127, 91, 36, 274, 226, 84, 421, 361, 132));
+ REQUIRE(A * B == TinyMatrix<3, int>(127, 91, 36, 274, 226, 84, 421, 361, 132));
}
SECTION("checking for matrix-vector product")
@@ -124,8 +118,7 @@ TEST_CASE("TinyMatrix", "[algebra]")
const TinyVector<3, int> u(1, 3, 7);
const TinyVector<3, int> v(6, 2, -3);
- REQUIRE(tensorProduct(u, v) ==
- TinyMatrix<3, int>(6, 2, -3, 18, 6, -9, 42, 14, -21));
+ REQUIRE(tensorProduct(u, v) == TinyMatrix<3, int>(6, 2, -3, 18, 6, -9, 42, 14, -21));
}
SECTION("checking for minor calculation")
@@ -165,8 +158,7 @@ TEST_CASE("TinyMatrix", "[algebra]")
REQUIRE(det(TinyMatrix<1, int>(6)) == 6);
REQUIRE(det(TinyMatrix<2, int>(3, 1, -3, 6)) == 21);
REQUIRE(det(B) == -1444);
- REQUIRE(det(TinyMatrix<4, double>(1, 2.3, 7, -6.2, 3, 4, 9, 1, 4.1, 5, 2,
- -3, 2, 27, 3, 17.5)) ==
+ REQUIRE(det(TinyMatrix<4, double>(1, 2.3, 7, -6.2, 3, 4, 9, 1, 4.1, 5, 2, -3, 2, 27, 3, 17.5)) ==
Approx(6661.455).epsilon(1E-14));
}