format

Author: lroberts36

example/diffusion/diffusion_equation.hpp

@@ -109,7 +109,8 @@ class DiffusionEquation {
     if (set_flux_boundary) {
       flux_res = tl.AddTask(flux_res, SetFluxBoundaries, md_mat, md_in, include_flux_dx);
     }
-    if (do_flux_cor && !(md_mat->grid.type() == parthenon::GridType::two_level_composite)) {
+    if (do_flux_cor &&
+        !(md_mat->grid.type() == parthenon::GridType::two_level_composite)) {
       auto start_flxcor =
           tl.AddTask(flux_res, parthenon::StartReceiveFluxCorrections, md_in);
       auto send_flxcor =

example/poisson_gmg/poisson_equation.hpp

@@ -59,7 +59,8 @@ class PoissonEquation {
     if (set_flux_boundary) {
       flux_res = tl.AddTask(flux_res, SetFluxBoundaries, md_mat, md_in, include_flux_dx);
     }
-    if (do_flux_cor && !(md_mat->grid.type() == parthenon::GridType::two_level_composite)) {
+    if (do_flux_cor &&
+        !(md_mat->grid.type() == parthenon::GridType::two_level_composite)) {
       auto start_flxcor =
           tl.AddTask(flux_res, parthenon::StartReceiveFluxCorrections, md_in);
       auto send_flxcor =

src/basic_types.hpp

@@ -110,7 +110,7 @@ inline constexpr BoundaryType GetAssociatedSender(BoundaryType btype) {
   return btype;
 }
 
-enum class GridType : int { none, leaf, two_level_composite};
+enum class GridType : int { none, leaf, two_level_composite };
 class GridIdentifier {
   GridType type_ = GridType::none;
   int logical_level_ = 0; // Only meaningful for two_level_composite
@@ -123,15 +123,15 @@ class GridIdentifier {
   auto logical_level() const { return logical_level_; }
   auto multigrid_level() const { return multigrid_level_; }
   auto block_coarsenings() const { return block_coarsenings_; }
-  auto IsMultigrid() const { return is_multigrid_; }  
+  auto IsMultigrid() const { return is_multigrid_; }
 
   static GridIdentifier leaf() {
     auto out = GridIdentifier::leaf(-1, 0);
     out.is_multigrid_ = false;
     return out;
   }
 
-  static GridIdentifier leaf(int multigrid_level, std::size_t block_coarsenings) { 
+  static GridIdentifier leaf(int multigrid_level, std::size_t block_coarsenings) {
     GridIdentifier out;
     out.type_ = GridType::leaf;
     out.logical_level_ = -1111;
@@ -140,13 +140,14 @@ class GridIdentifier {
     out.is_multigrid_ = true;
     return out;
   }
-  
+
   static GridIdentifier none() {
     GridIdentifier out;
     return out;
   }
 
-  static GridIdentifier two_level_composite(int multigrid_level, int logical_level, std::size_t block_coarsenings) {
+  static GridIdentifier two_level_composite(int multigrid_level, int logical_level,
+                                            std::size_t block_coarsenings) {
     GridIdentifier out;
     out.type_ = GridType::two_level_composite;
     out.logical_level_ = logical_level;
@@ -160,15 +161,17 @@ class GridIdentifier {
     if (type_ == GridType::leaf) {
       return "GridType::leaf[" + std::to_string(block_coarsenings_) + "]";
     } else if (type_ == GridType::two_level_composite) {
-      return "GridType::two_level_composite[" + std::to_string(logical_level_) + ", " + std::to_string(block_coarsenings_) + "]";
+      return "GridType::two_level_composite[" + std::to_string(logical_level_) + ", " +
+             std::to_string(block_coarsenings_) + "]";
     }
     return "GridType::none";
   }
 };
 // Add a comparator so we can store in std::map
 inline bool operator<(const GridIdentifier &lhs, const GridIdentifier &rhs) {
   if (lhs.type() != rhs.type()) return lhs.type() < rhs.type();
-  if (lhs.block_coarsenings() != rhs.block_coarsenings()) return lhs.block_coarsenings() < rhs.block_coarsenings();
+  if (lhs.block_coarsenings() != rhs.block_coarsenings())
+    return lhs.block_coarsenings() < rhs.block_coarsenings();
   return lhs.logical_level() < rhs.logical_level();
 }
 

src/bvals/comms/bnd_info.cpp

@@ -107,16 +107,19 @@ GetFluxCorrectionElements(const std::shared_ptr<Variable<Real>> &v,
   return elements;
 }
 
-bool NeighborIsCoarser(MeshBlock *pmb, const NeighborBlock &nb) { 
-  return nb.loc.level() < pmb->loc.level() || nb.block_coarsenings > pmb->block_coarsenings; 
+bool NeighborIsCoarser(MeshBlock *pmb, const NeighborBlock &nb) {
+  return nb.loc.level() < pmb->loc.level() ||
+         nb.block_coarsenings > pmb->block_coarsenings;
 }
 
-bool NeighborIsFiner(MeshBlock *pmb, const NeighborBlock &nb) { 
-  return nb.loc.level() > pmb->loc.level() || nb.block_coarsenings < pmb->block_coarsenings; 
+bool NeighborIsFiner(MeshBlock *pmb, const NeighborBlock &nb) {
+  return nb.loc.level() > pmb->loc.level() ||
+         nb.block_coarsenings < pmb->block_coarsenings;
 }
 
-bool NeighborIsSame(MeshBlock *pmb, const NeighborBlock &nb) { 
-  return nb.loc.level() == pmb->loc.level() && nb.block_coarsenings == pmb->block_coarsenings;
+bool NeighborIsSame(MeshBlock *pmb, const NeighborBlock &nb) {
+  return nb.loc.level() == pmb->loc.level() &&
+         nb.block_coarsenings == pmb->block_coarsenings;
 }
 
 SpatiallyMaskedIndexer6D
@@ -135,7 +138,8 @@ CalcIndices(const NeighborBlock &nb, MeshBlock *pmb,
   const bool nb_is_coarser = NeighborIsCoarser(pmb, nb);
   const bool nb_is_finer = NeighborIsFiner(pmb, nb);
   const bool nb_is_same = NeighborIsSame(pmb, nb);
-  PARTHENON_REQUIRE(nb_is_coarser + nb_is_finer + nb_is_same == 1, "Only one should be set.");
+  PARTHENON_REQUIRE(nb_is_coarser + nb_is_finer + nb_is_same == 1,
+                    "Only one should be set.");
   // Both prolongation and restriction always operate in the coarse
   // index space. Also need to use the coarse index space if the
   // neighbor is coarser than you, wether or not you are setting
@@ -172,8 +176,7 @@ CalcIndices(const NeighborBlock &nb, MeshBlock *pmb,
   std::array<int, 3> block_offset = nb.offsets;
 
   int communicated_ghosts = Globals::nghost;
-  if (!prores && nb_is_same &&
-      v->IsSet(Metadata::CommunicateOne))
+  if (!prores && nb_is_same && v->IsSet(Metadata::CommunicateOne))
     communicated_ghosts = 1;
   int interior_offset =
       ir_type == IndexRangeType::BoundaryInteriorSend ? communicated_ghosts : 0;

src/bvals/comms/bvals_utils.hpp

@@ -42,10 +42,12 @@ inline auto &GetReceiverGid(Mesh::channel_key_t &key) { return std::get<1>(key);
 inline auto &GetVariable(Mesh::channel_key_t &key) { return std::get<2>(key); }
 inline auto &GetLocIdx(Mesh::channel_key_t &key) { return std::get<3>(key); }
 inline auto &GetOther(Mesh::channel_key_t &key) { return std::get<4>(key); }
-inline std::string GetLabel(Mesh::channel_key_t &key) { return "sender: " + std::to_string(GetSenderGid(key)) + ", receiver: " +
-                     std::to_string(GetReceiverGid(key)) + ", var: " + GetVariable(key) +
-                     ", location: " + std::to_string(GetLocIdx(key)) + ", other:" 
-                     + std::to_string(GetOther(key));}
+inline std::string GetLabel(Mesh::channel_key_t &key) {
+  return "sender: " + std::to_string(GetSenderGid(key)) +
+         ", receiver: " + std::to_string(GetReceiverGid(key)) +
+         ", var: " + GetVariable(key) + ", location: " + std::to_string(GetLocIdx(key)) +
+         ", other:" + std::to_string(GetOther(key));
+}
 inline Mesh::channel_key_t SendKey(const MeshBlock *pmb, const NeighborBlock &nb,
                                    const std::shared_ptr<Variable<Real>> &pcv,
                                    BoundaryType btype, int id) {
@@ -105,16 +107,17 @@ void InitializeBufferCache(std::shared_ptr<MeshData<Real>> &md, COMM_MAP *comm_m
   std::vector<std::tuple<int, int, Mesh::channel_key_t>> key_order;
 
   int boundary_idx = 0;
-  ForEachBoundary<bound_type>(md, [&](auto pmb, sp_mbd_t rc, const nb_t &nb, const sp_cv_t v) {
-    auto key = KeyFunc(pmb, nb, v, bound_type, md->GetBoundBufferId(bound_type));
-    PARTHENON_DEBUG_REQUIRE(comm_map->count(key) > 0,
-                            "Boundary communicator does not exist");
-    // Create a unique index by combining receiver gid (second element of the key
-    // tuple) and geometric element index (fourth element of the key tuple)
-    int recvr_idx = 27 * GetReceiverGid(key) + GetLocIdx(key);
-    key_order.push_back({recvr_idx, boundary_idx, key});
-    ++boundary_idx;
-  });
+  ForEachBoundary<bound_type>(
+      md, [&](auto pmb, sp_mbd_t rc, const nb_t &nb, const sp_cv_t v) {
+        auto key = KeyFunc(pmb, nb, v, bound_type, md->GetBoundBufferId(bound_type));
+        PARTHENON_DEBUG_REQUIRE(comm_map->count(key) > 0,
+                                "Boundary communicator does not exist");
+        // Create a unique index by combining receiver gid (second element of the key
+        // tuple) and geometric element index (fourth element of the key tuple)
+        int recvr_idx = 27 * GetReceiverGid(key) + GetLocIdx(key);
+        key_order.push_back({recvr_idx, boundary_idx, key});
+        ++boundary_idx;
+      });
 
   // If desired, sort the keys and boundary indices by receiver_idx
   // std::sort(key_order.begin(), key_order.end(),
@@ -132,8 +135,8 @@ void InitializeBufferCache(std::shared_ptr<MeshData<Real>> &md, COMM_MAP *comm_m
   std::for_each(std::begin(key_order), std::end(key_order), [&](auto &t) {
     if (comm_map->count(std::get<2>(t)) == 0) {
       auto key = std::get<2>(t);
-      PARTHENON_FAIL(std::string("Asking for buffer that doesn't exist") +
-                     " (" + GetLabel(key) + ")");
+      PARTHENON_FAIL(std::string("Asking for buffer that doesn't exist") + " (" +
+                     GetLabel(key) + ")");
     }
     pcache->buf_vec.push_back(&((*comm_map)[std::get<2>(t)]));
     (pcache->idx_vec)[std::get<1>(t)] = buff_idx++;

src/bvals/comms/tag_map.cpp

@@ -37,16 +37,18 @@ TagMap::rank_pair_t TagMap::MakeChannelPair(const MeshBlock *pmb,
 }
 
 template <BoundaryType BOUND>
-void TagMap::AddMeshDataToMap(std::shared_ptr<MeshData<Real>> &md, int channels_per_pair) {
+void TagMap::AddMeshDataToMap(std::shared_ptr<MeshData<Real>> &md,
+                              int channels_per_pair) {
   for (int block = 0; block < md->NumBlocks(); ++block) {
     auto &rc = md->GetBlockData(block);
     auto pmb = rc->GetBlockPointer();
     // type_t var = []{...}() pattern defines and uses a lambda that
     // returns  to reduce initializations of var
     const auto &neighbors = [&pmb, &md] {
       if constexpr (BOUND == BoundaryType::gmg_restrict_send)
-        return pmb->loc.level() == md->grid.logical_level() ? pmb->GetGMGCoarserNeighbors()
-                                                          : pmb->GetGMGSelfNeighbors();
+        return pmb->loc.level() == md->grid.logical_level()
+                   ? pmb->GetGMGCoarserNeighbors()
+                   : pmb->GetGMGSelfNeighbors();
       if constexpr (BOUND == BoundaryType::gmg_restrict_recv)
         return pmb->GetGMGFinerNeighbors().size() > 0 ? pmb->GetGMGFinerNeighbors()
                                                       : pmb->GetGMGSelfNeighbors();
@@ -55,8 +57,7 @@ void TagMap::AddMeshDataToMap(std::shared_ptr<MeshData<Real>> &md, int channels_
       if constexpr (BOUND == BoundaryType::gmg_prolongate_recv)
         return pmb->GetGMGCoarserNeighbors();
       if constexpr (BOUND == BoundaryType::gmg_same) {
-        if (md->grid.type() == GridType::leaf)
-          return pmb->GetNeighbors();
+        if (md->grid.type() == GridType::leaf) return pmb->GetNeighbors();
         return pmb->loc.level() == md->grid.logical_level()
                    ? pmb->GetGMGSameNeighbors()
                    : pmb->GetGMGCompositeFinerNeighbors();
@@ -76,7 +77,8 @@ void TagMap::AddMeshDataToMap(std::shared_ptr<MeshData<Real>> &md, int channels_
 template void
 TagMap::AddMeshDataToMap<BoundaryType::any>(std::shared_ptr<MeshData<Real>> &md, int);
 template void
-TagMap::AddMeshDataToMap<BoundaryType::gmg_same>(std::shared_ptr<MeshData<Real>> &md, int);
+TagMap::AddMeshDataToMap<BoundaryType::gmg_same>(std::shared_ptr<MeshData<Real>> &md,
+                                                 int);
 template void TagMap::AddMeshDataToMap<BoundaryType::gmg_prolongate_send>(
     std::shared_ptr<MeshData<Real>> &md, int);
 template void TagMap::AddMeshDataToMap<BoundaryType::gmg_restrict_send>(

src/bvals/comms/tag_map.hpp

@@ -78,7 +78,8 @@ class NeighborBlock;
 class TagMap {
   // Unique keys defined by a two-way communication channel
   using rank_pair_t = UnorderedPair<BlockGeometricElementId>;
-  // Map between a communication channel key (+ buffer id on that channel) and a unique MPI tag
+  // Map between a communication channel key (+ buffer id on that channel) and a unique
+  // MPI tag
   using rank_pair_map_t = std::map<std::pair<rank_pair_t, int>, int>;
   // Map of maps where the key corresponds to the MPI rank of the
   // other process

src/bvals/neighbor_block.cpp

@@ -43,10 +43,12 @@ NeighborBlock::NeighborBlock()
 
 NeighborBlock::NeighborBlock(Mesh *mesh, LogicalLocation loc, LogicalLocation origin_loc,
                              int rank, int gid, Kokkos::Array<int, 3> offsets_in, int bid,
-                             int target_id, int fi1, int fi2, std::size_t block_coarsenings)
+                             int target_id, int fi1, int fi2,
+                             std::size_t block_coarsenings)
     : rank{rank}, gid{gid}, bufid{bid}, targetid{target_id}, loc{loc},
-      origin_loc{origin_loc}, fi1{fi1}, fi2{fi2}, block_size(mesh->GetBlockSize(loc, block_coarsenings)),
-      offsets(offsets_in), ownership(true), block_coarsenings{block_coarsenings} {}
+      origin_loc{origin_loc}, fi1{fi1}, fi2{fi2},
+      block_size(mesh->GetBlockSize(loc, block_coarsenings)), offsets(offsets_in),
+      ownership(true), block_coarsenings{block_coarsenings} {}
 
 BufferID::BufferID(int dim, bool multilevel) {
   std::vector<int> x1offsets = dim > 0 ? std::vector<int>{0, -1, 1} : std::vector<int>{0};

src/interface/data_collection.cpp

@@ -50,16 +50,14 @@ template <>
 std::shared_ptr<MeshData<Real>> &
 DataCollection<MeshData<Real>>::GetOrAdd(const std::string &mbd_label,
                                          const int &partition_id) {
-  return Add(mbd_label,
-             pmy_mesh_->GetDefaultBlockPartitions()[partition_id]);
+  return Add(mbd_label, pmy_mesh_->GetDefaultBlockPartitions()[partition_id]);
 }
 
 template <>
 std::shared_ptr<MeshData<Real>> &
 DataCollection<MeshData<Real>>::GetOrAdd(int gmg_level, const std::string &mbd_label,
                                          const int &partition_id) {
-  return Add(mbd_label,
-             pmy_mesh_->GetMultigridBlockPartitions(gmg_level)[partition_id]);
+  return Add(mbd_label, pmy_mesh_->GetMultigridBlockPartitions(gmg_level)[partition_id]);
 }
 
 template <class T>

src/interface/mesh_data.cpp

@@ -29,7 +29,7 @@ void MeshData<T>::Initialize(BlockList_t blocks, Mesh *pmesh,
     if (pmesh) {
       grid = pmesh->GetGMGGrid(*gmg_level);
     } else {
-      PARTHENON_FAIL("Cannot initialize MeshData without Mesh."); 
+      PARTHENON_FAIL("Cannot initialize MeshData without Mesh.");
     }
   } else {
     grid = GridIdentifier::leaf();