* fixed clang-tidy warnings

cellular_automaton/wireworld_c++/CollectiveCommunicator.cpp

 #include "CollectiveCommunicator.hpp"
 
 void CollectiveCommunicator::Communicate(State* model) {
-	if (commDistGraph_ == MPI_COMM_NULL)
-		MpiReportErrorAbort("Communicator not initialized");
+	if (commDistGraph_ == MPI_COMM_NULL) { MpiReportErrorAbort("Communicator not initialized"); }
 
 	MPI_Neighbor_alltoallw(model,                     // sendbuf
 	                       sizes_.data(),             // sendcounts
@@ -17,8 +16,7 @@ void CollectiveCommunicator::Communicate(State* model) {
 }
 
 MpiRequest CollectiveCommunicator::AsyncCommunicate(State* model) {
-	if (commDistGraph_ == MPI_COMM_NULL)
-		MpiReportErrorAbort("Communicator not initialized");
+	if (commDistGraph_ == MPI_COMM_NULL) { MpiReportErrorAbort("Communicator not initialized"); }
 
 	MPI_Request req;
 	MPI_Ineighbor_alltoallw(model,                     // sendbuf

cellular_automaton/wireworld_c++/Communicator.cpp

@@ -5,11 +5,9 @@
 #include "Communicator.hpp"
 
 // defines types and graph topology
-Communicator::Communicator(const MpiEnvironment& env, const Size& procsSize,
-                           const Size& tileSize) {
+Communicator::Communicator(const MpiEnvironment& env, const Size& gridSize, const Size& tileSize) {
 	// Begin definition of basic types
-	MPI_Type_contiguous(static_cast<int>(tileSize.Cols), MPI_CHAR,
-	                    &haloRowType_);
+	MPI_Type_contiguous(static_cast<int>(tileSize.Cols), MPI_CHAR, &haloRowType_);
 	MPI_Type_commit(&haloRowType_);
 
 	MPI_Type_vector(static_cast<int>(tileSize.Rows), 1, static_cast<int>(tileSize.Cols + 2), MPI_CHAR,
@@ -29,9 +27,7 @@ Communicator::Communicator(const MpiEnvironment& env, const Size& procsSize,
 	const auto tRows = tileSize.Rows;
 
 	// character coordinates to displacement
-	const auto dp = [&](std::size_t x, std::size_t y) {
-		return static_cast<MPI_Aint>(y * (tCols + 2) + x);
-	};
+	const auto dp = [&](std::size_t x, std::size_t y) { return static_cast<MPI_Aint>(y * (tCols + 2) + x); };
 
 	const std::array<MPI_Aint, NoNeighbors> generalSendDisplacements{{
 	    dp(1, 1), dp(1, 1), dp(tCols, 1),            //
@@ -56,16 +52,14 @@ Communicator::Communicator(const MpiEnvironment& env, const Size& procsSize,
 	// border cases)
 	const auto rank2coord = [&](std::size_t rank) {
 		return Coord{
-		    rank % procsSize.Cols, //
-		    rank / procsSize.Cols  //
+		    rank % gridSize.Cols, //
+		    rank / gridSize.Cols  //
 		};
 	};
 
-	const auto coord2rank = [&](Coord c) { return static_cast<int>(procsSize.Cols * c.Y + c.X); };
+	const auto coord2rank = [&](Coord c) { return static_cast<int>(gridSize.Cols * c.Y + c.X); };
 
-	const auto isInsideProcsGrid = [&](Coord c) {
-		return c.X < procsSize.Cols && c.Y < procsSize.Rows;
-	};
+	const auto isInsideProcsGrid = [&](Coord c) { return c.X < gridSize.Cols && c.Y < gridSize.Rows; };
 
 	const auto myCoord = rank2coord(env.worldRank());
 	const std::array<Coord, NoNeighbors> generalNeighborCoords{{
@@ -90,18 +84,17 @@ Communicator::Communicator(const MpiEnvironment& env, const Size& procsSize,
 		}
 	}
 
-	MPI_Dist_graph_create_adjacent(
-	    MPI_COMM_WORLD,                         // comm_old
-	    static_cast<int>(neighbors_.size()),    // indegree
-	    neighbors_.data(),                      // sources
-	    reinterpret_cast<int*>(MPI_UNWEIGHTED), // sourceweights
-	    static_cast<int>(neighbors_.size()),    // outdegree
-	    neighbors_.data(),                      // destinations
-	    reinterpret_cast<int*>(MPI_UNWEIGHTED), // destweights
-	    MPI_INFO_NULL,                          // info
-	    0,                                      // reorder
-	    &commDistGraph_                         // comm_dist_graph
-	    );
+	MPI_Dist_graph_create_adjacent(MPI_COMM_WORLD,                      // comm_old
+	                               static_cast<int>(neighbors_.size()), // indegree
+	                               neighbors_.data(),                   // sources
+	                               static_cast<int*>(MPI_UNWEIGHTED),   // sourceweights
+	                               static_cast<int>(neighbors_.size()), // outdegree
+	                               neighbors_.data(),                   // destinations
+	                               static_cast<int*>(MPI_UNWEIGHTED),   // destweights
+	                               MPI_INFO_NULL,                       // info
+	                               0,                                   // reorder
+	                               &commDistGraph_                      // comm_dist_graph
+	                               );
 	// End definition of datastructures for this particular cell
 }
 
@@ -126,9 +119,7 @@ void Communicator::swap(Communicator& first, Communicator& second) {
 	swap(first.haloCornerType_, second.haloCornerType_);
 }
 
-Communicator::Communicator(Communicator&& other) noexcept {
-	swap(*this, other);
-}
+Communicator::Communicator(Communicator&& other) noexcept { swap(*this, other); }
 Communicator& Communicator::operator=(Communicator&& other) noexcept {
 	swap(*this, other);
 	return *this;

cellular_automaton/wireworld_c++/Configuration.cpp

@@ -16,14 +16,14 @@ std::istream& operator>>(std::istream& in, CommunicationMode& comm) {
 	in >> buf;
 	const auto& str2comm = StringToCommunicationMode();
 	auto r = std::find_if(std::begin(str2comm), std::end(str2comm), [&](auto& t) { return t.first == buf; });
-	if (r == std::end(str2comm))
+	if (r == std::end(str2comm)) {
 		throw boost::program_options::validation_error(boost::program_options::validation_error::invalid_option_value);
+	}
 	comm = r->second;
 	return in;
 }
 
-auto Configuration::parseArgs(int argc, char* argv[], const MpiEnvironment& env)
-    -> Configuration {
+auto Configuration::parseArgs(int argc, char* argv[], const MpiEnvironment& env) -> Configuration {
 	namespace po = boost::program_options;
 	Configuration cfg;
 
@@ -52,16 +52,13 @@ auto Configuration::parseArgs(int argc, char* argv[], const MpiEnvironment& env)
 		              .run(),
 		          vm);
 
-		if (vm.count("help") > 0 && env.isMaster()) {
-			std::cout << desc << "\n";
-		}
+		if (vm.count("help") > 0 && env.isMaster()) { std::cout << desc << "\n"; }
 		po::notify(vm);
 	} catch (const po::error& err) { MpiReportErrorAbort(err.what()); }
 
 	// if no dimensions given, use MPI_Dims_create
 	if (cfg.Procs.Cols < 1 || cfg.Procs.Rows < 1) {
-		std::array<int, 2> dims{{static_cast<int>(cfg.Procs.Cols),
-		                         static_cast<int>(cfg.Procs.Rows)}};
+		std::array<int, 2> dims{{static_cast<int>(cfg.Procs.Cols), static_cast<int>(cfg.Procs.Rows)}};
 		MPI_Dims_create(static_cast<int>(env.worldSize()), // nnodes
 		                2,                                 // ndims
 		                dims.data());                      // dims
@@ -74,10 +71,9 @@ auto Configuration::parseArgs(int argc, char* argv[], const MpiEnvironment& env)
 	const auto& totalCellCount = cfg.Procs.Cols * cfg.Procs.Rows;
 	const auto& worldSize = env.worldSize();
 	if (totalCellCount != static_cast<std::size_t>(worldSize)) {
-		MpiReportErrorAbort(boost::str(
-		    boost::format("Total number of cells (%d) does not match "
-		                  "the MPI World size (%d)") %
-		    totalCellCount % worldSize));
+		MpiReportErrorAbort(boost::str(boost::format("Total number of cells (%d) does not match "
+		                                             "the MPI World size (%d)") %
+		                               totalCellCount % worldSize));
 	}
 	return cfg;
 }

cellular_automaton/wireworld_c++/main.cpp

@@ -6,8 +6,6 @@
 #include "MpiEnvironment.hpp"
 #include "MpiWireworld.hpp"
 
-using namespace std::string_literals;
-
 int main(int argc, char* argv[]) {
 	const auto& starttime = std::chrono::system_clock::now();