diff --git a/.clang-format b/.clang-format
index 5708a4fb10..35c4e2b679 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,77 +1,98 @@
 ---
+Language: Cpp
+Standard: c++17
+DisableFormat:   false
 AccessModifierOffset: -4
 AlignAfterOpenBracket: AlwaysBreak
 AlignConsecutiveAssignments: false
+#AlignConsecutiveBitFields: false
 AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: DontAlign
-AlignOperands: false
+AlignConsecutiveMacros: false
+AlignEscapedNewlines: Right
+AlignOperands: false #DontAlign
 AlignTrailingComments: false
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
 AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: false
+AllowShortBlocksOnASingleLine: Never
 AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Empty
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: true
+#AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakBeforeMultilineStrings: false
 AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: false
 BinPackParameters: false
-BreakBeforeBraces: Custom
-BraceWrapping:
-  AfterClass: true
-  AfterControlStatement: true
-  AfterEnum: true
-  AfterFunction: true
-  AfterNamespace: true
-  AfterStruct: true
-  AfterUnion: true
-  AfterExternBlock: true
-  BeforeCatch: true
-  BeforeElse: true
-  IndentBraces: false
-  SplitEmptyFunction: false
-  SplitEmptyRecord: false
-  SplitEmptyNamespace: false
+#BitFieldColonSpacing: Both
 BreakBeforeBinaryOperators: All
+BreakBeforeBraces: Allman
 BreakBeforeTernaryOperators: true
-BreakConstructorInitializers: AfterColon
-BreakInheritanceList: AfterColon
+BreakConstructorInitializers: BeforeComma
+BreakInheritanceList: BeforeComma
 BreakStringLiterals: true
-ColumnLimit: 80
+ColumnLimit:     120
+CommentPragmas:  '^ COMMENT pragma:'
 CompactNamespaces: false
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
-ConstructorInitializerIndentWidth: 8
+ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
+DeriveLineEnding: false
 DerivePointerAlignment: false
-FixNamespaceComments: false
-IncludeBlocks: Regroup
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+IncludeBlocks:   Regroup
+IncludeCategories:
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+#IndentCaseBlocks: true
 IndentCaseLabels: false
-IndentPPDirectives: None
+#IndentExternBlock: AfterExternBlock
+IndentGotoLabels: true
+IndentPPDirectives: AfterHash
 IndentWidth: 4
 IndentWrappedFunctionNames: false
 KeepEmptyLinesAtTheStartOfBlocks: false
-Language: Cpp
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 2
 NamespaceIndentation: All
-PointerAlignment: Middle
+#OperandAlignmentStyle: Align
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 1000
+PointerAlignment: Left
 ReflowComments: true
 SortIncludes: true
 SortUsingDeclarations: true
-SpaceAfterCStyleCast: false
-SpaceAfterTemplateKeyword: false
+SpaceAfterCStyleCast: true
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
 SpaceBeforeAssignmentOperators: true
-SpaceBeforeCpp11BracedList: false
+SpaceBeforeCpp11BracedList: true
 SpaceBeforeCtorInitializerColon: true
 SpaceBeforeInheritanceColon: true
-SpaceBeforeParens: Never
+SpaceBeforeParens: ControlStatements
 SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
 SpaceInEmptyParentheses: false
-SpacesInAngles: false
-SpacesInCStyleCastParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInConditionalStatement: false
 SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard: Cpp11
+SpaceBeforeSquareBrackets: false
+TabWidth: 4
+UseCRLF: false
 UseTab: Never
 ...
diff --git a/examples/alpaka/asyncblur/asyncblur.cpp b/examples/alpaka/asyncblur/asyncblur.cpp
index 7feef248c0..54aacca63a 100644
--- a/examples/alpaka/asyncblur/asyncblur.cpp
+++ b/examples/alpaka/asyncblur/asyncblur.cpp
@@ -26,34 +26,25 @@
 #include <random>
 #include <utility>
 
-constexpr auto ASYNC
-    = true; ///< defines whether the data shall be processed asynchronously
+constexpr auto ASYNC = true; ///< defines whether the data shall be processed asynchronously
 constexpr auto SHARED = true; ///< defines whether shared memory shall be used
-constexpr auto SAVE
-    = true; ///< defines whether the resultion image shall be saved
+constexpr auto SAVE = true; ///< defines whether the resultion image shall be saved
 constexpr auto CHUNK_COUNT = 4;
 
-constexpr auto DEFAULT_IMG_X
-    = 4096; /// width of the default image if no png is loaded
-constexpr auto DEFAULT_IMG_Y
-    = 4096; /// height of the default image if no png is loaded
-constexpr auto KERNEL_SIZE
-    = 8; /// radius of the blur kernel, the diameter is this times two plus one
-constexpr auto CHUNK_SIZE
-    = 512; /// size of each chunk to be processed per alpaka kernel
-constexpr auto ELEMS_PER_BLOCK
-    = 16; /// number of elements per direction(!) every block should process
+constexpr auto DEFAULT_IMG_X = 4096; /// width of the default image if no png is loaded
+constexpr auto DEFAULT_IMG_Y = 4096; /// height of the default image if no png is loaded
+constexpr auto KERNEL_SIZE = 8; /// radius of the blur kernel, the diameter is this times two plus one
+constexpr auto CHUNK_SIZE = 512; /// size of each chunk to be processed per alpaka kernel
+constexpr auto ELEMS_PER_BLOCK = 16; /// number of elements per direction(!) every block should process
 
 using FP = float;
 
-template<typename Mapping, typename AlpakaBuffer>
+template <typename Mapping, typename AlpakaBuffer>
 auto viewAlpakaBuffer(
-    Mapping & mapping,
-    AlpakaBuffer &
-        buffer) // taking mapping by & on purpose, so Mapping can deduce const
+    Mapping& mapping,
+    AlpakaBuffer& buffer) // taking mapping by & on purpose, so Mapping can deduce const
 {
-    return llama::View<Mapping, std::byte *>{
-        mapping, {alpaka::mem::view::getPtrNative(buffer)}};
+    return llama::View<Mapping, std::byte*> {mapping, {alpaka::mem::view::getPtrNative(buffer)}};
 }
 
 // clang-format off
@@ -80,101 +71,79 @@ using PixelOnAcc = llama::DS<
 /** Alpaka kernel functor used to blur a small image living in the device memory
  *  using the \ref PixelOnAcc datum domain
  */
-template<std::size_t Elems, std::size_t KernelSize, std::size_t ElemsPerBlock>
+template <std::size_t Elems, std::size_t KernelSize, std::size_t ElemsPerBlock>
 struct BlurKernel
 {
-    template<typename Acc, typename View>
-    LLAMA_FN_HOST_ACC_INLINE void
-    operator()(const Acc & acc, View oldImage, View newImage) const
+    template <typename Acc, typename View>
+    LLAMA_FN_HOST_ACC_INLINE void operator()(const Acc& acc, View oldImage, View newImage) const
     {
         const auto ti = alpaka::idx::getIdx<alpaka::Grid, alpaka::Threads>(acc);
 
         [[maybe_unused]] auto sharedView = [&] {
-            if constexpr(SHARED)
+            if constexpr (SHARED)
             {
                 // Using SoA for the shared memory
                 constexpr auto sharedChunkSize = ElemsPerBlock + 2 * KernelSize;
                 const auto sharedMapping = llama::mapping::tree::Mapping(
-                    typename View::UserDomain{sharedChunkSize, sharedChunkSize},
-                    llama::Tuple{llama::mapping::tree::functor::LeafOnlyRT()},
-                    typename View::DatumDomain{});
-                constexpr auto sharedMemSize
-                    = llama::sizeOf<PixelOnAcc> * sharedChunkSize
-                    * sharedChunkSize;
-                auto & sharedMem = alpaka::block::shared::st::
-                    allocVar<std::byte[sharedMemSize], __COUNTER__>(acc);
-                return llama::View{sharedMapping, llama::Array{&sharedMem[0]}};
+                    typename View::UserDomain {sharedChunkSize, sharedChunkSize},
+                    llama::Tuple {llama::mapping::tree::functor::LeafOnlyRT()},
+                    typename View::DatumDomain {});
+                constexpr auto sharedMemSize = llama::sizeOf<PixelOnAcc> * sharedChunkSize * sharedChunkSize;
+                auto& sharedMem = alpaka::block::shared::st::allocVar<std::byte[sharedMemSize], __COUNTER__>(acc);
+                return llama::View {sharedMapping, llama::Array {&sharedMem[0]}};
             }
             else
-                return int{}; // dummy
+                return int {}; // dummy
         }();
 
-        [[maybe_unused]] const auto bi
-            = alpaka::idx::getIdx<alpaka::Grid, alpaka::Blocks>(acc);
-        if constexpr(SHARED)
+        [[maybe_unused]] const auto bi = alpaka::idx::getIdx<alpaka::Grid, alpaka::Blocks>(acc);
+        if constexpr (SHARED)
         {
             constexpr auto threadsPerBlock = ElemsPerBlock / Elems;
-            const auto threadIdxInBlock
-                = alpaka::idx::getIdx<alpaka::Block, alpaka::Threads>(acc);
+            const auto threadIdxInBlock = alpaka::idx::getIdx<alpaka::Block, alpaka::Threads>(acc);
 
             const std::size_t bStart[2]
-                = {bi[0] * ElemsPerBlock + threadIdxInBlock[0],
-                   bi[1] * ElemsPerBlock + threadIdxInBlock[1]};
+                = {bi[0] * ElemsPerBlock + threadIdxInBlock[0], bi[1] * ElemsPerBlock + threadIdxInBlock[1]};
             const std::size_t bEnd[2] = {
-                alpaka::math::min(
-                    acc,
-                    bStart[0] + ElemsPerBlock + 2 * KernelSize,
-                    oldImage.mapping.userDomainSize[0]),
-                alpaka::math::min(
-                    acc,
-                    bStart[1] + ElemsPerBlock + 2 * KernelSize,
-                    oldImage.mapping.userDomainSize[1]),
+                alpaka::math::min(acc, bStart[0] + ElemsPerBlock + 2 * KernelSize, oldImage.mapping.userDomainSize[0]),
+                alpaka::math::min(acc, bStart[1] + ElemsPerBlock + 2 * KernelSize, oldImage.mapping.userDomainSize[1]),
             };
             LLAMA_INDEPENDENT_DATA
-            for(auto y = bStart[0]; y < bEnd[0]; y += threadsPerBlock)
+            for (auto y = bStart[0]; y < bEnd[0]; y += threadsPerBlock)
                 LLAMA_INDEPENDENT_DATA
-            for(auto x = bStart[1]; x < bEnd[1]; x += threadsPerBlock)
-                sharedView(y - bi[0] * ElemsPerBlock, x - bi[1] * ElemsPerBlock)
-                    = oldImage(y, x);
+            for (auto x = bStart[1]; x < bEnd[1]; x += threadsPerBlock)
+                sharedView(y - bi[0] * ElemsPerBlock, x - bi[1] * ElemsPerBlock) = oldImage(y, x);
 
             alpaka::block::sync::syncBlockThreads(acc);
         }
 
         const std::size_t start[2] = {ti[0] * Elems, ti[1] * Elems};
         const std::size_t end[2] = {
-            alpaka::math::min(
-                acc,
-                start[0] + Elems,
-                oldImage.mapping.userDomainSize[0] - 2 * KernelSize),
-            alpaka::math::min(
-                acc,
-                start[1] + Elems,
-                oldImage.mapping.userDomainSize[1] - 2 * KernelSize),
+            alpaka::math::min(acc, start[0] + Elems, oldImage.mapping.userDomainSize[0] - 2 * KernelSize),
+            alpaka::math::min(acc, start[1] + Elems, oldImage.mapping.userDomainSize[1] - 2 * KernelSize),
         };
 
         LLAMA_INDEPENDENT_DATA
-        for(auto y = start[0]; y < end[0]; ++y) LLAMA_INDEPENDENT_DATA
-        for(auto x = start[1]; x < end[1]; ++x)
+        for (auto y = start[0]; y < end[0]; ++y)
+            LLAMA_INDEPENDENT_DATA
+        for (auto x = start[1]; x < end[1]; ++x)
         {
             auto sum = llama::allocVirtualDatumStack<PixelOnAcc>();
             sum = 0;
 
             using ItType = long int;
-            const ItType iBStart
-                = SHARED ? ItType(y) - ItType(bi[0] * ElemsPerBlock) : y;
-            const ItType iAStart
-                = SHARED ? ItType(x) - ItType(bi[1] * ElemsPerBlock) : x;
-            const ItType i_b_end = SHARED
-                ? ItType(y + 2 * KernelSize + 1) - ItType(bi[0] * ElemsPerBlock)
-                : y + 2 * KernelSize + 1;
-            const ItType i_a_end = SHARED
-                ? ItType(x + 2 * KernelSize + 1) - ItType(bi[1] * ElemsPerBlock)
-                : x + 2 * KernelSize + 1;
+            const ItType iBStart = SHARED ? ItType(y) - ItType(bi[0] * ElemsPerBlock) : y;
+            const ItType iAStart = SHARED ? ItType(x) - ItType(bi[1] * ElemsPerBlock) : x;
+            const ItType i_b_end
+                = SHARED ? ItType(y + 2 * KernelSize + 1) - ItType(bi[0] * ElemsPerBlock) : y + 2 * KernelSize + 1;
+            const ItType i_a_end
+                = SHARED ? ItType(x + 2 * KernelSize + 1) - ItType(bi[1] * ElemsPerBlock) : x + 2 * KernelSize + 1;
             LLAMA_INDEPENDENT_DATA
-            for(auto b = iBStart; b < i_b_end; ++b) LLAMA_INDEPENDENT_DATA
-            for(auto a = iAStart; a < i_a_end; ++a)
+            for (auto b = iBStart; b < i_b_end; ++b)
+                LLAMA_INDEPENDENT_DATA
+            for (auto a = iAStart; a < i_a_end; ++a)
             {
-                if constexpr(SHARED)
+                if constexpr (SHARED)
                     sum += sharedView(std::size_t(b), std::size_t(a));
                 else
                     sum += oldImage(std::size_t(b), std::size_t(a));
@@ -185,7 +154,7 @@ struct BlurKernel
     }
 };
 
-int main(int argc, char ** argv)
+int main(int argc, char** argv)
 {
     // ALPAKA
     using Dim = alpaka::dim::DimInt<2>;
@@ -194,12 +163,8 @@ int main(int argc, char ** argv)
     // using Acc = alpaka::acc::AccGpuCudaRt<Dim, Size>;
     // using Acc = alpaka::acc::AccCpuSerial<Dim, Size>;
 
-    using Queue = alpaka::queue::Queue<
-        Acc,
-        std::conditional_t<
-            ASYNC,
-            alpaka::queue::NonBlocking,
-            alpaka::queue::Blocking>>;
+    using Queue
+        = alpaka::queue::Queue<Acc, std::conditional_t<ASYNC, alpaka::queue::NonBlocking, alpaka::queue::Blocking>>;
     using DevHost = alpaka::dev::DevCpu;
     using DevAcc = alpaka::dev::Dev<Acc>;
     using PltfHost = alpaka::pltf::Pltf<DevHost>;
@@ -207,7 +172,8 @@ int main(int argc, char ** argv)
     const DevAcc devAcc = alpaka::pltf::getDevByIdx<PltfAcc>(0);
     const DevHost devHost = alpaka::pltf::getDevByIdx<PltfHost>(0);
     std::vector<Queue> queue;
-    for(std::size_t i = 0; i < CHUNK_COUNT; ++i) queue.push_back(Queue(devAcc));
+    for (std::size_t i = 0; i < CHUNK_COUNT; ++i)
+        queue.push_back(Queue(devAcc));
 
     // ASYNCCOPY
     std::size_t img_x = DEFAULT_IMG_X;
@@ -216,20 +182,19 @@ int main(int argc, char ** argv)
     std::size_t buffer_y = DEFAULT_IMG_Y + 2 * KERNEL_SIZE;
 
     constexpr std::size_t hardwareThreads = 2; // relevant for OpenMP2Threads
-    using Distribution = common::
-        ThreadsElemsDistribution<Acc, ELEMS_PER_BLOCK, hardwareThreads>;
+    using Distribution = common::ThreadsElemsDistribution<Acc, ELEMS_PER_BLOCK, hardwareThreads>;
     constexpr std::size_t elemCount = Distribution::elemCount;
     constexpr std::size_t threadCount = Distribution::threadCount;
 
     std::vector<unsigned char> image;
     std::string out_filename = "output.png";
 
-    if(argc > 1)
+    if (argc > 1)
     {
         int x = 0;
         int y = 0;
         int n = 3;
-        unsigned char * data = stbi_load(argv[1], &x, &y, &n, 0);
+        unsigned char* data = stbi_load(argv[1], &x, &y, &n, 0);
         image.resize(x * y * 3);
         std::copy(data, data + image.size(), begin(image));
         stbi_image_free(data);
@@ -238,21 +203,20 @@ int main(int argc, char ** argv)
         buffer_x = x + 2 * KERNEL_SIZE;
         buffer_y = y + 2 * KERNEL_SIZE;
 
-        if(argc > 2)
+        if (argc > 2)
             out_filename = std::string(argv[2]);
     }
 
     // LLAMA
     using UserDomain = llama::UserDomain<2>;
 
-    auto treeOperationList
-        = llama::Tuple{llama::mapping::tree::functor::LeafOnlyRT()};
-    const auto hostMapping = llama::mapping::tree::Mapping{
-        UserDomain{buffer_y, buffer_x}, treeOperationList, Pixel{}};
-    const auto devMapping = llama::mapping::tree::Mapping{
-        UserDomain{CHUNK_SIZE + 2 * KERNEL_SIZE, CHUNK_SIZE + 2 * KERNEL_SIZE},
+    auto treeOperationList = llama::Tuple {llama::mapping::tree::functor::LeafOnlyRT()};
+    const auto hostMapping
+        = llama::mapping::tree::Mapping {UserDomain {buffer_y, buffer_x}, treeOperationList, Pixel {}};
+    const auto devMapping = llama::mapping::tree::Mapping {
+        UserDomain {CHUNK_SIZE + 2 * KERNEL_SIZE, CHUNK_SIZE + 2 * KERNEL_SIZE},
         treeOperationList,
-        PixelOnAcc{}};
+        PixelOnAcc {}};
 
     const auto hostBufferSize = hostMapping.getBlobSize(0);
     const auto devBufferSize = devMapping.getBlobSize(0);
@@ -262,50 +226,39 @@ int main(int argc, char ** argv)
 
     Chrono chrono;
 
-    auto hostBuffer = alpaka::mem::buf::alloc<std::byte, std::size_t>(
-        devHost, hostBufferSize);
+    auto hostBuffer = alpaka::mem::buf::alloc<std::byte, std::size_t>(devHost, hostBufferSize);
     auto hostView = viewAlpakaBuffer(hostMapping, hostBuffer);
 
-    std::vector<
-        alpaka::mem::buf::
-            Buf<DevHost, std::byte, alpaka::dim::DimInt<1>, std::size_t>>
-        hostChunkBuffer;
-    std::vector<llama::View<decltype(devMapping), std::byte *>> hostChunkView;
+    std::vector<alpaka::mem::buf::Buf<DevHost, std::byte, alpaka::dim::DimInt<1>, std::size_t>> hostChunkBuffer;
+    std::vector<llama::View<decltype(devMapping), std::byte*>> hostChunkView;
 
-    std::vector<alpaka::mem::buf::
-                    Buf<DevAcc, std::byte, alpaka::dim::DimInt<1>, std::size_t>>
-        devOldBuffer, devNewBuffer;
-    std::vector<llama::View<decltype(devMapping), std::byte *>> devOldView,
-        devNewView;
+    std::vector<alpaka::mem::buf::Buf<DevAcc, std::byte, alpaka::dim::DimInt<1>, std::size_t>> devOldBuffer,
+        devNewBuffer;
+    std::vector<llama::View<decltype(devMapping), std::byte*>> devOldView, devNewView;
 
-    for(std::size_t i = 0; i < CHUNK_COUNT; ++i)
+    for (std::size_t i = 0; i < CHUNK_COUNT; ++i)
     {
-        hostChunkBuffer.push_back(
-            alpaka::mem::buf::alloc<std::byte, std::size_t>(
-                devHost, devBufferSize));
-        hostChunkView.push_back(
-            viewAlpakaBuffer(devMapping, hostChunkBuffer.back()));
-
-        devOldBuffer.push_back(alpaka::mem::buf::alloc<std::byte, std::size_t>(
-            devAcc, devBufferSize));
+        hostChunkBuffer.push_back(alpaka::mem::buf::alloc<std::byte, std::size_t>(devHost, devBufferSize));
+        hostChunkView.push_back(viewAlpakaBuffer(devMapping, hostChunkBuffer.back()));
+
+        devOldBuffer.push_back(alpaka::mem::buf::alloc<std::byte, std::size_t>(devAcc, devBufferSize));
         devOldView.push_back(viewAlpakaBuffer(devMapping, devOldBuffer.back()));
 
-        devNewBuffer.push_back(alpaka::mem::buf::alloc<std::byte, std::size_t>(
-            devAcc, devBufferSize));
+        devNewBuffer.push_back(alpaka::mem::buf::alloc<std::byte, std::size_t>(devAcc, devBufferSize));
         devNewView.push_back(viewAlpakaBuffer(devMapping, devNewBuffer.back()));
     }
 
     chrono.printAndReset("Alloc");
 
-    if(image.empty())
+    if (image.empty())
     {
         image.resize(img_x * img_y * 3);
         std::default_random_engine generator;
-        std::normal_distribution<FP> distribution{FP(0), FP(0.5)};
-        for(std::size_t y = 0; y < buffer_y; ++y)
+        std::normal_distribution<FP> distribution {FP(0), FP(0.5)};
+        for (std::size_t y = 0; y < buffer_y; ++y)
         {
             LLAMA_INDEPENDENT_DATA
-            for(std::size_t x = 0; x < buffer_x; ++x)
+            for (std::size_t x = 0; x < buffer_x; ++x)
             {
                 hostView(y, x)(tag::R()) = std::abs(distribution(generator));
                 hostView(y, x)(tag::G()) = std::abs(distribution(generator));
@@ -315,17 +268,14 @@ int main(int argc, char ** argv)
     }
     else
     {
-        for(std::size_t y = 0; y < buffer_y; ++y)
+        for (std::size_t y = 0; y < buffer_y; ++y)
         {
             LLAMA_INDEPENDENT_DATA
-            for(std::size_t x = 0; x < buffer_x; ++x)
+            for (std::size_t x = 0; x < buffer_x; ++x)
             {
-                const auto X = std::clamp<std::size_t>(
-                    x, KERNEL_SIZE, img_x + KERNEL_SIZE - 1);
-                const auto Y = std::clamp<std::size_t>(
-                    y, KERNEL_SIZE, img_y + KERNEL_SIZE - 1);
-                const auto * pixel
-                    = &image[((Y - KERNEL_SIZE) * img_x + X - KERNEL_SIZE) * 3];
+                const auto X = std::clamp<std::size_t>(x, KERNEL_SIZE, img_x + KERNEL_SIZE - 1);
+                const auto Y = std::clamp<std::size_t>(y, KERNEL_SIZE, img_y + KERNEL_SIZE - 1);
+                const auto* pixel = &image[((Y - KERNEL_SIZE) * img_x + X - KERNEL_SIZE) * 3];
                 hostView(y, x)(tag::R()) = FP(pixel[0]) / 255.;
                 hostView(y, x)(tag::G()) = FP(pixel[1]) / 255.;
                 hostView(y, x)(tag::B()) = FP(pixel[2]) / 255.;
@@ -335,19 +285,15 @@ int main(int argc, char ** argv)
 
     chrono.printAndReset("Init");
     const auto elems = alpaka::vec::Vec<Dim, size_t>(elemCount, elemCount);
-    const auto threads
-        = alpaka::vec::Vec<Dim, size_t>(threadCount, threadCount);
+    const auto threads = alpaka::vec::Vec<Dim, size_t>(threadCount, threadCount);
     const auto blocks = alpaka::vec::Vec<Dim, size_t>(
-        static_cast<size_t>(
-            (CHUNK_SIZE + ELEMS_PER_BLOCK - 1) / ELEMS_PER_BLOCK),
-        static_cast<size_t>(
-            (CHUNK_SIZE + ELEMS_PER_BLOCK - 1) / ELEMS_PER_BLOCK));
+        static_cast<size_t>((CHUNK_SIZE + ELEMS_PER_BLOCK - 1) / ELEMS_PER_BLOCK),
+        static_cast<size_t>((CHUNK_SIZE + ELEMS_PER_BLOCK - 1) / ELEMS_PER_BLOCK));
     const alpaka::vec::Vec<Dim, size_t> chunks(
         static_cast<size_t>((img_y + CHUNK_SIZE - 1) / CHUNK_SIZE),
         static_cast<size_t>((img_x + CHUNK_SIZE - 1) / CHUNK_SIZE));
 
-    const auto workdiv
-        = alpaka::workdiv::WorkDivMembers<Dim, size_t>{blocks, threads, elems};
+    const auto workdiv = alpaka::workdiv::WorkDivMembers<Dim, size_t> {blocks, threads, elems};
 
     struct VirtualHostElement
     {
@@ -355,106 +301,79 @@ int main(int argc, char ** argv)
         const UserDomain validMiniSize;
     };
     std::list<VirtualHostElement> virtualHostList;
-    for(std::size_t chunk_y = 0; chunk_y < chunks[0]; ++chunk_y)
-        for(std::size_t chunk_x = 0; chunk_x < chunks[1]; ++chunk_x)
+    for (std::size_t chunk_y = 0; chunk_y < chunks[0]; ++chunk_y)
+        for (std::size_t chunk_x = 0; chunk_x < chunks[1]; ++chunk_x)
         {
             // Create virtual view with size of mini view
-            const UserDomain validMiniSize{
-                ((chunk_y < chunks[0] - 1) ? CHUNK_SIZE
-                                           : (img_y - 1) % CHUNK_SIZE + 1)
-                    + 2 * KERNEL_SIZE,
-                ((chunk_x < chunks[1] - 1) ? CHUNK_SIZE
-                                           : (img_x - 1) % CHUNK_SIZE + 1)
-                    + 2 * KERNEL_SIZE};
-            llama::VirtualView virtualHost(
-                hostView,
-                {chunk_y * CHUNK_SIZE, chunk_x * CHUNK_SIZE},
-                validMiniSize);
+            const UserDomain validMiniSize {
+                ((chunk_y < chunks[0] - 1) ? CHUNK_SIZE : (img_y - 1) % CHUNK_SIZE + 1) + 2 * KERNEL_SIZE,
+                ((chunk_x < chunks[1] - 1) ? CHUNK_SIZE : (img_x - 1) % CHUNK_SIZE + 1) + 2 * KERNEL_SIZE};
+            llama::VirtualView virtualHost(hostView, {chunk_y * CHUNK_SIZE, chunk_x * CHUNK_SIZE}, validMiniSize);
 
             // Find free chunk stream
             std::size_t chunkNr = virtualHostList.size();
-            if(virtualHostList.size() < CHUNK_COUNT)
+            if (virtualHostList.size() < CHUNK_COUNT)
                 virtualHostList.push_back({virtualHost, validMiniSize});
             else
             {
                 bool notFound = true;
-                while(notFound)
+                while (notFound)
                 {
                     auto chunkIt = virtualHostList.begin();
-                    for(chunkNr = 0; chunkNr < CHUNK_COUNT; ++chunkNr)
+                    for (chunkNr = 0; chunkNr < CHUNK_COUNT; ++chunkNr)
                     {
-                        if(alpaka::queue::empty(queue[chunkNr]))
+                        if (alpaka::queue::empty(queue[chunkNr]))
                         {
                             // Copy data back
                             LLAMA_INDEPENDENT_DATA
-                            for(std::size_t y = 0;
-                                y < chunkIt->validMiniSize[0] - 2 * KERNEL_SIZE;
-                                ++y)
+                            for (std::size_t y = 0; y < chunkIt->validMiniSize[0] - 2 * KERNEL_SIZE; ++y)
                             {
                                 LLAMA_INDEPENDENT_DATA
-                                for(std::size_t x = 0;
-                                    x < chunkIt->validMiniSize[1]
-                                        - 2 * KERNEL_SIZE;
-                                    ++x)
-                                    chunkIt->virtualHost(
-                                        y + KERNEL_SIZE, x + KERNEL_SIZE)
-                                        = hostChunkView[chunkNr](
-                                            y + KERNEL_SIZE, x + KERNEL_SIZE);
+                                for (std::size_t x = 0; x < chunkIt->validMiniSize[1] - 2 * KERNEL_SIZE; ++x)
+                                    chunkIt->virtualHost(y + KERNEL_SIZE, x + KERNEL_SIZE)
+                                        = hostChunkView[chunkNr](y + KERNEL_SIZE, x + KERNEL_SIZE);
                             }
                             chunkIt = virtualHostList.erase(chunkIt);
-                            virtualHostList.insert(
-                                chunkIt, {virtualHost, validMiniSize});
+                            virtualHostList.insert(chunkIt, {virtualHost, validMiniSize});
                             notFound = false;
                             break;
                         }
                         chunkIt++;
                     }
-                    if(notFound)
-                        std::this_thread::sleep_for(
-                            std::chrono::microseconds{1});
+                    if (notFound)
+                        std::this_thread::sleep_for(std::chrono::microseconds {1});
                 }
             }
 
             // Copy data from virtual view to mini view
-            for(std::size_t y = 0; y < validMiniSize[0]; ++y)
+            for (std::size_t y = 0; y < validMiniSize[0]; ++y)
             {
                 LLAMA_INDEPENDENT_DATA
-                for(std::size_t x = 0; x < validMiniSize[1]; ++x)
+                for (std::size_t x = 0; x < validMiniSize[1]; ++x)
                     hostChunkView[chunkNr](y, x) = virtualHost(y, x);
             }
-            alpaka::mem::view::copy(
-                queue[chunkNr],
-                devOldBuffer[chunkNr],
-                hostChunkBuffer[chunkNr],
-                devBufferSize);
+            alpaka::mem::view::copy(queue[chunkNr], devOldBuffer[chunkNr], hostChunkBuffer[chunkNr], devBufferSize);
 
             alpaka::kernel::exec<Acc>(
                 queue[chunkNr],
                 workdiv,
-                BlurKernel<elemCount, KERNEL_SIZE, ELEMS_PER_BLOCK>{},
+                BlurKernel<elemCount, KERNEL_SIZE, ELEMS_PER_BLOCK> {},
                 devOldView[chunkNr],
                 devNewView[chunkNr]);
 
-            alpaka::mem::view::copy(
-                queue[chunkNr],
-                hostChunkBuffer[chunkNr],
-                devNewBuffer[chunkNr],
-                devBufferSize);
+            alpaka::mem::view::copy(queue[chunkNr], hostChunkBuffer[chunkNr], devNewBuffer[chunkNr], devBufferSize);
         }
 
     // Wait for not finished tasks on accelerator
     auto chunkIt = virtualHostList.begin();
-    for(std::size_t chunkNr = 0; chunkNr < CHUNK_COUNT; ++chunkNr)
+    for (std::size_t chunkNr = 0; chunkNr < CHUNK_COUNT; ++chunkNr)
     {
         alpaka::wait::wait(queue[chunkNr]);
         // Copy data back
-        for(std::size_t y = 0; y < chunkIt->validMiniSize[0] - 2 * KERNEL_SIZE;
-            ++y)
+        for (std::size_t y = 0; y < chunkIt->validMiniSize[0] - 2 * KERNEL_SIZE; ++y)
         {
             LLAMA_INDEPENDENT_DATA
-            for(std::size_t x = 0;
-                x < chunkIt->validMiniSize[1] - 2 * KERNEL_SIZE;
-                ++x)
+            for (std::size_t x = 0; x < chunkIt->validMiniSize[1] - 2 * KERNEL_SIZE; ++x)
                 chunkIt->virtualHost(y + KERNEL_SIZE, x + KERNEL_SIZE)
                     = hostChunkView[chunkNr](y + KERNEL_SIZE, x + KERNEL_SIZE);
         }
@@ -462,20 +381,17 @@ int main(int argc, char ** argv)
     }
     chrono.printAndReset("Blur kernel");
 
-    if(SAVE)
+    if (SAVE)
     {
-        for(std::size_t y = 0; y < img_y; ++y)
+        for (std::size_t y = 0; y < img_y; ++y)
         {
             LLAMA_INDEPENDENT_DATA
-            for(std::size_t x = 0; x < img_x; ++x)
+            for (std::size_t x = 0; x < img_x; ++x)
             {
-                auto * pixel = &image[(y * img_x + x) * 3];
-                pixel[0] = hostView(y + KERNEL_SIZE, x + KERNEL_SIZE)(tag::R())
-                    * 255.;
-                pixel[1] = hostView(y + KERNEL_SIZE, x + KERNEL_SIZE)(tag::G())
-                    * 255.;
-                pixel[2] = hostView(y + KERNEL_SIZE, x + KERNEL_SIZE)(tag::B())
-                    * 255.;
+                auto* pixel = &image[(y * img_x + x) * 3];
+                pixel[0] = hostView(y + KERNEL_SIZE, x + KERNEL_SIZE)(tag::R()) * 255.;
+                pixel[1] = hostView(y + KERNEL_SIZE, x + KERNEL_SIZE)(tag::G()) * 255.;
+                pixel[2] = hostView(y + KERNEL_SIZE, x + KERNEL_SIZE)(tag::B()) * 255.;
             }
         }
         stbi_write_png(out_filename.c_str(), img_x, img_y, 3, image.data(), 0);
diff --git a/examples/alpaka/nbody/nbody.cpp b/examples/alpaka/nbody/nbody.cpp
index 62599112e8..3e1f94b408 100644
--- a/examples/alpaka/nbody/nbody.cpp
+++ b/examples/alpaka/nbody/nbody.cpp
@@ -16,13 +16,10 @@
 #include <random>
 #include <utility>
 
-constexpr auto MAPPING
-    = 0; /// 0 native AoS, 1 native SoA, 2 tree AoS, 3 tree SoA
-constexpr auto USE_SHARED
-    = true; ///< defines whether shared memory shall be used
-constexpr auto USE_SHARED_TREE
-    = true; ///< defines whether the shared memory shall use tree mapping or
-            ///< native mapping
+constexpr auto MAPPING = 0; /// 0 native AoS, 1 native SoA, 2 tree AoS, 3 tree SoA
+constexpr auto USE_SHARED = true; ///< defines whether shared memory shall be used
+constexpr auto USE_SHARED_TREE = true; ///< defines whether the shared memory shall use tree mapping or
+                                       ///< native mapping
 
 constexpr auto PROBLEM_SIZE = 16 * 1024; ///< total number of particles
 constexpr auto BLOCK_SIZE = 256; ///< number of elements per block
@@ -56,15 +53,13 @@ using Particle = llama::DS<
 
 /// Helper function for particle particle interaction. Gets two virtual
 /// datums like they are real particle objects
-template<typename VirtualDatum1, typename VirtualDatum2>
-LLAMA_FN_HOST_ACC_INLINE void
-pPInteraction(VirtualDatum1 p1, VirtualDatum2 p2, FP ts)
+template <typename VirtualDatum1, typename VirtualDatum2>
+LLAMA_FN_HOST_ACC_INLINE void pPInteraction(VirtualDatum1 p1, VirtualDatum2 p2, FP ts)
 {
     // Creating tempory virtual datum object for distance on stack:
     auto distance = p1(tag::Pos()) + p2(tag::Pos());
     distance *= distance; // square for each element
-    const FP distSqr
-        = EPS2 + distance(tag::X()) + distance(tag::Y()) + distance(tag::Z());
+    const FP distSqr = EPS2 + distance(tag::X()) + distance(tag::Y()) + distance(tag::Z());
     const FP distSixth = distSqr * distSqr * distSqr;
     const FP invDistCube = 1.0f / std::sqrt(distSixth);
     const FP s = p2(tag::Mass()) * invDistCube;
@@ -74,81 +69,68 @@ pPInteraction(VirtualDatum1 p1, VirtualDatum2 p2, FP ts)
 
 /// Alpaka kernel for updating the speed of every particle based on the
 /// distance and mass to each other particle. Has complexity O(N²).
-template<std::size_t ProblemSize, std::size_t Elems, std::size_t BlockSize>
+template <std::size_t ProblemSize, std::size_t Elems, std::size_t BlockSize>
 struct UpdateKernel
 {
-    template<typename Acc, typename View>
-    LLAMA_FN_HOST_ACC_INLINE void
-    operator()(const Acc & acc, View particles, FP ts) const
+    template <typename Acc, typename View>
+    LLAMA_FN_HOST_ACC_INLINE void operator()(const Acc& acc, View particles, FP ts) const
     {
         [[maybe_unused]] auto sharedView = [&] {
-            if constexpr(USE_SHARED)
+            if constexpr (USE_SHARED)
             {
                 const auto sharedMapping = [&] {
-                    if constexpr(USE_SHARED_TREE)
-                        return llama::mapping::tree::Mapping{
-                            typename View::UserDomain{BlockSize},
-                            llama::Tuple{
-                                llama::mapping::tree::functor::LeafOnlyRT()},
-                            typename View::DatumDomain{}};
+                    if constexpr (USE_SHARED_TREE)
+                        return llama::mapping::tree::Mapping {
+                            typename View::UserDomain {BlockSize},
+                            llama::Tuple {llama::mapping::tree::functor::LeafOnlyRT()},
+                            typename View::DatumDomain {}};
                     else
-                        return llama::mapping::SoA{
-                            typename View::UserDomain{BlockSize},
-                            typename View::DatumDomain{}};
+                        return llama::mapping::SoA {
+                            typename View::UserDomain {BlockSize},
+                            typename View::DatumDomain {}};
                 }();
 
                 // if there is only 1 thread per block, avoid using shared
                 // memory
-                if constexpr(BlockSize / Elems == 1)
-                    return llama::allocViewStack<
-                        View::UserDomain::rank,
-                        typename View::DatumDomain>();
+                if constexpr (BlockSize / Elems == 1)
+                    return llama::allocViewStack<View::UserDomain::rank, typename View::DatumDomain>();
                 else
                 {
-                    constexpr auto sharedMemSize
-                        = llama::sizeOf<typename View::DatumDomain> * BlockSize;
-                    auto & sharedMem = alpaka::block::shared::st::
-                        allocVar<std::byte[sharedMemSize], __COUNTER__>(acc);
-                    return llama::View{
-                        sharedMapping, llama::Array{&sharedMem[0]}};
+                    constexpr auto sharedMemSize = llama::sizeOf<typename View::DatumDomain> * BlockSize;
+                    auto& sharedMem = alpaka::block::shared::st::allocVar<std::byte[sharedMemSize], __COUNTER__>(acc);
+                    return llama::View {sharedMapping, llama::Array {&sharedMem[0]}};
                 }
             }
             else
-                return int{}; // dummy
+                return int {}; // dummy
         }();
 
-        const auto ti
-            = alpaka::idx::getIdx<alpaka::Grid, alpaka::Threads>(acc)[0u];
-        const auto tbi
-            = alpaka::idx::getIdx<alpaka::Block, alpaka::Threads>(acc)[0];
+        const auto ti = alpaka::idx::getIdx<alpaka::Grid, alpaka::Threads>(acc)[0u];
+        const auto tbi = alpaka::idx::getIdx<alpaka::Block, alpaka::Threads>(acc)[0];
 
         const auto start = ti * Elems;
         const auto end = alpaka::math::min(acc, start + Elems, ProblemSize);
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t b = 0; b < (ProblemSize + BlockSize - 1u) / BlockSize;
-            ++b)
+        for (std::size_t b = 0; b < (ProblemSize + BlockSize - 1u) / BlockSize; ++b)
         {
             const auto start2 = b * BlockSize;
-            const auto end2
-                = alpaka::math::min(acc, start2 + BlockSize, ProblemSize)
-                - start2;
-            if constexpr(USE_SHARED)
+            const auto end2 = alpaka::math::min(acc, start2 + BlockSize, ProblemSize) - start2;
+            if constexpr (USE_SHARED)
             {
                 LLAMA_INDEPENDENT_DATA
-                for(auto pos2 = decltype(end2)(0); pos2 + ti < end2;
-                    pos2 += BlockSize / Elems)
+                for (auto pos2 = decltype(end2)(0); pos2 + ti < end2; pos2 += BlockSize / Elems)
                     sharedView(pos2 + tbi) = particles(start2 + pos2 + tbi);
                 alpaka::block::sync::syncBlockThreads(acc);
             }
             LLAMA_INDEPENDENT_DATA
-            for(auto pos2 = decltype(end2)(0); pos2 < end2; ++pos2)
+            for (auto pos2 = decltype(end2)(0); pos2 < end2; ++pos2)
                 LLAMA_INDEPENDENT_DATA
-            for(auto i = start; i < end; ++i)
-                if constexpr(USE_SHARED)
+            for (auto i = start; i < end; ++i)
+                if constexpr (USE_SHARED)
                     pPInteraction(particles(i), sharedView(pos2), ts);
                 else
                     pPInteraction(particles(i), particles(start2 + pos2), ts);
-            if constexpr(USE_SHARED)
+            if constexpr (USE_SHARED)
                 alpaka::block::sync::syncBlockThreads(acc);
         }
     }
@@ -156,26 +138,24 @@ struct UpdateKernel
 
 /// Alpaka kernel for moving each particle with its speed. Has complexity
 /// O(N).
-template<std::size_t ProblemSize, std::size_t Elems>
+template <std::size_t ProblemSize, std::size_t Elems>
 struct MoveKernel
 {
-    template<typename Acc, typename View>
-    LLAMA_FN_HOST_ACC_INLINE void
-    operator()(const Acc & acc, View particles, FP ts) const
+    template <typename Acc, typename View>
+    LLAMA_FN_HOST_ACC_INLINE void operator()(const Acc& acc, View particles, FP ts) const
     {
-        const auto ti
-            = alpaka::idx::getIdx<alpaka::Grid, alpaka::Threads>(acc)[0];
+        const auto ti = alpaka::idx::getIdx<alpaka::Grid, alpaka::Threads>(acc)[0];
 
         const auto start = ti * Elems;
         const auto end = alpaka::math::min(acc, start + Elems, ProblemSize);
 
         LLAMA_INDEPENDENT_DATA
-        for(auto i = start; i < end; ++i)
+        for (auto i = start; i < end; ++i)
             particles(i)(tag::Pos()) += particles(i)(tag::Vel()) * ts;
     }
 };
 
-int main(int argc, char ** argv)
+int main(int argc, char** argv)
 {
     using Dim = alpaka::dim::DimInt<1>;
     using Size = std::size_t;
@@ -195,49 +175,42 @@ int main(int argc, char ** argv)
 
     // NBODY
     constexpr std::size_t hardwareThreads = 2; // relevant for OpenMP2Threads
-    using Distribution
-        = common::ThreadsElemsDistribution<Acc, BLOCK_SIZE, hardwareThreads>;
+    using Distribution = common::ThreadsElemsDistribution<Acc, BLOCK_SIZE, hardwareThreads>;
     constexpr std::size_t elemCount = Distribution::elemCount;
     constexpr std::size_t threadCount = Distribution::threadCount;
     constexpr FP ts = 0.0001;
 
     // LLAMA
-    const auto userDomain = llama::UserDomain{PROBLEM_SIZE};
+    const auto userDomain = llama::UserDomain {PROBLEM_SIZE};
 
     const auto mapping = [&] {
-        if constexpr(MAPPING == 0)
-            return llama::mapping::AoS{userDomain, Particle{}};
-        if constexpr(MAPPING == 1)
-            return llama::mapping::SoA{userDomain, Particle{}};
-        if constexpr(MAPPING == 2)
-            return llama::mapping::tree::Mapping{
-                userDomain, llama::Tuple{}, Particle{}};
-        if constexpr(MAPPING == 3)
-            return llama::mapping::tree::Mapping{
+        if constexpr (MAPPING == 0)
+            return llama::mapping::AoS {userDomain, Particle {}};
+        if constexpr (MAPPING == 1)
+            return llama::mapping::SoA {userDomain, Particle {}};
+        if constexpr (MAPPING == 2)
+            return llama::mapping::tree::Mapping {userDomain, llama::Tuple {}, Particle {}};
+        if constexpr (MAPPING == 3)
+            return llama::mapping::tree::Mapping {
                 userDomain,
-                llama::Tuple{llama::mapping::tree::functor::LeafOnlyRT()},
-                Particle{}};
+                llama::Tuple {llama::mapping::tree::functor::LeafOnlyRT()},
+                Particle {}};
     }();
 
     std::cout << PROBLEM_SIZE / 1000 << " thousand particles\n"
-              << PROBLEM_SIZE * llama::sizeOf<Particle> / 1000 / 1000
-              << "MB \n";
+              << PROBLEM_SIZE * llama::sizeOf<Particle> / 1000 / 1000 << "MB \n";
 
     Chrono chrono;
 
     const auto bufferSize = Size(mapping.getBlobSize(0));
 
-    auto hostBuffer
-        = alpaka::mem::buf::alloc<std::byte, Size>(devHost, bufferSize);
-    auto accBuffer
-        = alpaka::mem::buf::alloc<std::byte, Size>(devAcc, bufferSize);
+    auto hostBuffer = alpaka::mem::buf::alloc<std::byte, Size>(devHost, bufferSize);
+    auto accBuffer = alpaka::mem::buf::alloc<std::byte, Size>(devAcc, bufferSize);
 
     chrono.printAndReset("Alloc");
 
-    auto hostView = llama::View{
-        mapping, llama::Array{alpaka::mem::view::getPtrNative(hostBuffer)}};
-    auto accView = llama::View{
-        mapping, llama::Array{alpaka::mem::view::getPtrNative(accBuffer)}};
+    auto hostView = llama::View {mapping, llama::Array {alpaka::mem::view::getPtrNative(hostBuffer)}};
+    auto accView = llama::View {mapping, llama::Array {alpaka::mem::view::getPtrNative(accBuffer)}};
 
     chrono.printAndReset("Views");
 
@@ -245,7 +218,7 @@ int main(int argc, char ** argv)
     std::mt19937_64 generator;
     std::normal_distribution<FP> distribution(FP(0), FP(1));
     LLAMA_INDEPENDENT_DATA
-    for(std::size_t i = 0; i < PROBLEM_SIZE; ++i)
+    for (std::size_t i = 0; i < PROBLEM_SIZE; ++i)
     {
         auto temp = llama::allocVirtualDatumStack<Particle>();
         temp(tag::Pos(), tag::X()) = distribution(generator);
@@ -266,13 +239,11 @@ int main(int argc, char ** argv)
     const alpaka::vec::Vec<Dim, Size> Elems(static_cast<Size>(elemCount));
     const alpaka::vec::Vec<Dim, Size> threads(static_cast<Size>(threadCount));
     constexpr auto innerCount = elemCount * threadCount;
-    const alpaka::vec::Vec<Dim, Size> blocks(
-        static_cast<Size>((PROBLEM_SIZE + innerCount - 1u) / innerCount));
+    const alpaka::vec::Vec<Dim, Size> blocks(static_cast<Size>((PROBLEM_SIZE + innerCount - 1u) / innerCount));
 
-    const auto workdiv
-        = alpaka::workdiv::WorkDivMembers<Dim, Size>{blocks, threads, Elems};
+    const auto workdiv = alpaka::workdiv::WorkDivMembers<Dim, Size> {blocks, threads, Elems};
 
-    for(std::size_t s = 0; s < STEPS; ++s)
+    for (std::size_t s = 0; s < STEPS; ++s)
     {
         UpdateKernel<PROBLEM_SIZE, elemCount, BLOCK_SIZE> updateKernel;
         alpaka::kernel::exec<Acc>(queue, workdiv, updateKernel, accView, ts);
diff --git a/examples/alpaka/vectoradd/vectoradd.cpp b/examples/alpaka/vectoradd/vectoradd.cpp
index 621948e7c2..e2345422b1 100644
--- a/examples/alpaka/vectoradd/vectoradd.cpp
+++ b/examples/alpaka/vectoradd/vectoradd.cpp
@@ -16,8 +16,7 @@
 #include <random>
 #include <utility>
 
-constexpr auto MAPPING
-    = 0; /// 0 native AoS, 1 native SoA, 2 tree AoS, 3 tree SoA
+constexpr auto MAPPING = 0; /// 0 native AoS, 1 native SoA, 2 tree AoS, 3 tree SoA
 constexpr auto PROBLEM_SIZE = 64 * 1024 * 1024;
 constexpr auto BLOCK_SIZE = 256;
 constexpr auto STEPS = 10;
@@ -38,30 +37,28 @@ using Vector = llama::DS<
     llama::DE<tag::Z, FP>>;
 // clang-format on
 
-template<std::size_t ProblemSize, std::size_t Elems>
+template <std::size_t ProblemSize, std::size_t Elems>
 struct AddKernel
 {
-    template<typename Acc, typename View>
-    LLAMA_FN_HOST_ACC_INLINE void
-    operator()(const Acc & acc, View a, View b) const
+    template <typename Acc, typename View>
+    LLAMA_FN_HOST_ACC_INLINE void operator()(const Acc& acc, View a, View b) const
     {
-        const auto ti
-            = alpaka::idx::getIdx<alpaka::Grid, alpaka::Threads>(acc)[0];
+        const auto ti = alpaka::idx::getIdx<alpaka::Grid, alpaka::Threads>(acc)[0];
 
         const auto start = ti * Elems;
         const auto end = alpaka::math::min(acc, start + Elems, ProblemSize);
 
         LLAMA_INDEPENDENT_DATA
-        for(auto i = start; i < end; ++i)
+        for (auto i = start; i < end; ++i)
         {
-            a(i)(tag::X{}) += b(i)(tag::X{});
-            a(i)(tag::Y{}) -= b(i)(tag::Y{});
-            a(i)(tag::Z{}) *= b(i)(tag::Z{});
+            a(i)(tag::X {}) += b(i)(tag::X {});
+            a(i)(tag::Y {}) -= b(i)(tag::Y {});
+            a(i)(tag::Z {}) *= b(i)(tag::Z {});
         }
     }
 };
 
-int main(int argc, char ** argv)
+int main(int argc, char** argv)
 {
     // ALPAKA
     using Dim = alpaka::dim::DimInt<1>;
@@ -81,52 +78,42 @@ int main(int argc, char ** argv)
     Queue queue(devAcc);
 
     // LLAMA
-    const auto userDomain = llama::UserDomain{PROBLEM_SIZE};
+    const auto userDomain = llama::UserDomain {PROBLEM_SIZE};
 
     const auto mapping = [&] {
-        if constexpr(MAPPING == 0)
-            return llama::mapping::AoS{userDomain, Vector{}};
-        if constexpr(MAPPING == 1)
-            return llama::mapping::SoA{userDomain, Vector{}};
-        if constexpr(MAPPING == 2)
-            return llama::mapping::tree::Mapping{
-                userDomain, llama::Tuple{}, Vector{}};
-        if constexpr(MAPPING == 3)
-            return llama::mapping::tree::Mapping{
+        if constexpr (MAPPING == 0)
+            return llama::mapping::AoS {userDomain, Vector {}};
+        if constexpr (MAPPING == 1)
+            return llama::mapping::SoA {userDomain, Vector {}};
+        if constexpr (MAPPING == 2)
+            return llama::mapping::tree::Mapping {userDomain, llama::Tuple {}, Vector {}};
+        if constexpr (MAPPING == 3)
+            return llama::mapping::tree::Mapping {
                 userDomain,
-                llama::Tuple{llama::mapping::tree::functor::LeafOnlyRT()},
-                Vector{}};
+                llama::Tuple {llama::mapping::tree::functor::LeafOnlyRT()},
+                Vector {}};
     }();
 
     std::cout << PROBLEM_SIZE / 1000 / 1000 << " million vectors\n"
-              << PROBLEM_SIZE * llama::sizeOf<Vector> * 2 / 1000 / 1000
-              << " MB on device\n";
+              << PROBLEM_SIZE * llama::sizeOf<Vector> * 2 / 1000 / 1000 << " MB on device\n";
 
     Chrono chrono;
 
     const auto bufferSize = Size(mapping.getBlobSize(0));
 
     // allocate buffers
-    auto hostBufferA
-        = alpaka::mem::buf::alloc<std::byte, Size>(devHost, bufferSize);
-    auto hostBufferB
-        = alpaka::mem::buf::alloc<std::byte, Size>(devHost, bufferSize);
-    auto devBufferA
-        = alpaka::mem::buf::alloc<std::byte, Size>(devAcc, bufferSize);
-    auto devBufferB
-        = alpaka::mem::buf::alloc<std::byte, Size>(devAcc, bufferSize);
+    auto hostBufferA = alpaka::mem::buf::alloc<std::byte, Size>(devHost, bufferSize);
+    auto hostBufferB = alpaka::mem::buf::alloc<std::byte, Size>(devHost, bufferSize);
+    auto devBufferA = alpaka::mem::buf::alloc<std::byte, Size>(devAcc, bufferSize);
+    auto devBufferB = alpaka::mem::buf::alloc<std::byte, Size>(devAcc, bufferSize);
 
     chrono.printAndReset("Alloc");
 
     // create LLAMA views
-    auto hostA = llama::View{
-        mapping, llama::Array{alpaka::mem::view::getPtrNative(hostBufferA)}};
-    auto hostB = llama::View{
-        mapping, llama::Array{alpaka::mem::view::getPtrNative(hostBufferB)}};
-    auto devA = llama::View{
-        mapping, llama::Array{alpaka::mem::view::getPtrNative(devBufferA)}};
-    auto devB = llama::View{
-        mapping, llama::Array{alpaka::mem::view::getPtrNative(devBufferB)}};
+    auto hostA = llama::View {mapping, llama::Array {alpaka::mem::view::getPtrNative(hostBufferA)}};
+    auto hostB = llama::View {mapping, llama::Array {alpaka::mem::view::getPtrNative(hostBufferB)}};
+    auto devA = llama::View {mapping, llama::Array {alpaka::mem::view::getPtrNative(devBufferA)}};
+    auto devB = llama::View {mapping, llama::Array {alpaka::mem::view::getPtrNative(devBufferB)}};
 
     chrono.printAndReset("Views");
 
@@ -134,7 +121,7 @@ int main(int argc, char ** argv)
     std::normal_distribution<FP> distribution(FP(0), FP(1));
     auto seed = distribution(generator);
     LLAMA_INDEPENDENT_DATA
-    for(std::size_t i = 0; i < PROBLEM_SIZE; ++i)
+    for (std::size_t i = 0; i < PROBLEM_SIZE; ++i)
     {
         hostA(i) = seed + i;
         hostB(i) = seed - i;
@@ -147,23 +134,19 @@ int main(int argc, char ** argv)
     chrono.printAndReset("Copy H->D");
 
     constexpr std::size_t hardwareThreads = 2; // relevant for OpenMP2Threads
-    using Distribution
-        = common::ThreadsElemsDistribution<Acc, BLOCK_SIZE, hardwareThreads>;
+    using Distribution = common::ThreadsElemsDistribution<Acc, BLOCK_SIZE, hardwareThreads>;
     constexpr std::size_t elemCount = Distribution::elemCount;
     constexpr std::size_t threadCount = Distribution::threadCount;
     const alpaka::vec::Vec<Dim, Size> elems(static_cast<Size>(elemCount));
     const alpaka::vec::Vec<Dim, Size> threads(static_cast<Size>(threadCount));
     constexpr auto innerCount = elemCount * threadCount;
-    const alpaka::vec::Vec<Dim, Size> blocks(
-        static_cast<Size>((PROBLEM_SIZE + innerCount - 1) / innerCount));
+    const alpaka::vec::Vec<Dim, Size> blocks(static_cast<Size>((PROBLEM_SIZE + innerCount - 1) / innerCount));
 
-    const auto workdiv
-        = alpaka::workdiv::WorkDivMembers<Dim, Size>{blocks, threads, elems};
+    const auto workdiv = alpaka::workdiv::WorkDivMembers<Dim, Size> {blocks, threads, elems};
 
-    for(std::size_t s = 0; s < STEPS; ++s)
+    for (std::size_t s = 0; s < STEPS; ++s)
     {
-        alpaka::kernel::exec<Acc>(
-            queue, workdiv, AddKernel<PROBLEM_SIZE, elemCount>{}, devA, devB);
+        alpaka::kernel::exec<Acc>(queue, workdiv, AddKernel<PROBLEM_SIZE, elemCount> {}, devA, devB);
         chrono.printAndReset("Add kernel");
     }
 
diff --git a/examples/common/Chrono.hpp b/examples/common/Chrono.hpp
index 83e96820d1..67b31f1ec4 100644
--- a/examples/common/Chrono.hpp
+++ b/examples/common/Chrono.hpp
@@ -6,7 +6,9 @@
 
 struct Chrono
 {
-    Chrono() : last(std::chrono::system_clock::now()) {}
+    Chrono() : last(std::chrono::system_clock::now())
+    {
+    }
 
     void printAndReset(std::string eventName)
     {
diff --git a/examples/common/alpakaHelpers.hpp b/examples/common/alpakaHelpers.hpp
index b2d6ee2cda..215beea131 100644
--- a/examples/common/alpakaHelpers.hpp
+++ b/examples/common/alpakaHelpers.hpp
@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include <cstddef>
 #include <alpaka/alpaka.hpp>
+#include <cstddef>
 
 namespace common
 {
@@ -18,7 +18,7 @@ namespace common
     /** Returns a good guess for an optimal number of threads and elements in a
      *  block based on the total number of elements in the block.
      */
-    template<typename T_Acc, std::size_t blockSize, std::size_t hardwareThreads>
+    template <typename T_Acc, std::size_t blockSize, std::size_t hardwareThreads>
     struct ThreadsElemsDistribution
     {
         /// number of elements per thread
@@ -28,37 +28,21 @@ namespace common
     };
 
 #ifdef ALPAKA_ACC_GPU_CUDA_ENABLED
-    template<
-        std::size_t blockSize,
-        std::size_t hardwareThreads,
-        typename T_Dim,
-        typename T_Size>
-    struct ThreadsElemsDistribution<
-        alpaka::acc::AccGpuCudaRt<T_Dim, T_Size>,
-        blockSize,
-        hardwareThreads>
+    template <std::size_t blockSize, std::size_t hardwareThreads, typename T_Dim, typename T_Size>
+    struct ThreadsElemsDistribution<alpaka::acc::AccGpuCudaRt<T_Dim, T_Size>, blockSize, hardwareThreads>
     {
         static constexpr std::size_t elemCount = THREADELEMDIST_MIN_ELEM;
-        static constexpr std::size_t threadCount
-            = blockSize / THREADELEMDIST_MIN_ELEM;
+        static constexpr std::size_t threadCount = blockSize / THREADELEMDIST_MIN_ELEM;
     };
 #endif
 
 #ifdef ALPAKA_ACC_CPU_B_SEQ_T_OMP2_ENABLED
-    template<
-        std::size_t blockSize,
-        std::size_t hardwareThreads,
-        typename T_Dim,
-        typename T_Size>
-    struct ThreadsElemsDistribution<
-        alpaka::acc::AccCpuOmp2Threads<T_Dim, T_Size>,
-        blockSize,
-        hardwareThreads>
+    template <std::size_t blockSize, std::size_t hardwareThreads, typename T_Dim, typename T_Size>
+    struct ThreadsElemsDistribution<alpaka::acc::AccCpuOmp2Threads<T_Dim, T_Size>, blockSize, hardwareThreads>
     {
-        static constexpr std::size_t elemCount
-            = (blockSize + hardwareThreads - 1u) / hardwareThreads;
+        static constexpr std::size_t elemCount = (blockSize + hardwareThreads - 1u) / hardwareThreads;
         static constexpr std::size_t threadCount = hardwareThreads;
     };
 #endif
 
-} // namspace common
+} // namespace common
diff --git a/examples/heatequation/heatequation.cpp b/examples/heatequation/heatequation.cpp
index 56b086eefe..5f691432da 100644
--- a/examples/heatequation/heatequation.cpp
+++ b/examples/heatequation/heatequation.cpp
@@ -25,19 +25,12 @@ using DatumDomain = double;
 
 struct HeatEquationKernel
 {
-    template<typename View>
-    void operator()(
-        uint32_t idx,
-        const View & uCurrBuf,
-        View & uNextBuf,
-        uint32_t extent,
-        double dx,
-        double dt) const
+    template <typename View>
+    void operator()(uint32_t idx, const View& uCurrBuf, View& uNextBuf, uint32_t extent, double dx, double dt) const
     {
         const auto r = dt / (dx * dx);
-        if(idx > 0 && idx < extent - 1u)
-            uNextBuf[idx] = uCurrBuf[idx] * (1.0 - 2.0 * r)
-                + uCurrBuf[idx - 1] * r + uCurrBuf[idx + 1] * r;
+        if (idx > 0 && idx < extent - 1u)
+            uNextBuf[idx] = uCurrBuf[idx] * (1.0 - 2.0 * r) + uCurrBuf[idx - 1] * r + uCurrBuf[idx + 1] * r;
     }
 };
 
@@ -62,27 +55,25 @@ auto main() -> int
     const auto dt = tMax / static_cast<double>(numTimeSteps - 1);
 
     const auto r = dt / (dx * dx);
-    if(r > 0.5)
+    if (r > 0.5)
     {
-        std::cerr << "Stability condition check failed: dt/dx^2 = " << r
-                  << ", it is required to be <= 0.5\n";
+        std::cerr << "Stability condition check failed: dt/dx^2 = " << r << ", it is required to be <= 0.5\n";
         return 1;
     }
 
-    const auto mapping
-        = llama::mapping::AoS{llama::UserDomain{numNodesX}, DatumDomain{}};
+    const auto mapping = llama::mapping::AoS {llama::UserDomain {numNodesX}, DatumDomain {}};
     auto uNext = llama::allocView(mapping);
     auto uCurr = llama::allocView(mapping);
 
     // Apply initial conditions for the test problem
-    for(uint32_t i = 0; i < numNodesX; i++)
+    for (uint32_t i = 0; i < numNodesX; i++)
         uCurr[i] = exactSolution(i * dx, 0.0);
 
     const auto start = std::chrono::high_resolution_clock::now();
     HeatEquationKernel kernel;
-    for(int step = 0; step < numTimeSteps; step++)
+    for (int step = 0; step < numTimeSteps; step++)
     {
-        for(auto i = 0; i < numNodesX; i++)
+        for (auto i = 0; i < numNodesX; i++)
             kernel(i, uCurr, uNext, numNodesX, dx, dt);
 
         // We assume the boundary conditions are constant and so these values
@@ -90,29 +81,26 @@ auto main() -> int
         std::swap(uNext, uCurr);
     }
     const auto end = std::chrono::high_resolution_clock::now();
-    std::cout << "Runtime: "
-              << std::chrono::duration<double>(end - start).count() << "s\n";
+    std::cout << "Runtime: " << std::chrono::duration<double>(end - start).count() << "s\n";
 
     // Calculate error
     double maxError = 0.0;
-    for(uint32_t i = 0; i < numNodesX; i++)
+    for (uint32_t i = 0; i < numNodesX; i++)
     {
-        const auto error
-            = std::abs(uNext[i] - exactSolution(i * dx, tMax));
+        const auto error = std::abs(uNext[i] - exactSolution(i * dx, tMax));
         maxError = std::max(maxError, error);
     }
 
     const auto errorThreshold = 1e-5;
     const auto resultCorrect = (maxError < errorThreshold);
-    if(resultCorrect)
+    if (resultCorrect)
     {
         std::cout << "Execution results correct!\n";
         return 0;
     }
     else
     {
-        std::cout << "Execution results incorrect: error = " << maxError
-                  << " (the grid resolution may be too low)\n";
+        std::cout << "Execution results incorrect: error = " << maxError << " (the grid resolution may be too low)\n";
         return 2;
     }
 }
diff --git a/examples/nbody/nbody.cpp b/examples/nbody/nbody.cpp
index 0db7af7fe6..804e7d6b85 100644
--- a/examples/nbody/nbody.cpp
+++ b/examples/nbody/nbody.cpp
@@ -7,8 +7,7 @@
 
 // needs -fno-math-errno, so std::sqrt() can be vectorized
 
-constexpr auto MAPPING
-    = 1; ///< 0 native AoS, 1 native SoA, 2 tree AoS, 3 tree SoA
+constexpr auto MAPPING = 1; ///< 0 native AoS, 1 native SoA, 2 tree AoS, 3 tree SoA
 constexpr auto PROBLEM_SIZE = 16 * 1024; ///< total number of particles
 constexpr auto STEPS = 5; ///< number of steps to calculate
 constexpr auto TRACE = false;
@@ -44,63 +43,60 @@ namespace usellama
     >;
     // clang-format on
 
-    template<typename VirtualParticle>
-    LLAMA_FN_HOST_ACC_INLINE void
-    pPInteraction(VirtualParticle p1, VirtualParticle p2, FP ts)
+    template <typename VirtualParticle>
+    LLAMA_FN_HOST_ACC_INLINE void pPInteraction(VirtualParticle p1, VirtualParticle p2, FP ts)
     {
-        auto dist = p1(tag::Pos{}) + p2(tag::Pos{});
+        auto dist = p1(tag::Pos {}) + p2(tag::Pos {});
         dist *= dist;
-        const FP distSqr
-            = EPS2 + dist(tag::X{}) + dist(tag::Y{}) + dist(tag::Z{});
+        const FP distSqr = EPS2 + dist(tag::X {}) + dist(tag::Y {}) + dist(tag::Z {});
         const FP distSixth = distSqr * distSqr * distSqr;
         const FP invDistCube = 1.0f / std::sqrt(distSixth);
-        const FP s = p2(tag::Mass{}) * invDistCube;
+        const FP s = p2(tag::Mass {}) * invDistCube;
         dist *= s * ts;
-        p1(tag::Vel{}) += dist;
+        p1(tag::Vel {}) += dist;
     }
 
-    template<typename View>
-    void update(View & particles, FP ts)
+    template <typename View>
+    void update(View& particles, FP ts)
     {
-        for(std::size_t i = 0; i < PROBLEM_SIZE; i++)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
         {
             LLAMA_INDEPENDENT_DATA
-            for(std::size_t j = 0; j < PROBLEM_SIZE; j++)
+            for (std::size_t j = 0; j < PROBLEM_SIZE; j++)
                 pPInteraction(particles(j), particles(i), ts);
         }
     }
 
-    template<typename View>
-    void move(View & particles, FP ts)
+    template <typename View>
+    void move(View& particles, FP ts)
     {
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t i = 0; i < PROBLEM_SIZE; i++)
-            particles(i)(tag::Pos{}) += particles(i)(tag::Vel{}) * ts;
+        for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
+            particles(i)(tag::Pos {}) += particles(i)(tag::Vel {}) * ts;
     }
 
-    int main(int argc, char ** argv)
+    int main(int argc, char** argv)
     {
         constexpr FP ts = 0.0001f;
 
-        const auto userDomain = llama::UserDomain{PROBLEM_SIZE};
+        const auto userDomain = llama::UserDomain {PROBLEM_SIZE};
         auto mapping = [&] {
-            if constexpr(MAPPING == 0)
-                return llama::mapping::AoS{userDomain, Particle{}};
-            if constexpr(MAPPING == 1)
-                return llama::mapping::SoA{userDomain, Particle{}};
-            if constexpr(MAPPING == 2)
-                return llama::mapping::tree::Mapping{
-                    userDomain, llama::Tuple{}, Particle{}};
-            if constexpr(MAPPING == 3)
-                return llama::mapping::tree::Mapping{
+            if constexpr (MAPPING == 0)
+                return llama::mapping::AoS {userDomain, Particle {}};
+            if constexpr (MAPPING == 1)
+                return llama::mapping::SoA {userDomain, Particle {}};
+            if constexpr (MAPPING == 2)
+                return llama::mapping::tree::Mapping {userDomain, llama::Tuple {}, Particle {}};
+            if constexpr (MAPPING == 3)
+                return llama::mapping::tree::Mapping {
                     userDomain,
-                    llama::Tuple{llama::mapping::tree::functor::LeafOnlyRT()},
-                    Particle{}};
+                    llama::Tuple {llama::mapping::tree::functor::LeafOnlyRT()},
+                    Particle {}};
         }();
 
         auto tmapping = [&] {
-            if constexpr(TRACE)
-                return llama::mapping::Trace{std::move(mapping)};
+            if constexpr (TRACE)
+                return llama::mapping::Trace {std::move(mapping)};
             else
                 return std::move(mapping);
         }();
@@ -111,56 +107,48 @@ namespace usellama
 
         const auto start = std::chrono::high_resolution_clock::now();
         const auto stop = std::chrono::high_resolution_clock::now();
-        std::cout << "alloc took "
-                  << std::chrono::duration<double>(stop - start).count()
-                  << "s\n";
+        std::cout << "alloc took " << std::chrono::duration<double>(stop - start).count() << "s\n";
 
         {
             const auto start = std::chrono::high_resolution_clock::now();
 
             std::default_random_engine engine;
             std::normal_distribution<FP> dist(FP(0), FP(1));
-            for(std::size_t i = 0; i < PROBLEM_SIZE; ++i)
+            for (std::size_t i = 0; i < PROBLEM_SIZE; ++i)
             {
                 auto p = particles(i);
-                p(tag::Pos{}, tag::X{}) = dist(engine);
-                p(tag::Pos{}, tag::Y{}) = dist(engine);
-                p(tag::Pos{}, tag::Z{}) = dist(engine);
-                p(tag::Vel{}, tag::X{}) = dist(engine) / FP(10);
-                p(tag::Vel{}, tag::Y{}) = dist(engine) / FP(10);
-                p(tag::Vel{}, tag::Z{}) = dist(engine) / FP(10);
-                p(tag::Mass{}) = dist(engine) / FP(100);
+                p(tag::Pos {}, tag::X {}) = dist(engine);
+                p(tag::Pos {}, tag::Y {}) = dist(engine);
+                p(tag::Pos {}, tag::Z {}) = dist(engine);
+                p(tag::Vel {}, tag::X {}) = dist(engine) / FP(10);
+                p(tag::Vel {}, tag::Y {}) = dist(engine) / FP(10);
+                p(tag::Vel {}, tag::Z {}) = dist(engine) / FP(10);
+                p(tag::Mass {}) = dist(engine) / FP(100);
             }
 
             const auto stop = std::chrono::high_resolution_clock::now();
-            std::cout << "init took "
-                      << std::chrono::duration<double>(stop - start).count()
-                      << "s\n";
+            std::cout << "init took " << std::chrono::duration<double>(stop - start).count() << "s\n";
         }
 
-        for(std::size_t s = 0; s < STEPS; ++s)
+        for (std::size_t s = 0; s < STEPS; ++s)
         {
             {
                 const auto start = std::chrono::high_resolution_clock::now();
                 update(particles, ts);
                 const auto stop = std::chrono::high_resolution_clock::now();
-                std::cout << "update took "
-                          << std::chrono::duration<double>(stop - start).count()
-                          << "s\t";
+                std::cout << "update took " << std::chrono::duration<double>(stop - start).count() << "s\t";
             }
             {
                 const auto start = std::chrono::high_resolution_clock::now();
                 move(particles, ts);
                 const auto stop = std::chrono::high_resolution_clock::now();
-                std::cout << "move took   "
-                          << std::chrono::duration<double>(stop - start).count()
-                          << "s\n";
+                std::cout << "move took   " << std::chrono::duration<double>(stop - start).count() << "s\n";
             }
         }
 
         return 0;
     }
-}
+} // namespace usellama
 
 namespace manualAoS
 {
@@ -170,7 +158,7 @@ namespace manualAoS
         FP y;
         FP z;
 
-        auto operator*=(FP s) -> Vec &
+        auto operator*=(FP s) -> Vec&
         {
             x *= s;
             y *= s;
@@ -178,7 +166,7 @@ namespace manualAoS
             return *this;
         }
 
-        auto operator*=(Vec v) -> Vec &
+        auto operator*=(Vec v) -> Vec&
         {
             x *= v.x;
             y *= v.y;
@@ -186,7 +174,7 @@ namespace manualAoS
             return *this;
         }
 
-        auto operator+=(Vec v) -> Vec &
+        auto operator+=(Vec v) -> Vec&
         {
             x += v.x;
             y += v.y;
@@ -218,7 +206,7 @@ namespace manualAoS
         FP mass;
     };
 
-    inline void pPInteraction(Particle & p1, const Particle & p2, FP ts)
+    inline void pPInteraction(Particle& p1, const Particle& p2, FP ts)
     {
         auto distance = p1.pos + p2.pos;
         distance *= distance;
@@ -230,24 +218,24 @@ namespace manualAoS
         p1.vel += distance;
     }
 
-    void update(Particle * particles, FP ts)
+    void update(Particle* particles, FP ts)
     {
-        for(std::size_t i = 0; i < PROBLEM_SIZE; i++)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
         {
             LLAMA_INDEPENDENT_DATA
-            for(std::size_t j = 0; j < PROBLEM_SIZE; j++)
+            for (std::size_t j = 0; j < PROBLEM_SIZE; j++)
                 pPInteraction(particles[j], particles[i], ts);
         }
     }
 
-    void move(Particle * particles, FP ts)
+    void move(Particle* particles, FP ts)
     {
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t i = 0; i < PROBLEM_SIZE; i++)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
             particles[i].pos += particles[i].vel * ts;
     }
 
-    int main(int argc, char ** argv)
+    int main(int argc, char** argv)
     {
         constexpr FP ts = 0.0001f;
 
@@ -256,16 +244,14 @@ namespace manualAoS
         const auto start = std::chrono::high_resolution_clock::now();
         std::vector<Particle> particles(PROBLEM_SIZE);
         const auto stop = std::chrono::high_resolution_clock::now();
-        std::cout << "alloc took "
-                  << std::chrono::duration<double>(stop - start).count()
-                  << "s\n";
+        std::cout << "alloc took " << std::chrono::duration<double>(stop - start).count() << "s\n";
 
         {
             const auto start = std::chrono::high_resolution_clock::now();
 
             std::default_random_engine engine;
             std::normal_distribution<FP> dist(FP(0), FP(1));
-            for(auto & p : particles)
+            for (auto& p : particles)
             {
                 p.pos.x = dist(engine);
                 p.pos.y = dist(engine);
@@ -277,34 +263,28 @@ namespace manualAoS
             }
 
             const auto stop = std::chrono::high_resolution_clock::now();
-            std::cout << "init took "
-                      << std::chrono::duration<double>(stop - start).count()
-                      << "s\n";
+            std::cout << "init took " << std::chrono::duration<double>(stop - start).count() << "s\n";
         }
 
-        for(std::size_t s = 0; s < STEPS; ++s)
+        for (std::size_t s = 0; s < STEPS; ++s)
         {
             {
                 const auto start = std::chrono::high_resolution_clock::now();
                 update(particles.data(), ts);
                 const auto stop = std::chrono::high_resolution_clock::now();
-                std::cout << "update took "
-                          << std::chrono::duration<double>(stop - start).count()
-                          << "s\t";
+                std::cout << "update took " << std::chrono::duration<double>(stop - start).count() << "s\t";
             }
             {
                 const auto start = std::chrono::high_resolution_clock::now();
                 move(particles.data(), ts);
                 const auto stop = std::chrono::high_resolution_clock::now();
-                std::cout << "move took   "
-                          << std::chrono::duration<double>(stop - start).count()
-                          << "s\n";
+                std::cout << "move took   " << std::chrono::duration<double>(stop - start).count() << "s\n";
             }
         }
 
         return 0;
     }
-}
+} // namespace manualAoS
 
 namespace manualSoA
 {
@@ -312,9 +292,9 @@ namespace manualSoA
         FP p1posx,
         FP p1posy,
         FP p1posz,
-        FP & p1velx,
-        FP & p1vely,
-        FP & p1velz,
+        FP& p1velx,
+        FP& p1vely,
+        FP& p1velz,
         FP p2posx,
         FP p2posy,
         FP p2posz,
@@ -339,20 +319,12 @@ namespace manualSoA
         p1velz += zdistance;
     }
 
-    void update(
-        FP * posx,
-        FP * posy,
-        FP * posz,
-        FP * velx,
-        FP * vely,
-        FP * velz,
-        FP * mass,
-        FP ts)
+    void update(FP* posx, FP* posy, FP* posz, FP* velx, FP* vely, FP* velz, FP* mass, FP ts)
     {
-        for(std::size_t i = 0; i < PROBLEM_SIZE; i++)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
         {
             LLAMA_INDEPENDENT_DATA
-            for(std::size_t j = 0; j < PROBLEM_SIZE; j++)
+            for (std::size_t j = 0; j < PROBLEM_SIZE; j++)
                 pPInteraction(
                     posx[j],
                     posy[j],
@@ -368,18 +340,10 @@ namespace manualSoA
         }
     }
 
-    void move(
-        FP * posx,
-        FP * posy,
-        FP * posz,
-        FP * velx,
-        FP * vely,
-        FP * velz,
-        FP * mass,
-        FP ts)
+    void move(FP* posx, FP* posy, FP* posz, FP* velx, FP* vely, FP* velz, FP* mass, FP ts)
     {
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t i = 0; i < PROBLEM_SIZE; i++)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
         {
             posx[i] += velx[i] * ts;
             posy[i] += vely[i] * ts;
@@ -387,7 +351,7 @@ namespace manualSoA
         }
     }
 
-    int main(int argc, char ** argv)
+    int main(int argc, char** argv)
     {
         constexpr FP ts = 0.0001f;
 
@@ -402,16 +366,14 @@ namespace manualSoA
         std::vector<FP> velz(PROBLEM_SIZE);
         std::vector<FP> mass(PROBLEM_SIZE);
         const auto stop = std::chrono::high_resolution_clock::now();
-        std::cout << "alloc took "
-                  << std::chrono::duration<double>(stop - start).count()
-                  << "s\n";
+        std::cout << "alloc took " << std::chrono::duration<double>(stop - start).count() << "s\n";
 
         {
             const auto start = std::chrono::high_resolution_clock::now();
 
             std::default_random_engine engine;
             std::normal_distribution<FP> dist(FP(0), FP(1));
-            for(std::size_t i = 0; i < PROBLEM_SIZE; ++i)
+            for (std::size_t i = 0; i < PROBLEM_SIZE; ++i)
             {
                 posx[i] = dist(engine);
                 posy[i] = dist(engine);
@@ -423,52 +385,30 @@ namespace manualSoA
             }
 
             const auto stop = std::chrono::high_resolution_clock::now();
-            std::cout << "init took "
-                      << std::chrono::duration<double>(stop - start).count()
-                      << "s\n";
+            std::cout << "init took " << std::chrono::duration<double>(stop - start).count() << "s\n";
         }
 
-        for(std::size_t s = 0; s < STEPS; ++s)
+        for (std::size_t s = 0; s < STEPS; ++s)
         {
             {
                 const auto start = std::chrono::high_resolution_clock::now();
-                update(
-                    posx.data(),
-                    posy.data(),
-                    posz.data(),
-                    velx.data(),
-                    vely.data(),
-                    velz.data(),
-                    mass.data(),
-                    ts);
+                update(posx.data(), posy.data(), posz.data(), velx.data(), vely.data(), velz.data(), mass.data(), ts);
                 const auto stop = std::chrono::high_resolution_clock::now();
-                std::cout << "update took "
-                          << std::chrono::duration<double>(stop - start).count()
-                          << "s\t";
+                std::cout << "update took " << std::chrono::duration<double>(stop - start).count() << "s\t";
             }
             {
                 const auto start = std::chrono::high_resolution_clock::now();
-                move(
-                    posx.data(),
-                    posy.data(),
-                    posz.data(),
-                    velx.data(),
-                    vely.data(),
-                    velz.data(),
-                    mass.data(),
-                    ts);
+                move(posx.data(), posy.data(), posz.data(), velx.data(), vely.data(), velz.data(), mass.data(), ts);
                 const auto stop = std::chrono::high_resolution_clock::now();
-                std::cout << "move took   "
-                          << std::chrono::duration<double>(stop - start).count()
-                          << "s\n";
+                std::cout << "move took   " << std::chrono::duration<double>(stop - start).count() << "s\n";
             }
         }
 
         return 0;
     }
-}
+} // namespace manualSoA
 
-int main(int argc, char ** argv)
+int main(int argc, char** argv)
 {
     int r = 0;
     r += usellama::main(argc, argv);
diff --git a/examples/simpletest/simpletest.cpp b/examples/simpletest/simpletest.cpp
index 4d6445a657..1a0f244e63 100644
--- a/examples/simpletest/simpletest.cpp
+++ b/examples/simpletest/simpletest.cpp
@@ -57,32 +57,32 @@ using Name = llama::DS<
 
 namespace
 {
-    template<class T>
-    std::string type(const T & t)
+    template <class T>
+    std::string type(const T& t)
     {
         return boost::core::demangle(typeid(t).name());
     }
 
     /// Prints the coordinates of a given \ref llama::DatumCoord for debugging
     /// and testing purposes
-    template<std::size_t... T_coords>
+    template <std::size_t... T_coords>
     void printCoords(llama::DatumCoord<T_coords...> dc)
     {
         (std::cout << ... << T_coords);
     }
 
-    template<typename Out>
-    void split(const std::string & s, char delim, Out result)
+    template <typename Out>
+    void split(const std::string& s, char delim, Out result)
     {
         std::stringstream ss(s);
         std::string item;
-        while(std::getline(ss, item, delim))
+        while (std::getline(ss, item, delim))
         {
             *(result++) = item;
         }
     }
 
-    std::vector<std::string> split(const std::string & s, char delim)
+    std::vector<std::string> split(const std::string& s, char delim)
     {
         std::vector<std::string> elems;
         split(s, delim, std::back_inserter(elems));
@@ -92,7 +92,8 @@ namespace
     std::string nSpaces(int n)
     {
         std::string result = "";
-        for(int i = 0; i < n; ++i) result += " ";
+        for (int i = 0; i < n; ++i)
+            result += " ";
         return result;
     }
 
@@ -105,24 +106,24 @@ namespace
         auto tokens = split(raw, '\n');
         std::string result = "";
         int indent = 0;
-        for(auto t : tokens)
+        for (auto t : tokens)
         {
-            if(t.back() == '>' || (t.length() > 1 && t[t.length() - 2] == '>'))
+            if (t.back() == '>' || (t.length() > 1 && t[t.length() - 2] == '>'))
                 indent -= 4;
             result += nSpaces(indent) + t + "\n";
-            if(t.back() == '<')
+            if (t.back() == '<')
                 indent += 4;
         }
         return result;
     }
-}
+} // namespace
 
 /// Example functor for \ref llama::forEach which can also be used to print the
 /// coordinates inside of a datum domain when called.
-template<typename VirtualDatum>
+template <typename VirtualDatum>
 struct SetZeroFunctor
 {
-    template<typename Coord>
+    template <typename Coord>
     void operator()(Coord coord)
     {
         vd(coord) = 0;
@@ -130,25 +131,19 @@ struct SetZeroFunctor
     VirtualDatum vd;
 };
 
-int main(int argc, char ** argv)
+int main(int argc, char** argv)
 {
     // Defining a two-dimensional user domain
     using UD = llama::UserDomain<2>;
     // Setting the run time size of the user domain to 8192 * 8192
-    UD udSize{8192, 8192};
+    UD udSize {8192, 8192};
 
     // Printing the domain informations at runtime
     std::cout << "Datum Domain is " << addLineBreaks(type(Name())) << '\n';
     std::cout << "AoS address of (0,100) <0,1>: "
-              << llama::mapping::AoS<UD, Name>(udSize)
-                     .getBlobNrAndOffset<0, 1>({0, 100})
-                     .offset
-              << '\n';
+              << llama::mapping::AoS<UD, Name>(udSize).getBlobNrAndOffset<0, 1>({0, 100}).offset << '\n';
     std::cout << "SoA address of (0,100) <0,1>: "
-              << llama::mapping::SoA<UD, Name>(udSize)
-                     .getBlobNrAndOffset<0, 1>({0, 100})
-                     .offset
-              << '\n';
+              << llama::mapping::SoA<UD, Name>(udSize).getBlobNrAndOffset<0, 1>({0, 100}).offset << '\n';
     std::cout << "sizeOf DatumDomain: " << llama::sizeOf<Name> << '\n';
 
     std::cout << type(llama::GetCoordFromTags<Name, st::Pos, st::X>()) << '\n';
@@ -162,61 +157,57 @@ int main(int argc, char ** argv)
     auto view = allocView(mapping);
 
     // defining a position in the user domain
-    const UD pos{0, 0};
+    const UD pos {0, 0};
 
     st::Options Options_;
-    const auto Weight_ = st::Weight{};
+    const auto Weight_ = st::Weight {};
 
     // using the position in the user domain and a tree coord or a uid in the
     // datum domain to get the reference to an element in the view
-    float & position_x = view(pos).access<0, 0>();
-    double & momentum_z = view[pos].access<st::Momentum, st::Z>();
-    int & weight = view[{0, 0}](llama::DatumCoord<2>());
-    int & weight_2 = view(pos)(Weight_);
-    bool & options_2 = view[0](st::Options())(llama::DatumCoord<2>());
-    bool & options_3 = view(pos)(Options_)(llama::DatumCoord<2>());
+    float& position_x = view(pos).access<0, 0>();
+    double& momentum_z = view[pos].access<st::Momentum, st::Z>();
+    int& weight = view[{0, 0}](llama::DatumCoord<2>());
+    int& weight_2 = view(pos)(Weight_);
+    bool& options_2 = view[0](st::Options())(llama::DatumCoord<2>());
+    bool& options_3 = view(pos)(Options_)(llama::DatumCoord<2>());
     // printing the address and distances of the element in the memory. This
     // will change based on the chosen mapping. When array of struct is chosen
     // instead the elements will be much closer than with struct of array.
     std::cout << &position_x << '\n';
-    std::cout << &momentum_z << " " << (size_t)&momentum_z - (size_t)&position_x
-              << '\n';
-    std::cout << &weight << " " << (size_t)&weight - (size_t)&momentum_z
-              << '\n';
-    std::cout << &options_2 << " " << (size_t)&options_2 - (size_t)&weight
-              << '\n';
+    std::cout << &momentum_z << " " << (size_t) &momentum_z - (size_t) &position_x << '\n';
+    std::cout << &weight << " " << (size_t) &weight - (size_t) &momentum_z << '\n';
+    std::cout << &options_2 << " " << (size_t) &options_2 - (size_t) &weight << '\n';
 
     // iterating over the user domain at run time to do some stuff with the
     // allocated data
-    for(size_t x = 0; x < udSize[0]; ++x)
+    for (size_t x = 0; x < udSize[0]; ++x)
         // telling the compiler that all data in the following loop is
         // independent to each other and thus can be vectorized
         LLAMA_INDEPENDENT_DATA
-    for(size_t y = 0; y < udSize[1]; ++y)
+    for (size_t y = 0; y < udSize[1]; ++y)
     {
         // Defining a functor for a given virtual datum
-        SetZeroFunctor<decltype(view(x, y))> szf{view(x, y)};
+        SetZeroFunctor<decltype(view(x, y))> szf {view(x, y)};
         // Applying the functor for the sub tree 0,0 (pos.x), so basically
         // only for this element
-        llama::forEach<Name>(szf, llama::DatumCoord<0, 0>{});
+        llama::forEach<Name>(szf, llama::DatumCoord<0, 0> {});
         // Applying the functor for the sub tree momentum (0), so basically
         // for momentum.z, and momentum.x
-        llama::forEach<Name>(szf, st::Momentum{});
+        llama::forEach<Name>(szf, st::Momentum {});
         // the user domain address can be given as multiple comma separated
         // arguments or as one parameter of type user domain
         view({x, y}) = double(x + y) / double(udSize[0] + udSize[1]);
     }
 
-    for(size_t x = 0; x < udSize[0]; ++x) LLAMA_INDEPENDENT_DATA
-    for(size_t y = 0; y < udSize[1]; ++y)
+    for (size_t x = 0; x < udSize[0]; ++x)
+        LLAMA_INDEPENDENT_DATA
+    for (size_t y = 0; y < udSize[1]; ++y)
     {
         // Showing different options of access data with llama. Internally
         // all do the same data- and mappingwise
         auto datum = view(x, y);
-        datum.access<st::Pos, st::X>()
-            += datum.access<llama::DatumCoord<1, 0>>();
-        datum.access(st::Pos(), st::Y())
-            += datum.access(llama::DatumCoord<1, 1>());
+        datum.access<st::Pos, st::X>() += datum.access<llama::DatumCoord<1, 0>>();
+        datum.access(st::Pos(), st::Y()) += datum.access(llama::DatumCoord<1, 1>());
         datum(st::Pos(), st::Z()) += datum(llama::DatumCoord<2>());
 
         // It is also possible to work only on a part of data.
@@ -224,8 +215,10 @@ int main(int argc, char ** argv)
     }
     double sum = 0.0;
     LLAMA_INDEPENDENT_DATA
-    for(size_t x = 0; x < udSize[0]; ++x) LLAMA_INDEPENDENT_DATA
-    for(size_t y = 0; y < udSize[1]; ++y) sum += view(x, y).access<1, 0>();
+    for (size_t x = 0; x < udSize[0]; ++x)
+        LLAMA_INDEPENDENT_DATA
+    for (size_t y = 0; y < udSize[1]; ++y)
+        sum += view(x, y).access<1, 0>();
     std::cout << "Sum: " << sum << '\n';
 
     return 0;
diff --git a/examples/vectoradd/vectoradd.cpp b/examples/vectoradd/vectoradd.cpp
index 27b18850c8..6a9f0ec584 100644
--- a/examples/vectoradd/vectoradd.cpp
+++ b/examples/vectoradd/vectoradd.cpp
@@ -3,8 +3,7 @@
 #include <llama/llama.hpp>
 #include <utility>
 
-constexpr auto MAPPING
-    = 3; /// 0 native AoS, 1 native SoA, 2 tree AoS, 3 tree SoA
+constexpr auto MAPPING = 3; /// 0 native AoS, 1 native SoA, 2 tree AoS, 3 tree SoA
 constexpr auto PROBLEM_SIZE = 64 * 1024 * 1024; ///< problem size
 constexpr auto STEPS = 10; ///< number of vector adds to perform
 
@@ -27,35 +26,34 @@ namespace usellama
      >;
     // clang-format on
 
-    template<typename View>
-    void add(const View & a, const View & b, View & c)
+    template <typename View>
+    void add(const View& a, const View& b, View& c)
     {
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t i = 0; i < PROBLEM_SIZE; i++)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
         {
-            c(i)(tag::X{}) = a(i)(tag::X{}) + b(i)(tag::X{});
-            c(i)(tag::Y{}) = a(i)(tag::Y{}) - b(i)(tag::Y{});
-            c(i)(tag::Z{}) = a(i)(tag::Z{}) * b(i)(tag::Z{});
+            c(i)(tag::X {}) = a(i)(tag::X {}) + b(i)(tag::X {});
+            c(i)(tag::Y {}) = a(i)(tag::Y {}) - b(i)(tag::Y {});
+            c(i)(tag::Z {}) = a(i)(tag::Z {}) * b(i)(tag::Z {});
         }
     }
 
-    int main(int argc, char ** argv)
+    int main(int argc, char** argv)
     {
-        const auto userDomain = llama::UserDomain{PROBLEM_SIZE};
+        const auto userDomain = llama::UserDomain {PROBLEM_SIZE};
 
         const auto mapping = [&] {
-            if constexpr(MAPPING == 0)
-                return llama::mapping::AoS{userDomain, Vector{}};
-            if constexpr(MAPPING == 1)
-                return llama::mapping::SoA{userDomain, Vector{}};
-            if constexpr(MAPPING == 2)
-                return llama::mapping::tree::Mapping{
-                    userDomain, llama::Tuple{}, Vector{}};
-            if constexpr(MAPPING == 3)
-                return llama::mapping::tree::Mapping{
+            if constexpr (MAPPING == 0)
+                return llama::mapping::AoS {userDomain, Vector {}};
+            if constexpr (MAPPING == 1)
+                return llama::mapping::SoA {userDomain, Vector {}};
+            if constexpr (MAPPING == 2)
+                return llama::mapping::tree::Mapping {userDomain, llama::Tuple {}, Vector {}};
+            if constexpr (MAPPING == 3)
+                return llama::mapping::tree::Mapping {
                     userDomain,
-                    llama::Tuple{llama::mapping::tree::functor::LeafOnlyRT()},
-                    Vector{}};
+                    llama::Tuple {llama::mapping::tree::functor::LeafOnlyRT()},
+                    Vector {}};
         }();
 
         std::cout << PROBLEM_SIZE / 1000 / 1000 << " million vectors LLAMA\n";
@@ -67,32 +65,28 @@ namespace usellama
         const auto start = std::chrono::high_resolution_clock::now();
 
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t i = 0; i < PROBLEM_SIZE; ++i)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; ++i)
         {
-            a[i](tag::X{}) = i; // X
+            a[i](tag::X {}) = i; // X
             a[i].access<tag::Y>() = i; // Y
             a[i].access<2>() = i; // Z
             b(i) = i; // writes to all (X, Y, Z)
         }
 
         const auto stop = std::chrono::high_resolution_clock::now();
-        std::cout << "init took "
-                  << std::chrono::duration<double>(stop - start).count()
-                  << "s\n";
+        std::cout << "init took " << std::chrono::duration<double>(stop - start).count() << "s\n";
 
-        for(std::size_t s = 0; s < STEPS; ++s)
+        for (std::size_t s = 0; s < STEPS; ++s)
         {
             const auto start = std::chrono::high_resolution_clock::now();
             add(a, b, c);
             const auto stop = std::chrono::high_resolution_clock::now();
-            std::cout << "add took "
-                      << std::chrono::duration<double>(stop - start).count()
-                      << "s\n";
+            std::cout << "add took " << std::chrono::duration<double>(stop - start).count() << "s\n";
         }
 
-        return (int)c.storageBlobs[0][0];
+        return (int) c.storageBlobs[0][0];
     }
-}
+} // namespace usellama
 
 namespace manualAoS
 {
@@ -103,10 +97,10 @@ namespace manualAoS
         FP z;
     };
 
-    inline void add(const Vector * a, const Vector * b, Vector * c)
+    inline void add(const Vector* a, const Vector* b, Vector* c)
     {
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t i = 0; i < PROBLEM_SIZE; i++)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
         {
             c[i].x = a[i].x + b[i].x;
             c[i].y = a[i].y - b[i].y;
@@ -114,7 +108,7 @@ namespace manualAoS
         }
     }
 
-    int main(int argc, char ** argv)
+    int main(int argc, char** argv)
     {
         std::cout << PROBLEM_SIZE / 1000 / 1000 << " million vectors AoS\n";
 
@@ -125,7 +119,7 @@ namespace manualAoS
         const auto start = std::chrono::high_resolution_clock::now();
 
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t i = 0; i < PROBLEM_SIZE; ++i)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; ++i)
         {
             a[i].x = i;
             a[i].y = i;
@@ -136,39 +130,35 @@ namespace manualAoS
         }
 
         const auto stop = std::chrono::high_resolution_clock::now();
-        std::cout << "init took "
-                  << std::chrono::duration<double>(stop - start).count()
-                  << "s\n";
+        std::cout << "init took " << std::chrono::duration<double>(stop - start).count() << "s\n";
 
-        for(std::size_t s = 0; s < STEPS; ++s)
+        for (std::size_t s = 0; s < STEPS; ++s)
         {
             const auto start = std::chrono::high_resolution_clock::now();
             add(a.data(), b.data(), c.data());
             const auto stop = std::chrono::high_resolution_clock::now();
-            std::cout << "add took "
-                      << std::chrono::duration<double>(stop - start).count()
-                      << "s\n";
+            std::cout << "add took " << std::chrono::duration<double>(stop - start).count() << "s\n";
         }
 
         return c[0].x;
     }
-}
+} // namespace manualAoS
 
 namespace manualSoA
 {
-    inline void
-    add(const FP * ax,
-        const FP * ay,
-        const FP * az,
-        const FP * bx,
-        const FP * by,
-        const FP * bz,
-        FP * cx,
-        FP * cy,
-        FP * cz)
+    inline void add(
+        const FP* ax,
+        const FP* ay,
+        const FP* az,
+        const FP* bx,
+        const FP* by,
+        const FP* bz,
+        FP* cx,
+        FP* cy,
+        FP* cz)
     {
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t i = 0; i < PROBLEM_SIZE; i++)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; i++)
         {
             cx[i] = ax[i] + bx[i];
             cy[i] = ay[i] - by[i];
@@ -176,7 +166,7 @@ namespace manualSoA
         }
     }
 
-    int main(int argc, char ** argv)
+    int main(int argc, char** argv)
     {
         std::cout << PROBLEM_SIZE / 1000 / 1000 << " million vectors SoA\n";
 
@@ -193,7 +183,7 @@ namespace manualSoA
         const auto start = std::chrono::high_resolution_clock::now();
 
         LLAMA_INDEPENDENT_DATA
-        for(std::size_t i = 0; i < PROBLEM_SIZE; ++i)
+        for (std::size_t i = 0; i < PROBLEM_SIZE; ++i)
         {
             ax[i] = i;
             ay[i] = i;
@@ -204,33 +194,21 @@ namespace manualSoA
         }
 
         const auto stop = std::chrono::high_resolution_clock::now();
-        std::cout << "init took "
-                  << std::chrono::duration<double>(stop - start).count()
-                  << "s\n";
+        std::cout << "init took " << std::chrono::duration<double>(stop - start).count() << "s\n";
 
-        for(std::size_t s = 0; s < STEPS; ++s)
+        for (std::size_t s = 0; s < STEPS; ++s)
         {
             const auto start = std::chrono::high_resolution_clock::now();
-            add(ax.data(),
-                ay.data(),
-                az.data(),
-                bx.data(),
-                by.data(),
-                bz.data(),
-                cx.data(),
-                cy.data(),
-                cz.data());
+            add(ax.data(), ay.data(), az.data(), bx.data(), by.data(), bz.data(), cx.data(), cy.data(), cz.data());
             const auto stop = std::chrono::high_resolution_clock::now();
-            std::cout << "add took "
-                      << std::chrono::duration<double>(stop - start).count()
-                      << "s\n";
+            std::cout << "add took " << std::chrono::duration<double>(stop - start).count() << "s\n";
         }
 
         return cx[0];
     }
-}
+} // namespace manualSoA
 
-int main(int argc, char ** argv)
+int main(int argc, char** argv)
 {
     int r = 0;
     r += usellama::main(argc, argv);
diff --git a/include/llama/Allocators.hpp b/include/llama/Allocators.hpp
index 9820d48073..a57b1f7c9e 100644
--- a/include/llama/Allocators.hpp
+++ b/include/llama/Allocators.hpp
@@ -10,7 +10,7 @@
 #include <memory>
 #include <vector>
 #if BOOST_COMP_INTEL != 0
-#include <aligned_new>
+#    include <aligned_new>
 #endif
 
 namespace llama::allocator
@@ -18,11 +18,10 @@ namespace llama::allocator
     /// Allocates stack memory for a \ref View, which is copied each time a \ref
     /// View is copied.
     /// \tparam BytesToReserve the amount of memory to reserve.
-    template<std::size_t BytesToReserve>
+    template <std::size_t BytesToReserve>
     struct Stack
     {
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(std::size_t) const
-            -> Array<std::byte, BytesToReserve>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(std::size_t) const -> Array<std::byte, BytesToReserve>
         {
             return {};
         }
@@ -31,81 +30,71 @@ namespace llama::allocator
     /// Allocates heap memory managed by a `std::shared_ptr` for a \ref View.
     /// This memory is shared between all copies of a \ref View.
     /// \tparam Alignment aligment of the allocated block of memory.
-    template<std::size_t Alignment = 64>
+    template <std::size_t Alignment = 64>
     struct SharedPtr
     {
-        inline auto operator()(std::size_t count) const
-            -> std::shared_ptr<std::byte[]>
+        inline auto operator()(std::size_t count) const -> std::shared_ptr<std::byte[]>
         {
-            auto * ptr = static_cast<std::byte *>(::operator new[](
-                count * sizeof(std::byte), std::align_val_t{Alignment}));
-            auto deleter = [=](std::byte * ptr) {
-                ::operator delete[](ptr, std::align_val_t{Alignment});
-            };
-            return std::shared_ptr<std::byte[]>{ptr, deleter};
+            auto* ptr
+                = static_cast<std::byte*>(::operator new[](count * sizeof(std::byte), std::align_val_t {Alignment}));
+            auto deleter = [=](std::byte* ptr) { ::operator delete[](ptr, std::align_val_t {Alignment}); };
+            return std::shared_ptr<std::byte[]> {ptr, deleter};
         }
     };
 
     namespace internal
     {
-        template<typename T, std::size_t Alignment>
+        template <typename T, std::size_t Alignment>
         struct AlignmentAllocator
         {
             using value_type = T;
 
             inline AlignmentAllocator() noexcept = default;
 
-            template<typename T2>
-            inline AlignmentAllocator(
-                AlignmentAllocator<T2, Alignment> const &) noexcept
-            {}
+            template <typename T2>
+            inline AlignmentAllocator(AlignmentAllocator<T2, Alignment> const&) noexcept
+            {
+            }
 
             inline ~AlignmentAllocator() noexcept = default;
 
-            inline auto allocate(std::size_t n) -> T *
+            inline auto allocate(std::size_t n) -> T*
             {
-                return static_cast<T *>(::operator new[](
-                    n * sizeof(T), std::align_val_t{Alignment}));
+                return static_cast<T*>(::operator new[](n * sizeof(T), std::align_val_t {Alignment}));
             }
 
-            inline void deallocate(T * p, std::size_t)
+            inline void deallocate(T* p, std::size_t)
             {
-                ::operator delete[](p, std::align_val_t{Alignment});
+                ::operator delete[](p, std::align_val_t {Alignment});
             }
 
-            template<typename T2>
+            template <typename T2>
             struct rebind
             {
                 using other = AlignmentAllocator<T2, Alignment>;
             };
 
-            auto
-            operator!=(const AlignmentAllocator<T, Alignment> & other) const
-                -> bool
+            auto operator!=(const AlignmentAllocator<T, Alignment>& other) const -> bool
             {
                 return !(*this == other);
             }
 
-            auto
-            operator==(const AlignmentAllocator<T, Alignment> & other) const
-                -> bool
+            auto operator==(const AlignmentAllocator<T, Alignment>& other) const -> bool
             {
                 return true;
             }
         };
-    }
+    } // namespace internal
 
     /// Allocates heap memory managed by a `std::vector` for a \ref View, which
     /// is copied each time a \ref View is copied.
     /// \tparam Alignment aligment of the allocated block of memory.
-    template<std::size_t Alignment = 64u>
+    template <std::size_t Alignment = 64u>
     struct Vector
     {
         inline auto operator()(std::size_t count) const
         {
-            return std::vector<
-                std::byte,
-                internal::AlignmentAllocator<std::byte, Alignment>>(count);
+            return std::vector<std::byte, internal::AlignmentAllocator<std::byte, Alignment>>(count);
         }
     };
-}
+} // namespace llama::allocator
diff --git a/include/llama/Array.hpp b/include/llama/Array.hpp
index eb34bb2eec..5d57cb9529 100644
--- a/include/llama/Array.hpp
+++ b/include/llama/Array.hpp
@@ -13,88 +13,87 @@ namespace llama
     /// devices like GPUs.
     /// \tparam T type if array elements.
     /// \tparam N rank of the array.
-    template<typename T, std::size_t N>
+    template <typename T, std::size_t N>
     struct Array
     {
         static constexpr std::size_t rank = N;
         T element[N > 0 ? N : 1];
 
-        LLAMA_FN_HOST_ACC_INLINE T * begin()
+        LLAMA_FN_HOST_ACC_INLINE T* begin()
         {
             return &element[0];
         }
 
-        LLAMA_FN_HOST_ACC_INLINE const T * begin() const
+        LLAMA_FN_HOST_ACC_INLINE const T* begin() const
         {
             return &element[0];
         }
 
-        LLAMA_FN_HOST_ACC_INLINE T * end()
+        LLAMA_FN_HOST_ACC_INLINE T* end()
         {
             return &element[N];
         };
 
-        LLAMA_FN_HOST_ACC_INLINE const T * end() const
+        LLAMA_FN_HOST_ACC_INLINE const T* end() const
         {
             return &element[N];
         };
 
-        template<typename IndexType>
-        LLAMA_FN_HOST_ACC_INLINE auto operator[](IndexType && idx) -> T &
+        template <typename IndexType>
+        LLAMA_FN_HOST_ACC_INLINE auto operator[](IndexType&& idx) -> T&
         {
             return element[idx];
         }
 
-        template<typename IndexType>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto
-        operator[](IndexType && idx) const -> T const &
+        template <typename IndexType>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto operator[](IndexType&& idx) const -> T const&
         {
             return element[idx];
         }
 
-        LLAMA_FN_HOST_ACC_INLINE friend auto
-        operator==(const Array<T, N> & a, const Array<T, N> & b) -> bool
+        LLAMA_FN_HOST_ACC_INLINE friend auto operator==(const Array<T, N>& a, const Array<T, N>& b) -> bool
         {
-            for(std::size_t i = 0; i < N; ++i)
-                if(a.element[i] != b.element[i])
+            for (std::size_t i = 0; i < N; ++i)
+                if (a.element[i] != b.element[i])
                     return false;
             return true;
         }
 
-        LLAMA_FN_HOST_ACC_INLINE friend auto
-        operator+(const Array<T, N> & a, const Array<T, N> & b) -> Array
+        LLAMA_FN_HOST_ACC_INLINE friend auto operator+(const Array<T, N>& a, const Array<T, N>& b) -> Array
         {
             Array temp;
-            for(std::size_t i = 0; i < N; ++i) temp[i] = a[i] + b[i];
+            for (std::size_t i = 0; i < N; ++i)
+                temp[i] = a[i] + b[i];
             return temp;
         }
 
-        template<std::size_t I>
-        auto get() -> T &
+        template <std::size_t I>
+        auto get() -> T&
         {
             return element[I];
         }
 
-        template<std::size_t I>
-        auto get() const -> const T &
+        template <std::size_t I>
+        auto get() const -> const T&
         {
             return element[I];
         }
     };
 
-    template<typename First, typename... Args>
+    template <typename First, typename... Args>
     Array(First, Args... args) -> Array<First, sizeof...(Args) + 1>;
-}
+} // namespace llama
 
 namespace std
 {
-    template<typename T, size_t N>
+    template <typename T, size_t N>
     struct tuple_size<llama::Array<T, N>> : integral_constant<size_t, N>
-    {};
+    {
+    };
 
-    template<size_t I, typename T, size_t N>
+    template <size_t I, typename T, size_t N>
     struct tuple_element<I, llama::Array<T, N>>
     {
         using type = T;
     };
-}
+} // namespace std
diff --git a/include/llama/Concepts.hpp b/include/llama/Concepts.hpp
index 89f00a244d..f8dafb1aed 100644
--- a/include/llama/Concepts.hpp
+++ b/include/llama/Concepts.hpp
@@ -2,9 +2,9 @@
 
 #ifdef __cpp_concepts
 
-#include "Types.hpp"
+#    include "Types.hpp"
 
-#include <concepts>
+#    include <concepts>
 
 namespace llama
 {
@@ -18,6 +18,6 @@ namespace llama
         { m.getBlobNrAndOffset(typename M::UserDomain{}) } -> std::same_as<NrAndOffset>;
     };
     // clang-format on
-}
+} // namespace llama
 
 #endif
diff --git a/include/llama/DatumCoord.hpp b/include/llama/DatumCoord.hpp
index 7cc4ec4b18..ca3eb6748a 100644
--- a/include/llama/DatumCoord.hpp
+++ b/include/llama/DatumCoord.hpp
@@ -11,7 +11,7 @@ namespace llama
 {
     /// Represents a coordinate for an element inside the datum domain tree.
     /// \tparam Coords... the compile time coordinate.
-    template<std::size_t... Coords>
+    template <std::size_t... Coords>
     struct DatumCoord
     {
         /// The list of integral coordinates as `boost::mp11::mp_list`.
@@ -22,7 +22,7 @@ namespace llama
         static constexpr std::size_t size = sizeof...(Coords);
     };
 
-    template<>
+    template <>
     struct DatumCoord<>
     {
         using List = boost::mp11::mp_list_c<std::size_t>;
@@ -32,101 +32,94 @@ namespace llama
 
     namespace internal
     {
-        template<class L>
+        template <class L>
         struct mp_unwrap_sizes_impl;
 
-        template<template<class...> class L, typename... T>
+        template <template <class...> class L, typename... T>
         struct mp_unwrap_sizes_impl<L<T...>>
         {
             using type = DatumCoord<T::value...>;
         };
 
-        template<typename L>
+        template <typename L>
         using mp_unwrap_sizes = typename mp_unwrap_sizes_impl<L>::type;
-    }
+    } // namespace internal
 
     /// Converts a type list of integral constants into a \ref DatumCoord.
-    template<typename L>
+    template <typename L>
     using DatumCoordFromList = internal::mp_unwrap_sizes<L>;
 
     /// Concatenate two \ref DatumCoord.
-    template<typename DatumCoord1, typename DatumCoord2>
-    using Cat = DatumCoordFromList<boost::mp11::mp_append<
-        typename DatumCoord1::List,
-        typename DatumCoord2::List>>;
+    template <typename DatumCoord1, typename DatumCoord2>
+    using Cat = DatumCoordFromList<boost::mp11::mp_append<typename DatumCoord1::List, typename DatumCoord2::List>>;
 
     /// Concatenate two \ref DatumCoord instances.
-    template<typename DatumCoord1, typename DatumCoord2>
+    template <typename DatumCoord1, typename DatumCoord2>
     auto cat(DatumCoord1, DatumCoord2)
     {
-        return Cat<DatumCoord1, DatumCoord2>{};
+        return Cat<DatumCoord1, DatumCoord2> {};
     }
 
     /// DatumCoord without first coordinate component.
-    template<typename DatumCoord>
-    using PopFront = DatumCoordFromList<
-        boost::mp11::mp_pop_front<typename DatumCoord::List>>;
+    template <typename DatumCoord>
+    using PopFront = DatumCoordFromList<boost::mp11::mp_pop_front<typename DatumCoord::List>>;
 
     namespace internal
     {
-        template<typename First, typename Second>
+        template <typename First, typename Second>
         struct DatumCoordCommonPrefixIsBiggerImpl;
 
-        template<std::size_t... Coords1, std::size_t... Coords2>
-        struct DatumCoordCommonPrefixIsBiggerImpl<
-            DatumCoord<Coords1...>,
-            DatumCoord<Coords2...>>
+        template <std::size_t... Coords1, std::size_t... Coords2>
+        struct DatumCoordCommonPrefixIsBiggerImpl<DatumCoord<Coords1...>, DatumCoord<Coords2...>>
         {
             static constexpr auto value = []() constexpr
             {
                 // CTAD does not work if Coords1/2 is an empty pack
-                std::array<std::size_t, sizeof...(Coords1)> a1{Coords1...};
-                std::array<std::size_t, sizeof...(Coords2)> a2{Coords2...};
-                for(auto i = 0; i < std::min(a1.size(), a2.size()); i++)
+                std::array<std::size_t, sizeof...(Coords1)> a1 {Coords1...};
+                std::array<std::size_t, sizeof...(Coords2)> a2 {Coords2...};
+                for (auto i = 0; i < std::min(a1.size(), a2.size()); i++)
                 {
-                    if(a1[i] > a2[i])
+                    if (a1[i] > a2[i])
                         return true;
-                    if(a1[i] < a2[i])
+                    if (a1[i] < a2[i])
                         return false;
                 }
                 return false;
             }
             ();
         };
-    }
+    } // namespace internal
 
     /// Checks wether the first DatumCoord is bigger than the second.
-    template<typename First, typename Second>
+    template <typename First, typename Second>
     inline constexpr auto DatumCoordCommonPrefixIsBigger
         = internal::DatumCoordCommonPrefixIsBiggerImpl<First, Second>::value;
 
     namespace internal
     {
-        template<typename First, typename Second>
+        template <typename First, typename Second>
         struct DatumCoordCommonPrefixIsSameImpl;
 
-        template<std::size_t... Coords1, std::size_t... Coords2>
-        struct DatumCoordCommonPrefixIsSameImpl<
-            DatumCoord<Coords1...>,
-            DatumCoord<Coords2...>>
+        template <std::size_t... Coords1, std::size_t... Coords2>
+        struct DatumCoordCommonPrefixIsSameImpl<DatumCoord<Coords1...>, DatumCoord<Coords2...>>
         {
             static constexpr auto value = []() constexpr
             {
                 // CTAD does not work if Coords1/2 is an empty pack
-                std::array<std::size_t, sizeof...(Coords1)> a1{Coords1...};
-                std::array<std::size_t, sizeof...(Coords2)> a2{Coords2...};
-                for(auto i = 0; i < std::min(a1.size(), a2.size()); i++)
-                    if(a1[i] != a2[i])
+                std::array<std::size_t, sizeof...(Coords1)> a1 {Coords1...};
+                std::array<std::size_t, sizeof...(Coords2)> a2 {Coords2...};
+                for (auto i = 0; i < std::min(a1.size(), a2.size()); i++)
+                    if (a1[i] != a2[i])
                         return false;
                 return true;
             }
             ();
         };
-    }
+    } // namespace internal
 
     /// Checks wether two \ref DatumCoord are the same or one is the prefix of
     /// the other.
-    template<typename First, typename Second>
+    template <typename First, typename Second>
     inline constexpr auto DatumCoordCommonPrefixIsSame
         = internal::DatumCoordCommonPrefixIsSameImpl<First, Second>::value;
-}
+} // namespace llama
diff --git a/include/llama/DumpMapping.hpp b/include/llama/DumpMapping.hpp
index 14d1c4297c..fcf81ab74b 100644
--- a/include/llama/DumpMapping.hpp
+++ b/include/llama/DumpMapping.hpp
@@ -14,70 +14,63 @@ namespace llama
 {
     namespace internal
     {
-        template<std::size_t... Coords>
+        template <std::size_t... Coords>
         auto toVec(DatumCoord<Coords...>) -> std::vector<std::size_t>
         {
             return {Coords...};
         }
 
-        template<typename Tag>
+        template <typename Tag>
         auto tagToString(Tag tag)
         {
             return structName(tag);
         }
 
-        template<std::size_t N>
+        template <std::size_t N>
         auto tagToString(Index<N>)
         {
             return std::to_string(N);
         }
 
-        template<
+        template <
             typename DatumDomain,
             std::size_t... CoordsBefore,
             std::size_t CoordCurrent,
             std::size_t... CoordsAfter>
         void collectTagsAsStrings(
-            std::vector<std::string> & v,
+            std::vector<std::string>& v,
             DatumCoord<CoordsBefore...> before,
             DatumCoord<CoordCurrent, CoordsAfter...> after)
         {
-            using Tag = GetTag<
-                DatumDomain,
-                DatumCoord<CoordsBefore..., CoordCurrent>>;
-            v.push_back(tagToString(Tag{}));
-            if constexpr(sizeof...(CoordsAfter) > 0)
+            using Tag = GetTag<DatumDomain, DatumCoord<CoordsBefore..., CoordCurrent>>;
+            v.push_back(tagToString(Tag {}));
+            if constexpr (sizeof...(CoordsAfter) > 0)
                 collectTagsAsStrings<DatumDomain>(
                     v,
-                    DatumCoord<CoordsBefore..., CoordCurrent>{},
-                    DatumCoord<CoordsAfter...>{});
+                    DatumCoord<CoordsBefore..., CoordCurrent> {},
+                    DatumCoord<CoordsAfter...> {});
         }
 
-        template<typename DatumDomain, std::size_t... Coords>
+        template <typename DatumDomain, std::size_t... Coords>
         auto tagsAsStrings(DatumCoord<Coords...>) -> std::vector<std::string>
         {
             std::vector<std::string> v;
-            collectTagsAsStrings<DatumDomain>(
-                v, DatumCoord<>{}, DatumCoord<Coords...>{});
+            collectTagsAsStrings<DatumDomain>(v, DatumCoord<> {}, DatumCoord<Coords...> {});
             return v;
         }
 
-        template<typename Mapping, typename UserDomain, std::size_t... Coords>
-        auto mappingOffset(
-            const Mapping & mapping,
-            const UserDomain & udCoord,
-            DatumCoord<Coords...>)
+        template <typename Mapping, typename UserDomain, std::size_t... Coords>
+        auto mappingOffset(const Mapping& mapping, const UserDomain& udCoord, DatumCoord<Coords...>)
         {
-            return mapping.template getBlobNrAndOffset<Coords...>(udCoord)
-                .offset;
+            return mapping.template getBlobNrAndOffset<Coords...>(udCoord).offset;
         }
-    }
+    } // namespace internal
 
     /// Returns an SVG image visualizing the memory layout created by the given
     /// mapping. The created memory blocks are wrapped after wrapByteCount
     /// bytes.
-    template<typename Mapping>
-    auto toSvg(const Mapping & mapping, int wrapByteCount = 64) -> std::string
+    template <typename Mapping>
+    auto toSvg(const Mapping& mapping, int wrapByteCount = 64) -> std::string
     {
         using UserDomain = typename Mapping::UserDomain;
         using DatumDomain = typename Mapping::DatumDomain;
@@ -94,12 +87,11 @@ namespace llama
         };
         std::vector<DatumInfo> infos;
 
-        for(auto udCoord : UserDomainCoordRange{mapping.userDomainSize})
+        for (auto udCoord : UserDomainCoordRange {mapping.userDomainSize})
         {
             forEach<DatumDomain>([&](auto coord) {
-                constexpr int size
-                    = sizeof(GetType<DatumDomain, decltype(coord)>);
-                infos.push_back(DatumInfo{
+                constexpr int size = sizeof(GetType<DatumDomain, decltype(coord)>);
+                infos.push_back(DatumInfo {
                     udCoord,
                     internal::toVec(coord),
                     internal::tagsAsStrings<DatumDomain>(coord),
@@ -108,26 +100,26 @@ namespace llama
             });
         }
 
-        auto formatDDTags = [](const std::vector<std::string> & tags) {
+        auto formatDDTags = [](const std::vector<std::string>& tags) {
             std::string s;
-            for(const auto & tag : tags)
+            for (const auto& tag : tags)
             {
-                if(!s.empty())
+                if (!s.empty())
                     s += ".";
                 s += tag;
             }
             return s;
         };
 
-        auto formatUdCoord = [](const auto & coord) {
-            if constexpr(std::is_same_v<decltype(coord), llama::UserDomain<1>>)
+        auto formatUdCoord = [](const auto& coord) {
+            if constexpr (std::is_same_v<decltype(coord), llama::UserDomain<1>>)
                 return std::to_string(coord[0]);
             else
             {
                 std::string s = "{";
-                for(auto v : coord)
+                for (auto v : coord)
                 {
-                    if(s.size() >= 2)
+                    if (s.size() >= 2)
                         s += ",";
                     s += std::to_string(v);
                 }
@@ -146,7 +138,7 @@ namespace llama
 )",
             byteSizeInPixel / 2);
 
-        for(const auto & info : infos)
+        for (const auto& info : infos)
         {
             const auto x = (info.offset % wrapByteCount) * byteSizeInPixel;
             const auto y = (info.offset / wrapByteCount) * byteSizeInPixel;
@@ -162,7 +154,7 @@ namespace llama
                 width,
                 byteSizeInPixel,
                 fill);
-            for(auto i = 1; i < info.size; i++)
+            for (auto i = 1; i < info.size; i++)
             {
                 svg += fmt::format(
                     R"(<line x1="{}" y1="{}" x2="{}" y2="{}" stroke="#777"/>
@@ -186,8 +178,8 @@ namespace llama
 
     /// Returns an HTML document visualizing the memory layout created by the
     /// given mapping. The visualization is resizeable.
-    template<typename Mapping>
-    auto toHtml(const Mapping & mapping) -> std::string
+    template <typename Mapping>
+    auto toHtml(const Mapping& mapping) -> std::string
     {
         using UserDomain = typename Mapping::UserDomain;
         using DatumDomain = typename Mapping::DatumDomain;
@@ -206,12 +198,11 @@ namespace llama
         };
         std::vector<DatumInfo> infos;
 
-        for(auto udCoord : UserDomainCoordRange{mapping.userDomainSize})
+        for (auto udCoord : UserDomainCoordRange {mapping.userDomainSize})
         {
             forEach<DatumDomain>([&](auto coord) {
-                constexpr int size
-                    = sizeof(GetType<DatumDomain, decltype(coord)>);
-                infos.push_back(DatumInfo{
+                constexpr int size = sizeof(GetType<DatumDomain, decltype(coord)>);
+                infos.push_back(DatumInfo {
                     udCoord,
                     internal::toVec(coord),
                     internal::tagsAsStrings<DatumDomain>(coord),
@@ -219,44 +210,39 @@ namespace llama
                     size});
             });
         }
-        std::sort(
-            begin(infos),
-            end(infos),
-            [](const DatumInfo & a, const DatumInfo & b) {
-                return a.offset < b.offset;
-            });
+        std::sort(begin(infos), end(infos), [](const DatumInfo& a, const DatumInfo& b) { return a.offset < b.offset; });
 
-        auto formatDDTags = [](const std::vector<std::string> & tags) {
+        auto formatDDTags = [](const std::vector<std::string>& tags) {
             std::string s;
-            for(const auto & tag : tags)
+            for (const auto& tag : tags)
             {
-                if(!s.empty())
+                if (!s.empty())
                     s += ".";
                 s += tag;
             }
             return s;
         };
 
-        auto cssClass = [](const std::vector<std::string> & tags) {
+        auto cssClass = [](const std::vector<std::string>& tags) {
             std::string s;
-            for(const auto & tag : tags)
+            for (const auto& tag : tags)
             {
-                if(!s.empty())
+                if (!s.empty())
                     s += "_";
                 s += tag;
             }
             return s;
         };
 
-        auto formatUdCoord = [](const auto & coord) {
-            if constexpr(std::is_same_v<decltype(coord), llama::UserDomain<1>>)
+        auto formatUdCoord = [](const auto& coord) {
+            if constexpr (std::is_same_v<decltype(coord), llama::UserDomain<1>>)
                 return std::to_string(coord[0]);
             else
             {
                 std::string s = "{";
-                for(auto v : coord)
+                for (auto v : coord)
                 {
-                    if(s.size() >= 2)
+                    if (s.size() >= 2)
                         s += ",";
                     s += std::to_string(v);
                 }
@@ -312,7 +298,7 @@ namespace llama
 <body>
     <header id="ruler">
 )");
-        for(auto i = 0; i < rulerLengthInBytes; i += rulerByteInterval)
+        for (auto i = 0; i < rulerLengthInBytes; i += rulerByteInterval)
             svg += fmt::format(
                 R"(</style>
         <div style="margin-left: {}px;">{}</div>)",
@@ -322,7 +308,7 @@ namespace llama
     </header>
 )");
 
-        for(const auto & info : infos)
+        for (const auto& info : infos)
         {
             const auto bgColor = boost::hash_value(info.ddIndices) & 0xFFFFFF;
 
@@ -337,4 +323,4 @@ namespace llama
 </html>)";
         return svg;
     }
-}
+} // namespace llama
diff --git a/include/llama/ForEach.hpp b/include/llama/ForEach.hpp
index 28bf53e45f..43ed80bf8e 100644
--- a/include/llama/ForEach.hpp
+++ b/include/llama/ForEach.hpp
@@ -12,36 +12,31 @@ namespace llama
 {
     namespace internal
     {
-        template<typename T, std::size_t... Coords, typename Functor>
-        LLAMA_FN_HOST_ACC_INLINE void applyFunctorForEachLeaf(
-            T,
-            DatumCoord<Coords...> coord,
-            Functor && functor)
+        template <typename T, std::size_t... Coords, typename Functor>
+        LLAMA_FN_HOST_ACC_INLINE void applyFunctorForEachLeaf(T, DatumCoord<Coords...> coord, Functor&& functor)
         {
             functor(coord);
         };
 
-        template<typename... Children, std::size_t... Coords, typename Functor>
+        template <typename... Children, std::size_t... Coords, typename Functor>
         LLAMA_FN_HOST_ACC_INLINE void applyFunctorForEachLeaf(
             DatumStruct<Children...>,
             DatumCoord<Coords...>,
-            Functor && functor)
+            Functor&& functor)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            boost::mp11::mp_for_each<
-                boost::mp11::mp_iota_c<sizeof...(Children)>>([&](auto i) {
+            boost::mp11::mp_for_each<boost::mp11::mp_iota_c<sizeof...(Children)>>([&](auto i) {
                 constexpr auto childIndex = decltype(i)::value;
-                using DatumElement = boost::mp11::
-                    mp_at_c<DatumStruct<Children...>, childIndex>;
+                using DatumElement = boost::mp11::mp_at_c<DatumStruct<Children...>, childIndex>;
 
                 LLAMA_FORCE_INLINE_RECURSIVE
                 applyFunctorForEachLeaf(
-                    GetDatumElementType<DatumElement>{},
-                    llama::DatumCoord<Coords..., childIndex>{},
+                    GetDatumElementType<DatumElement> {},
+                    llama::DatumCoord<Coords..., childIndex> {},
                     std::forward<Functor>(functor));
             });
         }
-    }
+    } // namespace internal
 
     /// Iterates over the datum domain tree and calls a functor on each element.
     /// \param functor Functor to execute at each element of. Needs to have
@@ -49,13 +44,12 @@ namespace llama
     /// datum domain tree.
     /// \param baseCoord \ref DatumCoord at which the iteration should be
     /// started. The functor is called on elements beneath this coordinate.
-    template<typename DatumDomain, typename Functor, std::size_t... Coord>
-    LLAMA_FN_HOST_ACC_INLINE void
-    forEach(Functor && functor, DatumCoord<Coord...> baseCoord)
+    template <typename DatumDomain, typename Functor, std::size_t... Coord>
+    LLAMA_FN_HOST_ACC_INLINE void forEach(Functor&& functor, DatumCoord<Coord...> baseCoord)
     {
         LLAMA_FORCE_INLINE_RECURSIVE
         internal::applyFunctorForEachLeaf(
-            GetType<DatumDomain, DatumCoord<Coord...>>{},
+            GetType<DatumDomain, DatumCoord<Coord...>> {},
             baseCoord,
             std::forward<Functor>(functor));
     }
@@ -66,12 +60,10 @@ namespace llama
     /// datum domain tree.
     /// \param baseTags Tags used to define where the iteration should be
     /// started. The functor is called on elements beneath this coordinate.
-    template<typename DatumDomain, typename Functor, typename... Tags>
-    LLAMA_FN_HOST_ACC_INLINE void forEach(Functor && functor, Tags... baseTags)
+    template <typename DatumDomain, typename Functor, typename... Tags>
+    LLAMA_FN_HOST_ACC_INLINE void forEach(Functor&& functor, Tags... baseTags)
     {
         LLAMA_FORCE_INLINE_RECURSIVE
-        forEach<DatumDomain>(
-            std::forward<Functor>(functor),
-            GetCoordFromTags<DatumDomain, Tags...>{});
+        forEach<DatumDomain>(std::forward<Functor>(functor), GetCoordFromTags<DatumDomain, Tags...> {});
     }
-}
+} // namespace llama
diff --git a/include/llama/Functions.hpp b/include/llama/Functions.hpp
index e7be088622..64b4b14793 100644
--- a/include/llama/Functions.hpp
+++ b/include/llama/Functions.hpp
@@ -14,118 +14,90 @@
 namespace llama
 {
     /// Get the tag from a \ref DatumElement.
-    template<typename DatumElement>
+    template <typename DatumElement>
     using GetDatumElementTag = boost::mp11::mp_first<DatumElement>;
 
     /// Get the type from a \ref DatumElement.
-    template<typename DatumElement>
+    template <typename DatumElement>
     using GetDatumElementType = boost::mp11::mp_second<DatumElement>;
 
     namespace internal
     {
-        template<typename T, typename TargetDatumCoord, typename IterCoord>
-        constexpr auto offsetOfImpl(T *, TargetDatumCoord, IterCoord)
+        template <typename T, typename TargetDatumCoord, typename IterCoord>
+        constexpr auto offsetOfImpl(T*, TargetDatumCoord, IterCoord)
         {
-            return sizeof(T)
-                * static_cast<std::size_t>(DatumCoordCommonPrefixIsBigger<
-                                           TargetDatumCoord,
-                                           IterCoord>);
+            return sizeof(T) * static_cast<std::size_t>(DatumCoordCommonPrefixIsBigger<TargetDatumCoord, IterCoord>);
         }
 
-        template<
-            typename... DatumElements,
-            typename TargetDatumCoord,
-            std::size_t... IterCoords>
-        constexpr auto offsetOfImpl(
-            DatumStruct<DatumElements...> *,
-            TargetDatumCoord,
-            DatumCoord<IterCoords...>)
+        template <typename... DatumElements, typename TargetDatumCoord, std::size_t... IterCoords>
+        constexpr auto offsetOfImpl(DatumStruct<DatumElements...>*, TargetDatumCoord, DatumCoord<IterCoords...>)
         {
             std::size_t acc = 0;
-            boost::mp11::mp_for_each<
-                boost::mp11::mp_iota_c<sizeof...(DatumElements)>>([&](
-                auto i) constexpr {
+            boost::mp11::mp_for_each<boost::mp11::mp_iota_c<sizeof...(DatumElements)>>([&](auto i) constexpr {
                 constexpr auto index = decltype(i)::value;
-                using Element = boost::mp11::
-                    mp_at_c<DatumStruct<DatumElements...>, index>;
+                using Element = boost::mp11::mp_at_c<DatumStruct<DatumElements...>, index>;
 
                 acc += offsetOfImpl(
-                    (GetDatumElementType<Element> *)nullptr,
-                    TargetDatumCoord{},
-                    DatumCoord<IterCoords..., index>{});
+                    (GetDatumElementType<Element>*) nullptr,
+                    TargetDatumCoord {},
+                    DatumCoord<IterCoords..., index> {});
             });
             return acc;
         }
-    }
+    } // namespace internal
 
     /// The byte offset of an element in a datum domain if it would be a normal
     /// struct.
     /// \tparam DatumDomain Datum domain tree.
     /// \tparam ElementCoords... Components of a coordinate of an element in
     /// datum domain tree.
-    template<typename DatumDomain, std::size_t... ElementCoords>
-    inline constexpr std::size_t offsetOf = internal::offsetOfImpl(
-        (DatumDomain *)nullptr,
-        DatumCoord<ElementCoords...>{},
-        DatumCoord<>{});
+    template <typename DatumDomain, std::size_t... ElementCoords>
+    inline constexpr std::size_t offsetOf
+        = internal::offsetOfImpl((DatumDomain*) nullptr, DatumCoord<ElementCoords...> {}, DatumCoord<> {});
 
-    template<typename T>
+    template <typename T>
     static constexpr auto sizeOf = sizeof(T);
 
     /// The size a datum domain if it would be a normal struct.
-    template<typename... DatumElements>
-    static constexpr auto sizeOf<DatumStruct<
-        DatumElements...>> = (sizeOf<GetDatumElementType<DatumElements>> + ...);
+    template <typename... DatumElements>
+    static constexpr auto sizeOf<DatumStruct<DatumElements...>> = (sizeOf<GetDatumElementType<DatumElements>> + ...);
 
-    template<typename T>
+    template <typename T>
     inline constexpr auto isDatumStruct = false;
 
-    template<typename... DatumElements>
+    template <typename... DatumElements>
     inline constexpr auto isDatumStruct<DatumStruct<DatumElements...>> = true;
 
     namespace internal
     {
-        template<typename CurrTag, typename DatumDomain, typename DatumCoord>
+        template <typename CurrTag, typename DatumDomain, typename DatumCoord>
         struct GetTagsImpl;
 
-        template<
-            typename CurrTag,
-            typename... DatumElements,
-            std::size_t FirstCoord,
-            std::size_t... Coords>
-        struct GetTagsImpl<
-            CurrTag,
-            DatumStruct<DatumElements...>,
-            DatumCoord<FirstCoord, Coords...>>
+        template <typename CurrTag, typename... DatumElements, std::size_t FirstCoord, std::size_t... Coords>
+        struct GetTagsImpl<CurrTag, DatumStruct<DatumElements...>, DatumCoord<FirstCoord, Coords...>>
         {
-            using DatumElement = boost::mp11::
-                mp_at_c<boost::mp11::mp_list<DatumElements...>, FirstCoord>;
+            using DatumElement = boost::mp11::mp_at_c<boost::mp11::mp_list<DatumElements...>, FirstCoord>;
             using ChildTag = GetDatumElementTag<DatumElement>;
             using ChildType = GetDatumElementType<DatumElement>;
-            using type = boost::mp11::mp_push_front<
-                typename GetTagsImpl<
-                    ChildTag,
-                    ChildType,
-                    DatumCoord<Coords...>>::type,
-                CurrTag>;
+            using type = boost::mp11::
+                mp_push_front<typename GetTagsImpl<ChildTag, ChildType, DatumCoord<Coords...>>::type, CurrTag>;
         };
 
-        template<typename CurrTag, typename T>
+        template <typename CurrTag, typename T>
         struct GetTagsImpl<CurrTag, T, DatumCoord<>>
         {
             using type = boost::mp11::mp_list<CurrTag>;
         };
-    }
+    } // namespace internal
 
     /// Get the tags of all \ref DatumElement from the root of the datum domain
     /// tree until to the node identified by \ref DatumCoord.
-    template<typename DatumDomain, typename DatumCoord>
-    using GetTags =
-        typename internal::GetTagsImpl<NoName, DatumDomain, DatumCoord>::type;
+    template <typename DatumDomain, typename DatumCoord>
+    using GetTags = typename internal::GetTagsImpl<NoName, DatumDomain, DatumCoord>::type;
 
     /// Get the tag of the \ref DatumElement at a \ref DatumCoord inside the
     /// datum domain tree.
-    template<typename DatumDomain, typename DatumCoord>
+    template <typename DatumDomain, typename DatumCoord>
     using GetTag = boost::mp11::mp_back<GetTags<DatumDomain, DatumCoord>>;
 
     /// Is true if, starting at two coordinates in two datum domains, all
@@ -136,160 +108,115 @@ namespace llama
     /// \tparam DatumDomainB second user domain
     /// \tparam LocalB \ref DatumCoord based on StartB along which the tags are
     /// compared.
-    template<
-        typename DatumDomainA,
-        typename LocalA,
-        typename DatumDomainB,
-        typename LocalB>
+    template <typename DatumDomainA, typename LocalA, typename DatumDomainB, typename LocalB>
     inline constexpr auto hasSameTags = []() constexpr
     {
-        if constexpr(LocalA::size != LocalB::size)
+        if constexpr (LocalA::size != LocalB::size)
             return false;
-        else if constexpr(LocalA::size == 0 && LocalB::size == 0)
+        else if constexpr (LocalA::size == 0 && LocalB::size == 0)
             return true;
         else
-            return std::is_same_v<
-                GetTags<DatumDomainA, LocalA>,
-                GetTags<DatumDomainB, LocalB>>;
+            return std::is_same_v<GetTags<DatumDomainA, LocalA>, GetTags<DatumDomainB, LocalB>>;
     }
     ();
 
     namespace internal
     {
-        template<typename DatumDomain, typename DatumCoord, typename... Tags>
+        template <typename DatumDomain, typename DatumCoord, typename... Tags>
         struct GetCoordFromTagsImpl
         {
-            static_assert(
-                boost::mp11::mp_size<DatumDomain>::value != 0,
-                "Tag combination is not valid");
+            static_assert(boost::mp11::mp_size<DatumDomain>::value != 0, "Tag combination is not valid");
         };
 
-        template<
-            typename... DatumElements,
-            std::size_t... ResultCoords,
-            typename FirstTag,
-            typename... Tags>
-        struct GetCoordFromTagsImpl<
-            DatumStruct<DatumElements...>,
-            DatumCoord<ResultCoords...>,
-            FirstTag,
-            Tags...>
+        template <typename... DatumElements, std::size_t... ResultCoords, typename FirstTag, typename... Tags>
+        struct GetCoordFromTagsImpl<DatumStruct<DatumElements...>, DatumCoord<ResultCoords...>, FirstTag, Tags...>
         {
-            template<typename DatumElement>
-            struct HasTag :
-                    std::is_same<GetDatumElementTag<DatumElement>, FirstTag>
-            {};
-
-            static constexpr auto tagIndex = boost::mp11::mp_find_if<
-                boost::mp11::mp_list<DatumElements...>,
-                HasTag>::value;
-            static_assert(
-                tagIndex < sizeof...(DatumElements),
-                "FirstTag was not found inside this DatumStruct");
-
-            using ChildType = GetDatumElementType<
-                boost::mp11::mp_at_c<DatumStruct<DatumElements...>, tagIndex>>;
-
-            using type = typename GetCoordFromTagsImpl<
-                ChildType,
-                DatumCoord<ResultCoords..., tagIndex>,
-                Tags...>::type;
+            template <typename DatumElement>
+            struct HasTag : std::is_same<GetDatumElementTag<DatumElement>, FirstTag>
+            {
+            };
+
+            static constexpr auto tagIndex
+                = boost::mp11::mp_find_if<boost::mp11::mp_list<DatumElements...>, HasTag>::value;
+            static_assert(tagIndex < sizeof...(DatumElements), "FirstTag was not found inside this DatumStruct");
+
+            using ChildType = GetDatumElementType<boost::mp11::mp_at_c<DatumStruct<DatumElements...>, tagIndex>>;
+
+            using type = typename GetCoordFromTagsImpl<ChildType, DatumCoord<ResultCoords..., tagIndex>, Tags...>::type;
         };
 
-        template<typename DatumDomain, typename DatumCoord>
+        template <typename DatumDomain, typename DatumCoord>
         struct GetCoordFromTagsImpl<DatumDomain, DatumCoord>
         {
             using type = DatumCoord;
         };
-    }
+    } // namespace internal
 
     /// Converts a series of tags navigating down a datum domain into a \ref
     /// DatumCoord.
-    template<typename DatumDomain, typename... Tags>
-    using GetCoordFromTags = typename internal::
-        GetCoordFromTagsImpl<DatumDomain, DatumCoord<>, Tags...>::type;
+    template <typename DatumDomain, typename... Tags>
+    using GetCoordFromTags = typename internal::GetCoordFromTagsImpl<DatumDomain, DatumCoord<>, Tags...>::type;
 
     namespace internal
     {
-        template<typename DatumDomain, typename... DatumCoordOrTags>
+        template <typename DatumDomain, typename... DatumCoordOrTags>
         struct GetTypeImpl;
 
-        template<
-            typename... Children,
-            std::size_t HeadCoord,
-            std::size_t... TailCoords>
-        struct GetTypeImpl<
-            DatumStruct<Children...>,
-            DatumCoord<HeadCoord, TailCoords...>>
+        template <typename... Children, std::size_t HeadCoord, std::size_t... TailCoords>
+        struct GetTypeImpl<DatumStruct<Children...>, DatumCoord<HeadCoord, TailCoords...>>
         {
-            using ChildType = GetDatumElementType<
-                boost::mp11::mp_at_c<DatumStruct<Children...>, HeadCoord>>;
-            using type =
-                typename GetTypeImpl<ChildType, DatumCoord<TailCoords...>>::
-                    type;
+            using ChildType = GetDatumElementType<boost::mp11::mp_at_c<DatumStruct<Children...>, HeadCoord>>;
+            using type = typename GetTypeImpl<ChildType, DatumCoord<TailCoords...>>::type;
         };
 
-        template<typename T>
+        template <typename T>
         struct GetTypeImpl<T, DatumCoord<>>
         {
             using type = T;
         };
 
-        template<typename DatumDomain, typename... DatumCoordOrTags>
+        template <typename DatumDomain, typename... DatumCoordOrTags>
         struct GetTypeImpl
         {
-            using type = typename GetTypeImpl<
-                DatumDomain,
-                GetCoordFromTags<DatumDomain, DatumCoordOrTags...>>::type;
+            using type = typename GetTypeImpl<DatumDomain, GetCoordFromTags<DatumDomain, DatumCoordOrTags...>>::type;
         };
-    }
+    } // namespace internal
 
     /// Returns the type of a node in a datum domain tree identified by a given
     /// \ref DatumCoord or a series of tags.
-    template<typename DatumDomain, typename... DatumCoordOrTags>
-    using GetType =
-        typename internal::GetTypeImpl<DatumDomain, DatumCoordOrTags...>::type;
+    template <typename DatumDomain, typename... DatumCoordOrTags>
+    using GetType = typename internal::GetTypeImpl<DatumDomain, DatumCoordOrTags...>::type;
 
     namespace internal
     {
-        template<
-            typename DatumDomain,
-            typename BaseDatumCoord,
-            typename... Tags>
+        template <typename DatumDomain, typename BaseDatumCoord, typename... Tags>
         struct GetCoordFromTagsRelativeImpl
         {
-            using AbsolutCoord = typename internal::GetCoordFromTagsImpl<
-                GetType<DatumDomain, BaseDatumCoord>,
-                BaseDatumCoord,
-                Tags...>::type;
+            using AbsolutCoord = typename internal::
+                GetCoordFromTagsImpl<GetType<DatumDomain, BaseDatumCoord>, BaseDatumCoord, Tags...>::type;
             // Only returning the datum coord relative to BaseDatumCoord
-            using type = DatumCoordFromList<boost::mp11::mp_drop_c<
-                typename AbsolutCoord::List,
-                BaseDatumCoord::size>>;
+            using type = DatumCoordFromList<boost::mp11::mp_drop_c<typename AbsolutCoord::List, BaseDatumCoord::size>>;
         };
-    }
+    } // namespace internal
 
     /// Converts a series of tags navigating down a datum domain, starting at a
     /// given \ref DatumCoord, into a \ref DatumCoord.
-    template<typename DatumDomain, typename BaseDatumCoord, typename... Tags>
+    template <typename DatumDomain, typename BaseDatumCoord, typename... Tags>
     using GetCoordFromTagsRelative =
-        typename internal::GetCoordFromTagsRelativeImpl<
-            DatumDomain,
-            BaseDatumCoord,
-            Tags...>::type;
+        typename internal::GetCoordFromTagsRelativeImpl<DatumDomain, BaseDatumCoord, Tags...>::type;
 
     /// Iterator supporting \ref UserDomainCoordRange.
-    template<std::size_t Dim>
-    struct UserDomainCoordIterator :
-            boost::iterator_facade<
-                UserDomainCoordIterator<Dim>,
-                UserDomain<Dim>,
-                boost::forward_traversal_tag,
-                UserDomain<Dim>>
+    template <std::size_t Dim>
+    struct UserDomainCoordIterator
+        : boost::iterator_facade<
+              UserDomainCoordIterator<Dim>,
+              UserDomain<Dim>,
+              boost::forward_traversal_tag,
+              UserDomain<Dim>>
     {
-        UserDomainCoordIterator(UserDomain<Dim> size, UserDomain<Dim> current) :
-                size(size), current(current)
-        {}
+        UserDomainCoordIterator(UserDomain<Dim> size, UserDomain<Dim> current) : size(size), current(current)
+        {
+        }
 
         auto dereference() const -> UserDomain<Dim>
         {
@@ -298,10 +225,10 @@ namespace llama
 
         void increment()
         {
-            for(auto i = (int)Dim - 1; i >= 0; i--)
+            for (auto i = (int) Dim - 1; i >= 0; i--)
             {
                 current[i]++;
-                if(current[i] != size[i])
+                if (current[i] != size[i])
                     return;
                 current[i] = 0;
             }
@@ -309,7 +236,7 @@ namespace llama
             current[0] = size[0];
         }
 
-        auto equal(const UserDomainCoordIterator & other) const -> bool
+        auto equal(const UserDomainCoordIterator& other) const -> bool
         {
             return size == other.size && current == other.current;
         }
@@ -319,19 +246,21 @@ namespace llama
     };
 
     /// Range allowing to iterate over all indices in a \ref UserDomain.
-    template<std::size_t Dim>
+    template <std::size_t Dim>
     struct UserDomainCoordRange
     {
-        UserDomainCoordRange(UserDomain<Dim> size) : size(size) {}
+        UserDomainCoordRange(UserDomain<Dim> size) : size(size)
+        {
+        }
 
         auto begin() const -> UserDomainCoordIterator<Dim>
         {
-            return {size, UserDomain<Dim>{}};
+            return {size, UserDomain<Dim> {}};
         }
 
         auto end() const -> UserDomainCoordIterator<Dim>
         {
-            UserDomain<Dim> e{};
+            UserDomain<Dim> e {};
             e[0] = size[0];
             return {size, e};
         }
@@ -340,12 +269,12 @@ namespace llama
         UserDomain<Dim> size;
     };
 
-    template<typename S>
+    template <typename S>
     auto structName(S) -> std::string
     {
         auto s = boost::core::demangle(typeid(S).name());
-        if(const auto pos = s.rfind(':'); pos != std::string::npos)
+        if (const auto pos = s.rfind(':'); pos != std::string::npos)
             s = s.substr(pos + 1);
         return s;
     }
-}
+} // namespace llama
diff --git a/include/llama/Tuple.hpp b/include/llama/Tuple.hpp
index fd7d4f6c1f..dfad9b40ab 100644
--- a/include/llama/Tuple.hpp
+++ b/include/llama/Tuple.hpp
@@ -9,14 +9,15 @@ namespace llama
 {
     /// Tuple class like `std::tuple` but suitable for use with offloading
     /// devices like GPUs.
-    template<typename... Elements>
+    template <typename... Elements>
     struct Tuple;
 
-    template<>
+    template <>
     struct Tuple<>
-    {};
+    {
+    };
 
-    template<typename T_FirstElement, typename... Elements>
+    template <typename T_FirstElement, typename... Elements>
     struct Tuple<T_FirstElement, Elements...>
     {
         using FirstElement = T_FirstElement;
@@ -26,20 +27,20 @@ namespace llama
         constexpr Tuple() = default;
 
         LLAMA_FN_HOST_ACC_INLINE
-        constexpr Tuple(FirstElement first, Elements... rest) :
-                first(first), rest(rest...)
-        {}
+        constexpr Tuple(FirstElement first, Elements... rest) : first(first), rest(rest...)
+        {
+        }
 
         LLAMA_FN_HOST_ACC_INLINE
-        constexpr Tuple(FirstElement first, Tuple<Elements...> rest) :
-                first(first), rest(rest)
-        {}
+        constexpr Tuple(FirstElement first, Tuple<Elements...> rest) : first(first), rest(rest)
+        {
+        }
 
         FirstElement first; ///< the first element (if existing)
         RestTuple rest; ///< the remaining elements
     };
 
-    template<typename T_FirstElement>
+    template <typename T_FirstElement>
     struct Tuple<T_FirstElement>
     {
         using FirstElement = T_FirstElement;
@@ -49,150 +50,136 @@ namespace llama
         constexpr Tuple() = default;
 
         LLAMA_FN_HOST_ACC_INLINE
-        constexpr Tuple(
-            FirstElement const first,
-            Tuple<> const rest = Tuple<>()) :
-                first(first)
-        {}
+        constexpr Tuple(FirstElement const first, Tuple<> const rest = Tuple<>()) : first(first)
+        {
+        }
 
         FirstElement first;
     };
 
-    template<typename... Elements>
+    template <typename... Elements>
     Tuple(Elements...) -> Tuple<Elements...>;
 
-    template<typename Tuple, std::size_t Pos>
+    template <typename Tuple, std::size_t Pos>
     using TupleElement = boost::mp11::mp_at_c<Tuple, Pos>;
 
-    template<std::size_t Pos, typename... Elements>
-    LLAMA_FN_HOST_ACC_INLINE auto get(const Tuple<Elements...> & tuple)
+    template <std::size_t Pos, typename... Elements>
+    LLAMA_FN_HOST_ACC_INLINE auto get(const Tuple<Elements...>& tuple)
     {
-        if constexpr(Pos == 0)
+        if constexpr (Pos == 0)
             return tuple.first;
         else
             return get<Pos - 1>(tuple.rest);
     }
 
-    template<typename Tuple>
+    template <typename Tuple>
     inline constexpr auto tupleSize = boost::mp11::mp_size<Tuple>::value;
 
     namespace internal
     {
-        template<typename Tuple1, typename Tuple2, size_t... Is1, size_t... Is2>
+        template <typename Tuple1, typename Tuple2, size_t... Is1, size_t... Is2>
         static LLAMA_FN_HOST_ACC_INLINE auto tupleCatImpl(
-            const Tuple1 & t1,
-            const Tuple2 & t2,
+            const Tuple1& t1,
+            const Tuple2& t2,
             std::index_sequence<Is1...>,
             std::index_sequence<Is2...>)
         {
-            return Tuple{get<Is1>(t1)..., get<Is2>(t2)...};
+            return Tuple {get<Is1>(t1)..., get<Is2>(t2)...};
         }
-    }
+    } // namespace internal
 
-    template<typename Tuple1, typename Tuple2>
-    LLAMA_FN_HOST_ACC_INLINE auto tupleCat(const Tuple1 & t1, const Tuple2 & t2)
+    template <typename Tuple1, typename Tuple2>
+    LLAMA_FN_HOST_ACC_INLINE auto tupleCat(const Tuple1& t1, const Tuple2& t2)
     {
         return internal::tupleCatImpl(
             t1,
             t2,
-            std::make_index_sequence<tupleSize<Tuple1>>{},
-            std::make_index_sequence<tupleSize<Tuple2>>{});
+            std::make_index_sequence<tupleSize<Tuple1>> {},
+            std::make_index_sequence<tupleSize<Tuple2>> {});
     }
 
     namespace internal
     {
-        template<std::size_t Pos, typename Tuple, typename Replacement>
+        template <std::size_t Pos, typename Tuple, typename Replacement>
         struct TupleReplaceImpl
         {
             LLAMA_FN_HOST_ACC_INLINE
             auto operator()(Tuple const tuple, Replacement const replacement)
             {
                 return tupleCat(
-                    llama::Tuple{tuple.first},
-                    TupleReplaceImpl<
-                        Pos - 1,
-                        typename Tuple::RestTuple,
-                        Replacement>()(tuple.rest, replacement));
+                    llama::Tuple {tuple.first},
+                    TupleReplaceImpl<Pos - 1, typename Tuple::RestTuple, Replacement>()(tuple.rest, replacement));
             };
         };
 
-        template<typename... Elements, typename Replacement>
+        template <typename... Elements, typename Replacement>
         struct TupleReplaceImpl<0, Tuple<Elements...>, Replacement>
         {
             LLAMA_FN_HOST_ACC_INLINE
-            auto
-            operator()(Tuple<Elements...> tuple, Replacement const replacement)
+            auto operator()(Tuple<Elements...> tuple, Replacement const replacement)
             {
-                return tupleCat(Tuple{replacement}, tuple.rest);
+                return tupleCat(Tuple {replacement}, tuple.rest);
             };
         };
 
-        template<typename OneElement, typename Replacement>
+        template <typename OneElement, typename Replacement>
         struct TupleReplaceImpl<0, Tuple<OneElement>, Replacement>
         {
             LLAMA_FN_HOST_ACC_INLINE
             auto operator()(Tuple<OneElement>, Replacement const replacement)
             {
-                return Tuple{replacement};
+                return Tuple {replacement};
             }
         };
-    }
+    } // namespace internal
 
     /// Creates a copy of a tuple with the element at position Pos replaced by
     /// replacement.
-    template<std::size_t Pos, typename Tuple, typename Replacement>
-    LLAMA_FN_HOST_ACC_INLINE auto
-    tupleReplace(Tuple tuple, Replacement replacement)
+    template <std::size_t Pos, typename Tuple, typename Replacement>
+    LLAMA_FN_HOST_ACC_INLINE auto tupleReplace(Tuple tuple, Replacement replacement)
     {
-        return internal::TupleReplaceImpl<Pos, Tuple, Replacement>()(
-            tuple, replacement);
+        return internal::TupleReplaceImpl<Pos, Tuple, Replacement>()(tuple, replacement);
     }
 
     namespace internal
     {
-        template<typename Seq>
+        template <typename Seq>
         struct TupleTransformHelper;
 
-        template<size_t... Is>
+        template <size_t... Is>
         struct TupleTransformHelper<std::index_sequence<Is...>>
         {
-            template<typename... Elements, typename Functor>
-            static LLAMA_FN_HOST_ACC_INLINE auto
-            transform(const Tuple<Elements...> & tuple, const Functor & functor)
+            template <typename... Elements, typename Functor>
+            static LLAMA_FN_HOST_ACC_INLINE auto transform(const Tuple<Elements...>& tuple, const Functor& functor)
             {
                 // FIXME(bgruber): nvcc fails to compile
                 // Tuple{functor(get<Is>(tuple))...}
-                return Tuple<decltype(functor(std::declval<Elements>()))...>{
-                    functor(get<Is>(tuple))...};
+                return Tuple<decltype(functor(std::declval<Elements>()))...> {functor(get<Is>(tuple))...};
             }
         };
-    }
+    } // namespace internal
 
     /// Applies a functor to every element of a tuple, creating a new tuple with
     /// the result of the element transformations. The functor needs to
     /// implement a template `operator()` to which all tuple elements are
     /// passed.
     // TODO: replace by mp11 version in Boost 1.74.
-    template<typename... Elements, typename Functor>
-    LLAMA_FN_HOST_ACC_INLINE auto
-    tupleTransform(const Tuple<Elements...> & tuple, const Functor & functor)
+    template <typename... Elements, typename Functor>
+    LLAMA_FN_HOST_ACC_INLINE auto tupleTransform(const Tuple<Elements...>& tuple, const Functor& functor)
     {
-        return internal::TupleTransformHelper<std::make_index_sequence<
-            sizeof...(Elements)>>::transform(tuple, functor);
+        return internal::TupleTransformHelper<std::make_index_sequence<sizeof...(Elements)>>::transform(tuple, functor);
     }
 
     /// Returns a copy of the tuple without the first element.
-    template<typename... Elements>
-    LLAMA_FN_HOST_ACC_INLINE auto
-    tupleWithoutFirst(const Tuple<Elements...> & tuple)
+    template <typename... Elements>
+    LLAMA_FN_HOST_ACC_INLINE auto tupleWithoutFirst(const Tuple<Elements...>& tuple)
     {
         return tuple.rest;
     }
 
-    template<typename Element>
-    LLAMA_FN_HOST_ACC_INLINE auto
-    tupleWithoutFirst(const Tuple<Element> & tuple)
+    template <typename Element>
+    LLAMA_FN_HOST_ACC_INLINE auto tupleWithoutFirst(const Tuple<Element>& tuple)
     {
-        return Tuple<>{};
+        return Tuple<> {};
     }
-}
+} // namespace llama
diff --git a/include/llama/Types.hpp b/include/llama/Types.hpp
index d56ebc3846..d82c93dd03 100644
--- a/include/llama/Types.hpp
+++ b/include/llama/Types.hpp
@@ -13,44 +13,46 @@ namespace llama
     /// Anonymous naming for a \ref DatumElement. Especially used for a \ref
     /// DatumArray.
     struct NoName
-    {};
+    {
+    };
 
     /// The run-time specified user domain.
     /// \tparam Dim compile time dimensionality of the user domain
-    template<std::size_t Dim>
+    template <std::size_t Dim>
     struct UserDomain : Array<std::size_t, Dim>
-    {};
+    {
+    };
 
-    static_assert(std::is_trivially_default_constructible_v<
-                  UserDomain<1>>); // so UserDomain<1>{} will produce a zeroed
-                                   // coord. Should hold for all dimensions, but
-                                   // just checking for <1> here.
+    static_assert(std::is_trivially_default_constructible_v<UserDomain<1>>); // so UserDomain<1>{} will produce a zeroed
+                                                                             // coord. Should hold for all dimensions,
+                                                                             // but just checking for <1> here.
 
-    template<typename... Args>
+    template <typename... Args>
     UserDomain(Args...) -> UserDomain<sizeof...(Args)>;
-}
+} // namespace llama
 
 namespace std
 {
-    template<size_t N>
+    template <size_t N>
     struct tuple_size<llama::UserDomain<N>> : integral_constant<size_t, N>
-    {};
+    {
+    };
 
-    template<size_t I, size_t N>
+    template <size_t I, size_t N>
     struct tuple_element<I, llama::UserDomain<N>>
     {
         using type = size_t;
     };
-}
+} // namespace std
 
 namespace llama
 {
     /// A list of \ref DatumElement which may be used to define a datum domain.
-    template<typename... Leaves>
+    template <typename... Leaves>
     using DatumStruct = boost::mp11::mp_list<Leaves...>;
 
     /// Shortcut alias for \ref DatumStruct.
-    template<typename... Leaves>
+    template <typename... Leaves>
     using DS = DatumStruct<Leaves...>;
 
     /// Datum domain tree node which may either be a leaf or refer to a child
@@ -59,25 +61,25 @@ namespace llama
     /// \tparam Type Type of the node. May be either another sub tree consisting
     /// of a nested \ref DatumStruct or \ref DatumArray or any other type making
     /// it a leaf of this type.
-    template<typename Tag, typename Type>
+    template <typename Tag, typename Type>
     using DatumElement = boost::mp11::mp_list<Tag, Type>;
 
     /// Shortcut alias for \ref DatumElement.
-    template<typename Identifier, typename Type>
+    template <typename Identifier, typename Type>
     using DE = DatumElement<Identifier, Type>;
 
     /// Tag describing an index. Used to access members of a \ref DatumArray.
-    template<std::size_t I>
+    template <std::size_t I>
     using Index = boost::mp11::mp_size_t<I>;
 
     namespace internal
     {
-        template<typename ChildType, std::size_t... Is>
+        template <typename ChildType, std::size_t... Is>
         auto makeDatumArray(std::index_sequence<Is...>)
         {
-            return DatumStruct<DatumElement<Index<Is>, ChildType>...>{};
+            return DatumStruct<DatumElement<Index<Is>, ChildType>...> {};
         }
-    }
+    } // namespace internal
 
     /// An array of identical \ref DatumElement with \ref Index specialized on
     /// consecutive numbers. Can be used anywhere where \ref DatumStruct may
@@ -86,12 +88,11 @@ namespace llama
     /// DatumStruct or DatumArray or any other type making it an array of leaves
     /// of this type.
     /// \tparam Count Number of repetitions of ChildType.
-    template<typename ChildType, std::size_t Count>
-    using DatumArray = decltype(
-        internal::makeDatumArray<ChildType>(std::make_index_sequence<Count>{}));
+    template <typename ChildType, std::size_t Count>
+    using DatumArray = decltype(internal::makeDatumArray<ChildType>(std::make_index_sequence<Count> {}));
 
     /// Shortcut alias for \ref DatumArray
-    template<typename ChildType, std::size_t Count>
+    template <typename ChildType, std::size_t Count>
     using DA = DatumArray<ChildType, Count>;
 
     struct NrAndOffset
@@ -99,4 +100,4 @@ namespace llama
         std::size_t nr;
         std::size_t offset;
     };
-}
+} // namespace llama
diff --git a/include/llama/View.hpp b/include/llama/View.hpp
index 3c3d4dcf48..34507c3b9f 100644
--- a/include/llama/View.hpp
+++ b/include/llama/View.hpp
@@ -15,216 +15,180 @@
 
 namespace llama
 {
-    template<typename Mapping, typename BlobType>
+    template <typename Mapping, typename BlobType>
     struct View;
 
     namespace internal
     {
-        template<typename Allocator>
+        template <typename Allocator>
         using AllocatorBlobType = decltype(std::declval<Allocator>()(0));
 
-        template<typename Allocator, typename Mapping, std::size_t... Is>
+        template <typename Allocator, typename Mapping, std::size_t... Is>
         LLAMA_FN_HOST_ACC_INLINE static auto makeBlobArray(
-            const Allocator & alloc,
-            const Mapping & mapping,
-            std::integer_sequence<std::size_t, Is...>)
-            -> Array<AllocatorBlobType<Allocator>, Mapping::blobCount>
+            const Allocator& alloc,
+            const Mapping& mapping,
+            std::integer_sequence<std::size_t, Is...>) -> Array<AllocatorBlobType<Allocator>, Mapping::blobCount>
         {
             return {alloc(mapping.getBlobSize(Is))...};
         }
-    }
+    } // namespace internal
 
     /// Creates a view based on the given mapping, e.g. \ref mapping::AoS or
     /// \ref mapping::SoA. For allocating the view's underlying memory, the
     /// specified allocator is used (or the default one, which is \ref
     /// allocator::Vector). This function is the preferred way to create a \ref
     /// View.
-    template<typename Mapping, typename Allocator = allocator::Vector<>>
-    LLAMA_FN_HOST_ACC_INLINE auto
-    allocView(Mapping mapping = {}, const Allocator & alloc = {})
+    template <typename Mapping, typename Allocator = allocator::Vector<>>
+    LLAMA_FN_HOST_ACC_INLINE auto allocView(Mapping mapping = {}, const Allocator& alloc = {})
         -> View<Mapping, internal::AllocatorBlobType<Allocator>>
     {
-        auto blobs = internal::makeBlobArray<Allocator>(
-            alloc, mapping, std::make_index_sequence<Mapping::blobCount>{});
+        auto blobs
+            = internal::makeBlobArray<Allocator>(alloc, mapping, std::make_index_sequence<Mapping::blobCount> {});
         return {std::move(mapping), std::move(blobs)};
     }
 
     /// Allocates a \ref View holding a single datum backed by stack memory
     /// (\ref allocator::Stack).
     /// \tparam Dim Dimension of the \ref UserDomain of the \ref View.
-    template<std::size_t Dim, typename DatumDomain>
+    template <std::size_t Dim, typename DatumDomain>
     LLAMA_FN_HOST_ACC_INLINE auto allocViewStack() -> decltype(auto)
     {
         using Mapping = llama::mapping::One<UserDomain<Dim>, DatumDomain>;
-        return allocView(
-            Mapping{}, llama::allocator::Stack<sizeOf<DatumDomain>>{});
+        return allocView(Mapping {}, llama::allocator::Stack<sizeOf<DatumDomain>> {});
     }
 
-    template<typename View>
+    template <typename View>
     inline constexpr auto IsView = false;
 
-    template<typename Mapping, typename BlobType>
+    template <typename Mapping, typename BlobType>
     inline constexpr auto IsView<View<Mapping, BlobType>> = true;
 
-    template<
-        typename View,
-        typename BoundDatumDomain = DatumCoord<>,
-        bool OwnView = false>
+    template <typename View, typename BoundDatumDomain = DatumCoord<>, bool OwnView = false>
     struct VirtualDatum;
 
-    template<typename View>
+    template <typename View>
     inline constexpr auto is_VirtualDatum = false;
 
-    template<typename View, typename BoundDatumDomain, bool OwnView>
-    inline constexpr auto
-        is_VirtualDatum<VirtualDatum<View, BoundDatumDomain, OwnView>> = true;
+    template <typename View, typename BoundDatumDomain, bool OwnView>
+    inline constexpr auto is_VirtualDatum<VirtualDatum<View, BoundDatumDomain, OwnView>> = true;
 
     /// Creates a single \ref VirtualDatum owning a view with stack memory.
-    template<typename DatumDomain>
-    LLAMA_FN_HOST_ACC_INLINE auto allocVirtualDatumStack() -> VirtualDatum<
-        decltype(llama::allocViewStack<1, DatumDomain>()),
-        DatumCoord<>,
-        true>
+    template <typename DatumDomain>
+    LLAMA_FN_HOST_ACC_INLINE auto allocVirtualDatumStack()
+        -> VirtualDatum<decltype(llama::allocViewStack<1, DatumDomain>()), DatumCoord<>, true>
     {
-        return {UserDomain<1>{}, llama::allocViewStack<1, DatumDomain>()};
+        return {UserDomain<1> {}, llama::allocViewStack<1, DatumDomain>()};
     }
 
     /// Creates a single \ref VirtualDatum owning a view with stack memory and
     /// copies all values from an existing \ref VirtualDatum.
-    template<typename VirtualDatum>
-    LLAMA_FN_HOST_ACC_INLINE auto copyVirtualDatumStack(const VirtualDatum & vd)
-        -> decltype(auto)
+    template <typename VirtualDatum>
+    LLAMA_FN_HOST_ACC_INLINE auto copyVirtualDatumStack(const VirtualDatum& vd) -> decltype(auto)
     {
-        auto temp = allocVirtualDatumStack<
-            typename VirtualDatum::AccessibleDatumDomain>();
+        auto temp = allocVirtualDatumStack<typename VirtualDatum::AccessibleDatumDomain>();
         temp = vd;
         return temp;
     }
 
     namespace internal
     {
-        template<
+        template <
             typename Functor,
             typename LeftDatum,
             typename RightView,
             typename RightBoundDatumDomain,
             bool RightOwnView>
         LLAMA_FN_HOST_ACC_INLINE auto virtualDatumArithOperator(
-            LeftDatum & left,
-            const VirtualDatum<RightView, RightBoundDatumDomain, RightOwnView> &
-                right) -> LeftDatum &
-        {
-            using RightDatum
-                = VirtualDatum<RightView, RightBoundDatumDomain, RightOwnView>;
-            forEach<
-                typename LeftDatum::AccessibleDatumDomain>([&](auto leftCoord) {
+            LeftDatum& left,
+            const VirtualDatum<RightView, RightBoundDatumDomain, RightOwnView>& right) -> LeftDatum&
+        {
+            using RightDatum = VirtualDatum<RightView, RightBoundDatumDomain, RightOwnView>;
+            forEach<typename LeftDatum::AccessibleDatumDomain>([&](auto leftCoord) {
                 using LeftInnerCoord = decltype(leftCoord);
-                forEach<typename RightDatum::
-                            AccessibleDatumDomain>([&](auto rightCoord) {
+                forEach<typename RightDatum::AccessibleDatumDomain>([&](auto rightCoord) {
                     using RightInnerCoord = decltype(rightCoord);
-                    if constexpr(hasSameTags<
-                                     typename LeftDatum::AccessibleDatumDomain,
-                                     LeftInnerCoord,
-                                     typename RightDatum::AccessibleDatumDomain,
-                                     RightInnerCoord>)
+                    if constexpr (hasSameTags<
+                                      typename LeftDatum::AccessibleDatumDomain,
+                                      LeftInnerCoord,
+                                      typename RightDatum::AccessibleDatumDomain,
+                                      RightInnerCoord>)
                     {
-                        Functor{}(left(leftCoord), right(rightCoord));
+                        Functor {}(left(leftCoord), right(rightCoord));
                     }
                 });
             });
             return left;
         }
 
-        template<
-            typename Functor,
-            typename LeftDatum,
-            typename RightMapping,
-            typename RightBlobType>
+        template <typename Functor, typename LeftDatum, typename RightMapping, typename RightBlobType>
         LLAMA_FN_HOST_ACC_INLINE auto virtualDatumArithOperator(
-            LeftDatum & left,
-            const View<RightMapping, RightBlobType> & right) -> LeftDatum &
+            LeftDatum& left,
+            const View<RightMapping, RightBlobType>& right) -> LeftDatum&
         {
-            return virtualDatumArithOperator(
-                left, right(UserDomain<RightMapping::UserDomain::rank>{}));
+            return virtualDatumArithOperator(left, right(UserDomain<RightMapping::UserDomain::rank> {}));
         }
 
-        template<typename Functor, typename LeftDatum, typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        virtualDatumArithOperator(LeftDatum & left, const T & right)
-            -> LeftDatum &
+        template <typename Functor, typename LeftDatum, typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto virtualDatumArithOperator(LeftDatum& left, const T& right) -> LeftDatum&
         {
             forEach<typename LeftDatum::AccessibleDatumDomain>(
-                [&](auto leftCoord) { Functor{}(left(leftCoord), right); });
+                [&](auto leftCoord) { Functor {}(left(leftCoord), right); });
             return left;
         }
 
-        template<
+        template <
             typename Functor,
             typename LeftDatum,
             typename RightView,
             typename RightBoundDatumDomain,
             bool RightOwnView>
         LLAMA_FN_HOST_ACC_INLINE auto virtualDatumRelOperator(
-            const LeftDatum & left,
-            const VirtualDatum<RightView, RightBoundDatumDomain, RightOwnView> &
-                right) -> bool
+            const LeftDatum& left,
+            const VirtualDatum<RightView, RightBoundDatumDomain, RightOwnView>& right) -> bool
         {
-            using RightDatum
-                = VirtualDatum<RightView, RightBoundDatumDomain, RightOwnView>;
+            using RightDatum = VirtualDatum<RightView, RightBoundDatumDomain, RightOwnView>;
             bool result = true;
-            forEach<
-                typename LeftDatum::AccessibleDatumDomain>([&](auto leftCoord) {
+            forEach<typename LeftDatum::AccessibleDatumDomain>([&](auto leftCoord) {
                 using LeftInnerCoord = decltype(leftCoord);
-                forEach<typename RightDatum::
-                            AccessibleDatumDomain>([&](auto rightCoord) {
+                forEach<typename RightDatum::AccessibleDatumDomain>([&](auto rightCoord) {
                     using RightInnerCoord = decltype(rightCoord);
-                    if constexpr(hasSameTags<
-                                     typename LeftDatum::AccessibleDatumDomain,
-                                     LeftInnerCoord,
-                                     typename RightDatum::AccessibleDatumDomain,
-                                     RightInnerCoord>)
+                    if constexpr (hasSameTags<
+                                      typename LeftDatum::AccessibleDatumDomain,
+                                      LeftInnerCoord,
+                                      typename RightDatum::AccessibleDatumDomain,
+                                      RightInnerCoord>)
                     {
-                        result &= Functor{}(left(leftCoord), right(rightCoord));
+                        result &= Functor {}(left(leftCoord), right(rightCoord));
                     }
                 });
             });
             return result;
         }
 
-        template<
-            typename Functor,
-            typename LeftDatum,
-            typename RightMapping,
-            typename RightBlobType>
+        template <typename Functor, typename LeftDatum, typename RightMapping, typename RightBlobType>
         LLAMA_FN_HOST_ACC_INLINE auto virtualDatumRelOperator(
-            const LeftDatum & left,
-            const View<RightMapping, RightBlobType> & right) -> bool
+            const LeftDatum& left,
+            const View<RightMapping, RightBlobType>& right) -> bool
         {
-            return virtualDatumRelOperator(
-                left, right(UserDomain<RightMapping::UserDomain::rank>{}));
+            return virtualDatumRelOperator(left, right(UserDomain<RightMapping::UserDomain::rank> {}));
         }
 
-        template<typename Functor, typename LeftDatum, typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        virtualDatumRelOperator(const LeftDatum & left, const T & right) -> bool
+        template <typename Functor, typename LeftDatum, typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto virtualDatumRelOperator(const LeftDatum& left, const T& right) -> bool
         {
             bool result = true;
-            forEach<typename LeftDatum::AccessibleDatumDomain>(
-                [&](auto leftCoord) {
-                    result &= Functor{}(
-                        left(leftCoord),
-                        static_cast<
-                            std::remove_reference_t<decltype(left(leftCoord))>>(
-                            right));
-                });
+            forEach<typename LeftDatum::AccessibleDatumDomain>([&](auto leftCoord) {
+                result &= Functor {}(
+                    left(leftCoord),
+                    static_cast<std::remove_reference_t<decltype(left(leftCoord))>>(right));
+            });
             return result;
         }
 
         struct Assign
         {
-            template<typename A, typename B>
-            LLAMA_FN_HOST_ACC_INLINE decltype(auto)
-            operator()(A & a, const B & b) const
+            template <typename A, typename B>
+            LLAMA_FN_HOST_ACC_INLINE decltype(auto) operator()(A& a, const B& b) const
             {
                 return a = b;
             }
@@ -232,9 +196,8 @@ namespace llama
 
         struct PlusAssign
         {
-            template<typename A, typename B>
-            LLAMA_FN_HOST_ACC_INLINE decltype(auto)
-            operator()(A & a, const B & b) const
+            template <typename A, typename B>
+            LLAMA_FN_HOST_ACC_INLINE decltype(auto) operator()(A& a, const B& b) const
             {
                 return a += b;
             }
@@ -242,9 +205,8 @@ namespace llama
 
         struct MinusAssign
         {
-            template<typename A, typename B>
-            LLAMA_FN_HOST_ACC_INLINE decltype(auto)
-            operator()(A & a, const B & b) const
+            template <typename A, typename B>
+            LLAMA_FN_HOST_ACC_INLINE decltype(auto) operator()(A& a, const B& b) const
             {
                 return a -= b;
             }
@@ -252,9 +214,8 @@ namespace llama
 
         struct MultiplyAssign
         {
-            template<typename A, typename B>
-            LLAMA_FN_HOST_ACC_INLINE decltype(auto)
-            operator()(A & a, const B & b) const
+            template <typename A, typename B>
+            LLAMA_FN_HOST_ACC_INLINE decltype(auto) operator()(A& a, const B& b) const
             {
                 return a *= b;
             }
@@ -262,9 +223,8 @@ namespace llama
 
         struct DivideAssign
         {
-            template<typename A, typename B>
-            LLAMA_FN_HOST_ACC_INLINE decltype(auto)
-            operator()(A & a, const B & b) const
+            template <typename A, typename B>
+            LLAMA_FN_HOST_ACC_INLINE decltype(auto) operator()(A& a, const B& b) const
             {
                 return a /= b;
             }
@@ -272,14 +232,13 @@ namespace llama
 
         struct ModuloAssign
         {
-            template<typename A, typename B>
-            LLAMA_FN_HOST_ACC_INLINE decltype(auto)
-            operator()(A & a, const B & b) const
+            template <typename A, typename B>
+            LLAMA_FN_HOST_ACC_INLINE decltype(auto) operator()(A& a, const B& b) const
             {
                 return a %= b;
             }
         };
-    }
+    } // namespace internal
 
     /// Virtual data type returned by \ref View after resolving a user domain
     /// coordinate or partially resolving a \ref DatumCoord. A virtual datum
@@ -288,7 +247,7 @@ namespace llama
     /// from a \ref View later. Virtual datums should not be created by the
     /// user. They are returned from various access functions in \ref View and
     /// VirtualDatum itself.
-    template<typename T_View, typename BoundDatumDomain, bool OwnView>
+    template <typename T_View, typename BoundDatumDomain, bool OwnView>
     struct VirtualDatum
     {
         using View = T_View; ///< View this virtual datum points into.
@@ -298,7 +257,7 @@ namespace llama
         using DatumDomain = typename View::Mapping::DatumDomain;
 
         const UserDomain userDomainPos;
-        std::conditional_t<OwnView, View, View &> view;
+        std::conditional_t<OwnView, View, View&> view;
 
     public:
         /// Subtree of the datum domain of View starting at
@@ -307,54 +266,49 @@ namespace llama
         using AccessibleDatumDomain = GetType<DatumDomain, BoundDatumDomain>;
 
         LLAMA_FN_HOST_ACC_INLINE
-        VirtualDatum(
-            UserDomain userDomainPos,
-            std::conditional_t<OwnView, View &&, View &> view) :
-                userDomainPos(userDomainPos),
-                view{static_cast<decltype(view)>(view)}
-        {}
+        VirtualDatum(UserDomain userDomainPos, std::conditional_t<OwnView, View&&, View&> view)
+            : userDomainPos(userDomainPos)
+            , view {static_cast<decltype(view)>(view)}
+        {
+        }
 
-        VirtualDatum(const VirtualDatum &) = default;
-        VirtualDatum(VirtualDatum &&) = default;
+        VirtualDatum(const VirtualDatum&) = default;
+        VirtualDatum(VirtualDatum&&) = default;
 
         /// Access a datum in the datum domain underneath the current virtual
         /// datum using a \ref DatumCoord. If the access resolves to a leaf, a
         /// reference to a variable inside the \ref View storage is returned,
         /// otherwise another virtual datum.
-        template<std::size_t... Coord>
-        LLAMA_FN_HOST_ACC_INLINE auto access(DatumCoord<Coord...> = {}) const
-            -> decltype(auto)
+        template <std::size_t... Coord>
+        LLAMA_FN_HOST_ACC_INLINE auto access(DatumCoord<Coord...> = {}) const -> decltype(auto)
         {
             using AbsolutCoord = Cat<BoundDatumDomain, DatumCoord<Coord...>>;
-            if constexpr(isDatumStruct<GetType<DatumDomain, AbsolutCoord>>)
+            if constexpr (isDatumStruct<GetType<DatumDomain, AbsolutCoord>>)
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return VirtualDatum<const View, AbsolutCoord>{
-                    userDomainPos, this->view};
+                return VirtualDatum<const View, AbsolutCoord> {userDomainPos, this->view};
             }
             else
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return this->view.accessor(userDomainPos, AbsolutCoord{});
+                return this->view.accessor(userDomainPos, AbsolutCoord {});
             }
         }
 
         // FIXME(bgruber): remove redundancy
-        template<std::size_t... Coord>
-        LLAMA_FN_HOST_ACC_INLINE auto access(DatumCoord<Coord...> coord = {})
-            -> decltype(auto)
+        template <std::size_t... Coord>
+        LLAMA_FN_HOST_ACC_INLINE auto access(DatumCoord<Coord...> coord = {}) -> decltype(auto)
         {
             using AbsolutCoord = Cat<BoundDatumDomain, DatumCoord<Coord...>>;
-            if constexpr(isDatumStruct<GetType<DatumDomain, AbsolutCoord>>)
+            if constexpr (isDatumStruct<GetType<DatumDomain, AbsolutCoord>>)
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return VirtualDatum<View, AbsolutCoord>{
-                    userDomainPos, this->view};
+                return VirtualDatum<View, AbsolutCoord> {userDomainPos, this->view};
             }
             else
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return this->view.accessor(userDomainPos, AbsolutCoord{});
+                return this->view.accessor(userDomainPos, AbsolutCoord {});
             }
         }
 
@@ -362,186 +316,160 @@ namespace llama
         /// datum using a series of tags. If the access resolves to a leaf, a
         /// reference to a variable inside the \ref View storage is returned,
         /// otherwise another virtual datum.
-        template<typename... Tags>
+        template <typename... Tags>
         LLAMA_FN_HOST_ACC_INLINE auto access(Tags...) const -> decltype(auto)
         {
-            using DatumCoord = GetCoordFromTagsRelative<
-                DatumDomain,
-                BoundDatumDomain,
-                Tags...>;
+            using DatumCoord = GetCoordFromTagsRelative<DatumDomain, BoundDatumDomain, Tags...>;
 
             LLAMA_FORCE_INLINE_RECURSIVE
-            return access(DatumCoord{});
+            return access(DatumCoord {});
         }
 
         // FIXME(bgruber): remove redundancy
-        template<typename... Tags>
+        template <typename... Tags>
         LLAMA_FN_HOST_ACC_INLINE auto access(Tags... uids) -> decltype(auto)
         {
-            using DatumCoord = GetCoordFromTagsRelative<
-                DatumDomain,
-                BoundDatumDomain,
-                Tags...>;
+            using DatumCoord = GetCoordFromTagsRelative<DatumDomain, BoundDatumDomain, Tags...>;
 
             LLAMA_FORCE_INLINE_RECURSIVE
-            return access(DatumCoord{});
+            return access(DatumCoord {});
         }
 
-        template<typename... DatumCoordOrUIDs>
+        template <typename... DatumCoordOrUIDs>
         LLAMA_FN_HOST_ACC_INLINE auto access() const -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return access(DatumCoordOrUIDs{}...);
+            return access(DatumCoordOrUIDs {}...);
         }
 
-        template<typename... DatumCoordOrUIDs>
+        template <typename... DatumCoordOrUIDs>
         LLAMA_FN_HOST_ACC_INLINE auto access() -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return access(DatumCoordOrUIDs{}...);
+            return access(DatumCoordOrUIDs {}...);
         }
 
         /// Calls \ref access with the passed arguments and returns the result.
-        template<typename... DatumCoordOrUIDs>
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(DatumCoordOrUIDs...) const
-            -> decltype(auto)
+        template <typename... DatumCoordOrUIDs>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(DatumCoordOrUIDs...) const -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return access(DatumCoordOrUIDs{}...);
+            return access(DatumCoordOrUIDs {}...);
         }
 
-        template<typename... DatumCoordOrUIDs>
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(DatumCoordOrUIDs...)
-            -> decltype(auto)
+        template <typename... DatumCoordOrUIDs>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(DatumCoordOrUIDs...) -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return access(DatumCoordOrUIDs{}...);
+            return access(DatumCoordOrUIDs {}...);
         }
 
         // we need this one to disable the compiler generated copy assignment
-        LLAMA_FN_HOST_ACC_INLINE auto operator=(const VirtualDatum & other)
-            -> VirtualDatum &
+        LLAMA_FN_HOST_ACC_INLINE auto operator=(const VirtualDatum& other) -> VirtualDatum&
         {
             return this->operator=<VirtualDatum>(other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator=(const T & other)
-            -> VirtualDatum &
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator=(const T& other) -> VirtualDatum&
         {
-            return internal::virtualDatumArithOperator<internal::Assign>(
-                *this, other);
+            return internal::virtualDatumArithOperator<internal::Assign>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator+=(const T & other)
-            -> VirtualDatum &
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator+=(const T& other) -> VirtualDatum&
         {
-            return internal::virtualDatumArithOperator<internal::PlusAssign>(
-                *this, other);
+            return internal::virtualDatumArithOperator<internal::PlusAssign>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator-=(const T & other)
-            -> VirtualDatum &
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator-=(const T& other) -> VirtualDatum&
         {
-            return internal::virtualDatumArithOperator<internal::MinusAssign>(
-                *this, other);
+            return internal::virtualDatumArithOperator<internal::MinusAssign>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator*=(const T & other)
-            -> VirtualDatum &
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator*=(const T& other) -> VirtualDatum&
         {
-            return internal::virtualDatumArithOperator<
-                internal::MultiplyAssign>(*this, other);
+            return internal::virtualDatumArithOperator<internal::MultiplyAssign>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator/=(const T & other)
-            -> VirtualDatum &
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator/=(const T& other) -> VirtualDatum&
         {
-            return internal::virtualDatumArithOperator<internal::DivideAssign>(
-                *this, other);
+            return internal::virtualDatumArithOperator<internal::DivideAssign>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator%=(const T & other)
-            -> VirtualDatum &
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator%=(const T& other) -> VirtualDatum&
         {
-            return internal::virtualDatumArithOperator<internal::ModuloAssign>(
-                *this, other);
+            return internal::virtualDatumArithOperator<internal::ModuloAssign>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator+(const T & other)
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator+(const T& other)
         {
             return copyVirtualDatumStack(*this) += other;
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator-(const T & other)
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator-(const T& other)
         {
             return copyVirtualDatumStack(*this) -= other;
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator*(const T & other)
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator*(const T& other)
         {
             return copyVirtualDatumStack(*this) *= other;
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator/(const T & other)
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator/(const T& other)
         {
             return copyVirtualDatumStack(*this) /= other;
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator%(const T & other)
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator%(const T& other)
         {
             return copyVirtualDatumStack(*this) %= other;
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator==(const T & other) const -> bool
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator==(const T& other) const -> bool
         {
-            return internal::virtualDatumRelOperator<std::equal_to<>>(
-                *this, other);
+            return internal::virtualDatumRelOperator<std::equal_to<>>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator!=(const T & other) const -> bool
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator!=(const T& other) const -> bool
         {
-            return internal::virtualDatumRelOperator<std::not_equal_to<>>(
-                *this, other);
+            return internal::virtualDatumRelOperator<std::not_equal_to<>>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator<(const T & other) const -> bool
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator<(const T& other) const -> bool
         {
             return internal::virtualDatumRelOperator<std::less<>>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator<=(const T & other) const -> bool
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator<=(const T& other) const -> bool
         {
-            return internal::virtualDatumRelOperator<std::less_equal<>>(
-                *this, other);
+            return internal::virtualDatumRelOperator<std::less_equal<>>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator>(const T & other) const -> bool
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator>(const T& other) const -> bool
         {
-            return internal::virtualDatumRelOperator<std::greater<>>(
-                *this, other);
+            return internal::virtualDatumRelOperator<std::greater<>>(*this, other);
         }
 
-        template<typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto operator>=(const T & other) const -> bool
+        template <typename T>
+        LLAMA_FN_HOST_ACC_INLINE auto operator>=(const T& other) const -> bool
         {
-            return internal::virtualDatumRelOperator<std::greater_equal<>>(
-                *this, other);
+            return internal::virtualDatumRelOperator<std::greater_equal<>>(*this, other);
         }
     };
 
@@ -552,86 +480,79 @@ namespace llama
     /// memory.
     /// \tparam BlobType The storage type used by the view holding
     /// memory.
-    template<typename T_Mapping, typename BlobType>
+    template <typename T_Mapping, typename BlobType>
     struct View
     {
         using Mapping = T_Mapping;
         using UserDomain = typename Mapping::UserDomain;
         using DatumDomain = typename Mapping::DatumDomain;
         using VirtualDatumType = VirtualDatum<View<Mapping, BlobType>>;
-        using VirtualDatumTypeConst
-            = VirtualDatum<const View<Mapping, BlobType>>;
+        using VirtualDatumTypeConst = VirtualDatum<const View<Mapping, BlobType>>;
 
         View() = default;
 
         LLAMA_FN_HOST_ACC_INLINE
-        View(
-            Mapping mapping,
-            Array<BlobType, Mapping::blobCount> storageBlobs) :
-                mapping(std::move(mapping)), storageBlobs(storageBlobs)
-        {}
+        View(Mapping mapping, Array<BlobType, Mapping::blobCount> storageBlobs)
+            : mapping(std::move(mapping))
+            , storageBlobs(storageBlobs)
+        {
+        }
 
         /// Retrieves the \ref VirtualDatum at the given \ref UserDomain
         /// coordinate.
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(UserDomain userDomain) const
-            -> decltype(auto)
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(UserDomain userDomain) const -> decltype(auto)
         {
-            if constexpr(isDatumStruct<DatumDomain>)
+            if constexpr (isDatumStruct<DatumDomain>)
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return VirtualDatumTypeConst{userDomain, *this};
+                return VirtualDatumTypeConst {userDomain, *this};
             }
             else
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return accessor(userDomain, DatumCoord<>{});
+                return accessor(userDomain, DatumCoord<> {});
             }
         }
 
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(UserDomain userDomain)
-            -> decltype(auto)
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(UserDomain userDomain) -> decltype(auto)
         {
-            if constexpr(isDatumStruct<DatumDomain>)
+            if constexpr (isDatumStruct<DatumDomain>)
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return VirtualDatumType{userDomain, *this};
+                return VirtualDatumType {userDomain, *this};
             }
             else
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return accessor(userDomain, DatumCoord<>{});
+                return accessor(userDomain, DatumCoord<> {});
             }
         }
 
         /// Retrieves the \ref VirtualDatum at the \ref UserDomain coordinate
         /// constructed from the passed component indices.
-        template<typename... Index>
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(Index... indices) const
-            -> decltype(auto)
+        template <typename... Index>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(Index... indices) const -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return (*this)(UserDomain{indices...});
+            return (*this)(UserDomain {indices...});
         }
 
-        template<typename... Index>
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(Index... indices)
-            -> decltype(auto)
+        template <typename... Index>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(Index... indices) -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return (*this)(UserDomain{indices...});
+            return (*this)(UserDomain {indices...});
         }
 
         /// Retrieves the \ref VirtualDatum at the \ref UserDomain coordinate
         /// constructed from the passed component indices.
-        LLAMA_FN_HOST_ACC_INLINE auto operator[](UserDomain userDomain) const
-            -> decltype(auto)
+        LLAMA_FN_HOST_ACC_INLINE auto operator[](UserDomain userDomain) const -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
             return (*this)(userDomain);
         }
 
-        LLAMA_FN_HOST_ACC_INLINE auto operator[](UserDomain userDomain)
-            -> decltype(auto)
+        LLAMA_FN_HOST_ACC_INLINE auto operator[](UserDomain userDomain) -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
             return (*this)(userDomain);
@@ -639,15 +560,13 @@ namespace llama
 
         /// Retrieves the \ref VirtualDatum at the 1D \ref UserDomain coordinate
         /// constructed from the passed index.
-        LLAMA_FN_HOST_ACC_INLINE auto operator[](std::size_t index) const
-            -> decltype(auto)
+        LLAMA_FN_HOST_ACC_INLINE auto operator[](std::size_t index) const -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
             return (*this)(index);
         }
 
-        LLAMA_FN_HOST_ACC_INLINE auto operator[](std::size_t index)
-            -> decltype(auto)
+        LLAMA_FN_HOST_ACC_INLINE auto operator[](std::size_t index) -> decltype(auto)
         {
             LLAMA_FORCE_INLINE_RECURSIVE
             return (*this)(index);
@@ -657,79 +576,67 @@ namespace llama
         Array<BlobType, Mapping::blobCount> storageBlobs;
 
     private:
-        template<typename T_View, typename T_BoundDatumDomain, bool OwnView>
+        template <typename T_View, typename T_BoundDatumDomain, bool OwnView>
         friend struct VirtualDatum;
 
-        template<std::size_t... Coords>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        accessor(UserDomain userDomain, DatumCoord<Coords...> = {}) const
-            -> const auto &
+        template <std::size_t... Coords>
+        LLAMA_FN_HOST_ACC_INLINE auto accessor(UserDomain userDomain, DatumCoord<Coords...> = {}) const -> const auto&
         {
-            const auto [nr, offset]
-                = mapping.template getBlobNrAndOffset<Coords...>(userDomain);
+            const auto [nr, offset] = mapping.template getBlobNrAndOffset<Coords...>(userDomain);
             using Type = GetType<DatumDomain, DatumCoord<Coords...>>;
-            return reinterpret_cast<const Type &>(storageBlobs[nr][offset]);
+            return reinterpret_cast<const Type&>(storageBlobs[nr][offset]);
         }
 
-        template<std::size_t... Coords>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        accessor(UserDomain userDomain, DatumCoord<Coords...> coord = {})
-            -> auto &
+        template <std::size_t... Coords>
+        LLAMA_FN_HOST_ACC_INLINE auto accessor(UserDomain userDomain, DatumCoord<Coords...> coord = {}) -> auto&
         {
-            const auto [nr, offset]
-                = mapping.template getBlobNrAndOffset<Coords...>(userDomain);
+            const auto [nr, offset] = mapping.template getBlobNrAndOffset<Coords...>(userDomain);
             using Type = GetType<DatumDomain, DatumCoord<Coords...>>;
-            return reinterpret_cast<Type &>(storageBlobs[nr][offset]);
+            return reinterpret_cast<Type&>(storageBlobs[nr][offset]);
         }
     };
 
     /// Acts like a \ref View, but shows only a smaller and/or shifted part of
     /// another view it references, the parent view.
-    template<typename T_ParentViewType>
+    template <typename T_ParentViewType>
     struct VirtualView
     {
         using ParentView = T_ParentViewType; ///< type of the parent view
-        using Mapping =
-            typename ParentView::Mapping; ///< mapping of the parent view
-        using UserDomain =
-            typename Mapping::UserDomain; ///< user domain of the parent view
-        using VirtualDatumType =
-            typename ParentView::VirtualDatumType; ///< VirtualDatum type of the
-                                                   ///< parent view
+        using Mapping = typename ParentView::Mapping; ///< mapping of the parent view
+        using UserDomain = typename Mapping::UserDomain; ///< user domain of the parent view
+        using VirtualDatumType = typename ParentView::VirtualDatumType; ///< VirtualDatum type of the
+                                                                        ///< parent view
 
         /// Creates a VirtualView given a parent \ref View, offset and size.
         LLAMA_FN_HOST_ACC_INLINE
-        VirtualView(
-            ParentView & parentView,
-            UserDomain offset,
-            UserDomain size) :
-                parentView(parentView), offset(offset), size(size)
-        {}
+        VirtualView(ParentView& parentView, UserDomain offset, UserDomain size)
+            : parentView(parentView)
+            , offset(offset)
+            , size(size)
+        {
+        }
 
-        template<std::size_t... Coords>
-        LLAMA_FN_HOST_ACC_INLINE auto accessor(UserDomain userDomain) const
-            -> const auto &
+        template <std::size_t... Coords>
+        LLAMA_FN_HOST_ACC_INLINE auto accessor(UserDomain userDomain) const -> const auto&
         {
             return parentView.template accessor<Coords...>(userDomain + offset);
         }
 
-        template<std::size_t... Coords>
-        LLAMA_FN_HOST_ACC_INLINE auto accessor(UserDomain userDomain) -> auto &
+        template <std::size_t... Coords>
+        LLAMA_FN_HOST_ACC_INLINE auto accessor(UserDomain userDomain) -> auto&
         {
             return parentView.template accessor<Coords...>(userDomain + offset);
         }
 
         /// Same as \ref View::operator()(UserDomain), but shifted by the offset
         /// of this \ref VirtualView.
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(UserDomain userDomain) const
-            -> VirtualDatumType
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(UserDomain userDomain) const -> VirtualDatumType
         {
             LLAMA_FORCE_INLINE_RECURSIVE
             return parentView(userDomain + offset);
         }
 
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(UserDomain userDomain)
-            -> VirtualDatumType
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(UserDomain userDomain) -> VirtualDatumType
         {
             LLAMA_FORCE_INLINE_RECURSIVE
             return parentView(userDomain + offset);
@@ -737,42 +644,37 @@ namespace llama
 
         /// Same as corresponding operator in \ref View, but shifted by the
         /// offset of this \ref VirtualView.
-        template<typename... Indices>
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(Indices... indices) const
-            -> VirtualDatumType
+        template <typename... Indices>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(Indices... indices) const -> VirtualDatumType
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return parentView(UserDomain{indices...} + offset);
+            return parentView(UserDomain {indices...} + offset);
         }
 
-        template<typename... Indices>
-        LLAMA_FN_HOST_ACC_INLINE auto operator()(Indices... indices)
-            -> VirtualDatumType
+        template <typename... Indices>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(Indices... indices) -> VirtualDatumType
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return parentView(UserDomain{indices...} + offset);
+            return parentView(UserDomain {indices...} + offset);
         }
 
-        template<std::size_t... Coord>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        operator()(DatumCoord<Coord...> && dc = {}) const -> const auto &
+        template <std::size_t... Coord>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(DatumCoord<Coord...>&& dc = {}) const -> const auto&
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return accessor<Coord...>(UserDomain{});
+            return accessor<Coord...>(UserDomain {});
         }
 
-        template<std::size_t... Coord>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        operator()(DatumCoord<Coord...> && dc = {}) -> auto &
+        template <std::size_t... Coord>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(DatumCoord<Coord...>&& dc = {}) -> auto&
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            return accessor<Coord...>(UserDomain{});
+            return accessor<Coord...>(UserDomain {});
         }
 
-        ParentView & parentView; ///< reference to parent view.
-        const UserDomain
-            offset; ///< offset this view's \ref UserDomain coordinates are
-                    ///< shifted to the parent view.
+        ParentView& parentView; ///< reference to parent view.
+        const UserDomain offset; ///< offset this view's \ref UserDomain coordinates are
+                                 ///< shifted to the parent view.
         const UserDomain size;
     };
-}
+} // namespace llama
diff --git a/include/llama/macros.hpp b/include/llama/macros.hpp
index b625c889e2..396831ab1e 100644
--- a/include/llama/macros.hpp
+++ b/include/llama/macros.hpp
@@ -6,29 +6,28 @@
 #include <boost/predef.h>
 
 #if BOOST_COMP_INTEL == 0 // Work around for broken intel detection
-#if defined(__INTEL_COMPILER)
-#ifdef BOOST_COMP_INTEL_DETECTION
-#undef BOOST_COMP_INTEL_DETECTION
-#endif
-#define BOOST_COMP_INTEL_DETECTION BOOST_PREDEF_MAKE_10_VVRR(__INTEL_COMPILER)
-#if defined(BOOST_COMP_INTEL)
-#undef BOOST_COMP_INTEL
-#endif
-#define BOOST_COMP_INTEL BOOST_COMP_INTEL_DETECTION
-#endif
+#    if defined(__INTEL_COMPILER)
+#        ifdef BOOST_COMP_INTEL_DETECTION
+#            undef BOOST_COMP_INTEL_DETECTION
+#        endif
+#        define BOOST_COMP_INTEL_DETECTION BOOST_PREDEF_MAKE_10_VVRR(__INTEL_COMPILER)
+#        if defined(BOOST_COMP_INTEL)
+#            undef BOOST_COMP_INTEL
+#        endif
+#        define BOOST_COMP_INTEL BOOST_COMP_INTEL_DETECTION
+#    endif
 #endif
 
 #if BOOST_COMP_GNUC != 0
-#define LLAMA_INDEPENDENT_DATA _Pragma("GCC ivdep")
+#    define LLAMA_INDEPENDENT_DATA _Pragma("GCC ivdep")
 #elif BOOST_COMP_INTEL != 0
-#define LLAMA_INDEPENDENT_DATA _Pragma("ivdep")
+#    define LLAMA_INDEPENDENT_DATA _Pragma("ivdep")
 #elif BOOST_COMP_CLANG
-#define LLAMA_INDEPENDENT_DATA \
-    _Pragma("clang loop vectorize(enable)") \
-        _Pragma("clang loop interleave(enable)") \
+#    define LLAMA_INDEPENDENT_DATA                                                                                     \
+        _Pragma("clang loop vectorize(enable)") _Pragma("clang loop interleave(enable)")                               \
             _Pragma("clang loop distribute(enable)")
 #elif defined(_MSC_VER)
-#define LLAMA_INDEPENDENT_DATA __pragma(loop(ivdep))
+#    define LLAMA_INDEPENDENT_DATA __pragma(loop(ivdep))
 #else
 /// May be put in front of a loop statement. Indicates that all (!) data access
 /// inside the loop is indepent, so the loop can be safely vectorized. Example:
@@ -39,17 +38,17 @@
 ///         // do not overlap and the operation can safely be vectorized
 ///         a[i] += b[i];
 /// \endcode
-#define LLAMA_INDEPENDENT_DATA
+#    define LLAMA_INDEPENDENT_DATA
 #endif
 
 #ifndef LLAMA_FN_HOST_ACC_INLINE
-#if BOOST_COMP_NVCC != 0
-#define LLAMA_FN_HOST_ACC_INLINE __forceinline__
-#elif BOOST_COMP_GNUC != 0
-#define LLAMA_FN_HOST_ACC_INLINE inline __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#define LLAMA_FN_HOST_ACC_INLINE __forceinline
-#else
+#    if BOOST_COMP_NVCC != 0
+#        define LLAMA_FN_HOST_ACC_INLINE __forceinline__
+#    elif BOOST_COMP_GNUC != 0
+#        define LLAMA_FN_HOST_ACC_INLINE inline __attribute__((always_inline))
+#    elif defined(_MSC_VER)
+#        define LLAMA_FN_HOST_ACC_INLINE __forceinline
+#    else
 /// Some offloading parallelization language extensions such a CUDA, OpenACC or
 /// OpenMP 4.5 need to specify whether a class, struct, function or method
 /// "resides" on the host, the accelerator (the offloading device) or both.
@@ -58,18 +57,18 @@
 /// href="https://github.com/ComputationalRadiationPhysics/alpaka">alpaka</a>)
 /// this macro should be defined on the compiler's command line. E.g. for
 /// alpaka: -D'LLAMA_FN_HOST_ACC_INLINE=ALPAKA_FN_HOST_ACC'
-#define LLAMA_FN_HOST_ACC_INLINE inline
-#endif
+#        define LLAMA_FN_HOST_ACC_INLINE inline
+#    endif
 #endif
 
 #if BOOST_COMP_INTEL != 0
-#define LLAMA_FORCE_INLINE_RECURSIVE _Pragma("forceinline recursive")
+#    define LLAMA_FORCE_INLINE_RECURSIVE _Pragma("forceinline recursive")
 #elif defined(_MSC_VER)
-#define LLAMA_FORCE_INLINE_RECURSIVE __pragma(inline_depth(255))
+#    define LLAMA_FORCE_INLINE_RECURSIVE __pragma(inline_depth(255))
 #else
 /// Forces the compiler to recursively inline the call hiearchy started by the
 /// subsequent function call.
-#define LLAMA_FORCE_INLINE_RECURSIVE
+#    define LLAMA_FORCE_INLINE_RECURSIVE
 #endif
 
 /// Forces a copy of a value. This is useful to prevent ODR usage of constants
diff --git a/include/llama/mapping/AoS.hpp b/include/llama/mapping/AoS.hpp
index 3c5f3cd369..6ac7945fb5 100644
--- a/include/llama/mapping/AoS.hpp
+++ b/include/llama/mapping/AoS.hpp
@@ -12,7 +12,7 @@ namespace llama::mapping
     /// \tparam LinearizeUserDomainFunctor Defines how the
     /// user domain should be mapped into linear numbers and how big the linear
     /// domain gets.
-    template<
+    template <
         typename T_UserDomain,
         typename T_DatumDomain,
         typename LinearizeUserDomainFunctor = LinearizeUserDomainCpp>
@@ -25,27 +25,24 @@ namespace llama::mapping
         AoS() = default;
 
         LLAMA_FN_HOST_ACC_INLINE
-        AoS(UserDomain size, DatumDomain = {}) : userDomainSize(size) {}
+        AoS(UserDomain size, DatumDomain = {}) : userDomainSize(size)
+        {
+        }
 
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobSize(std::size_t) const
-            -> std::size_t
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobSize(std::size_t) const -> std::size_t
         {
-            return LinearizeUserDomainFunctor{}.size(userDomainSize)
-                * sizeOf<DatumDomain>;
+            return LinearizeUserDomainFunctor {}.size(userDomainSize) * sizeOf<DatumDomain>;
         }
 
-        template<std::size_t... DatumDomainCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const
-            -> NrAndOffset
+        template <std::size_t... DatumDomainCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const -> NrAndOffset
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            const auto offset
-                = LinearizeUserDomainFunctor{}(coord, userDomainSize)
-                    * sizeOf<
-                        DatumDomain> + offsetOf<DatumDomain, DatumDomainCoord...>;
+            const auto offset = LinearizeUserDomainFunctor {}(coord, userDomainSize)
+                    * sizeOf<DatumDomain> + offsetOf<DatumDomain, DatumDomainCoord...>;
             return {0, offset};
         }
 
         UserDomain userDomainSize;
     };
-}
+} // namespace llama::mapping
diff --git a/include/llama/mapping/AoSoA.hpp b/include/llama/mapping/AoSoA.hpp
index de775776b4..f2972aebdb 100644
--- a/include/llama/mapping/AoSoA.hpp
+++ b/include/llama/mapping/AoSoA.hpp
@@ -14,7 +14,7 @@ namespace llama::mapping
     /// \tparam LinearizeUserDomainFunctor Defines how the
     /// user domain should be mapped into linear numbers and how big the linear
     /// domain gets.
-    template<
+    template <
         typename T_UserDomain,
         typename T_DatumDomain,
         std::size_t Lanes,
@@ -28,30 +28,27 @@ namespace llama::mapping
         AoSoA() = default;
 
         LLAMA_FN_HOST_ACC_INLINE
-        AoSoA(UserDomain size, DatumDomain = {}) : userDomainSize(size) {}
+        AoSoA(UserDomain size, DatumDomain = {}) : userDomainSize(size)
+        {
+        }
 
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobSize(std::size_t) const
-            -> std::size_t
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobSize(std::size_t) const -> std::size_t
         {
-            return LinearizeUserDomainFunctor{}.size(userDomainSize)
-                * sizeOf<DatumDomain>;
+            return LinearizeUserDomainFunctor {}.size(userDomainSize) * sizeOf<DatumDomain>;
         }
 
-        template<std::size_t... DatumDomainCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const
-            -> NrAndOffset
+        template <std::size_t... DatumDomainCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const -> NrAndOffset
         {
-            const auto userDomainIndex
-                = LinearizeUserDomainFunctor{}(coord, userDomainSize);
+            const auto userDomainIndex = LinearizeUserDomainFunctor {}(coord, userDomainSize);
             const auto blockIndex = userDomainIndex / Lanes;
             const auto laneIndex = userDomainIndex % Lanes;
             const auto offset = (sizeOf<DatumDomain> * Lanes) * blockIndex
                 + offsetOf<DatumDomain, DatumDomainCoord...> * Lanes
-                + sizeof(GetType<DatumDomain, DatumCoord<DatumDomainCoord...>>)
-                    * laneIndex;
+                + sizeof(GetType<DatumDomain, DatumCoord<DatumDomainCoord...>>) * laneIndex;
             return {0, offset};
         }
 
         UserDomain userDomainSize;
     };
-}
+} // namespace llama::mapping
diff --git a/include/llama/mapping/Common.hpp b/include/llama/mapping/Common.hpp
index fb79199423..b44942d508 100644
--- a/include/llama/mapping/Common.hpp
+++ b/include/llama/mapping/Common.hpp
@@ -11,23 +11,22 @@ namespace llama::mapping
 {
     namespace internal
     {
-        template<std::size_t Dim>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto
-        product(const UserDomain<Dim> & size) -> std::size_t
+        template <std::size_t Dim>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto product(const UserDomain<Dim>& size) -> std::size_t
         {
             std::size_t prod = 1;
-            for(auto s : size) prod *= s;
+            for (auto s : size)
+                prod *= s;
             return prod;
         }
-    }
+    } // namespace internal
 
     /// Functor that maps a \ref UserDomain coordinate into linear numbers the
     /// way C++ arrays work.
     struct LinearizeUserDomainCpp
     {
-        template<std::size_t Dim>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto
-        size(const UserDomain<Dim> & size) -> std::size_t
+        template <std::size_t Dim>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto size(const UserDomain<Dim>& size) -> std::size_t
         {
             return internal::product(size);
         }
@@ -37,13 +36,12 @@ namespace llama::mapping
          * \param size total size of the user domain
          * \return linearized index
          * */
-        template<std::size_t Dim>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto operator()(
-            const UserDomain<Dim> & coord,
-            const UserDomain<Dim> & size) const -> std::size_t
+        template <std::size_t Dim>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto operator()(const UserDomain<Dim>& coord, const UserDomain<Dim>& size)
+            const -> std::size_t
         {
             std::size_t address = coord[0];
-            for(auto i = 1; i < Dim; i++)
+            for (auto i = 1; i < Dim; i++)
             {
                 address *= size[i];
                 address += coord[i];
@@ -56,9 +54,8 @@ namespace llama::mapping
     /// way Fortran arrays work.
     struct LinearizeUserDomainFortran
     {
-        template<std::size_t Dim>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto
-        size(const UserDomain<Dim> & size) -> std::size_t
+        template <std::size_t Dim>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto size(const UserDomain<Dim>& size) -> std::size_t
         {
             return internal::product(size);
         }
@@ -68,13 +65,12 @@ namespace llama::mapping
          * \param size total size of the user domain
          * \return linearized index
          * */
-        template<std::size_t Dim>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto operator()(
-            const UserDomain<Dim> & coord,
-            const UserDomain<Dim> & size) const -> std::size_t
+        template <std::size_t Dim>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto operator()(const UserDomain<Dim>& coord, const UserDomain<Dim>& size)
+            const -> std::size_t
         {
             std::size_t address = coord[Dim - 1];
-            for(int i = (int)Dim - 2; i >= 0; i--)
+            for (int i = (int) Dim - 2; i >= 0; i--)
             {
                 address *= size[i];
                 address += coord[i];
@@ -87,46 +83,41 @@ namespace llama::mapping
     /// the Z-order space filling curve (Morton codes).
     struct LinearizeUserDomainMorton
     {
-        template<std::size_t Dim>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto
-        size(const UserDomain<Dim> & size) const -> std::size_t
+        template <std::size_t Dim>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto size(const UserDomain<Dim>& size) const -> std::size_t
         {
             std::size_t longest = size[0];
-            for(auto i = 1; i < Dim; i++) longest = std::max(longest, size[i]);
+            for (auto i = 1; i < Dim; i++)
+                longest = std::max(longest, size[i]);
             const auto longestPO2 = bit_ceil(longest);
             return intPow(longestPO2, Dim);
         }
 
-        template<std::size_t Dim>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto
-        operator()(const UserDomain<Dim> & coord, const UserDomain<Dim> &) const
+        template <std::size_t Dim>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto operator()(const UserDomain<Dim>& coord, const UserDomain<Dim>&) const
             -> std::size_t
         {
             std::size_t r = 0;
-            for(std::size_t bit = 0;
-                bit < (sizeof(std::size_t) * CHAR_BIT) / Dim;
-                bit++)
-                for(std::size_t i = 0; i < Dim; i++)
-                    r |= (coord[i] & (std::size_t{1} << bit))
-                        << ((bit + 1) * (Dim - 1) - i);
+            for (std::size_t bit = 0; bit < (sizeof(std::size_t) * CHAR_BIT) / Dim; bit++)
+                for (std::size_t i = 0; i < Dim; i++)
+                    r |= (coord[i] & (std::size_t {1} << bit)) << ((bit + 1) * (Dim - 1) - i);
             return r;
         }
 
     private:
-        LLAMA_FN_HOST_ACC_INLINE static constexpr auto bit_ceil(std::size_t n)
-            -> std::size_t
+        LLAMA_FN_HOST_ACC_INLINE static constexpr auto bit_ceil(std::size_t n) -> std::size_t
         {
             std::size_t r = 1;
-            while(r < n) r <<= 1;
+            while (r < n)
+                r <<= 1;
             return r;
         }
 
-        LLAMA_FN_HOST_ACC_INLINE static constexpr auto
-        intPow(std::size_t b, std::size_t e) -> std::size_t
+        LLAMA_FN_HOST_ACC_INLINE static constexpr auto intPow(std::size_t b, std::size_t e) -> std::size_t
         {
             e--;
             auto r = b;
-            while(e)
+            while (e)
             {
                 r *= b;
                 e--;
@@ -134,4 +125,4 @@ namespace llama::mapping
             return r;
         }
     };
-}
+} // namespace llama::mapping
diff --git a/include/llama/mapping/One.hpp b/include/llama/mapping/One.hpp
index c06bd0b15a..117e619bc3 100644
--- a/include/llama/mapping/One.hpp
+++ b/include/llama/mapping/One.hpp
@@ -11,7 +11,7 @@ namespace llama::mapping
     /// Maps all UserDomain coordinates into the same location and layouts
     /// struct members consecutively. This mapping is used for temporary, single
     /// element views.
-    template<typename T_UserDomain, typename T_DatumDomain>
+    template <typename T_UserDomain, typename T_DatumDomain>
     struct One
     {
         using UserDomain = T_UserDomain;
@@ -19,18 +19,16 @@ namespace llama::mapping
 
         static constexpr std::size_t blobCount = 1;
 
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobSize(std::size_t) const
-            -> std::size_t
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobSize(std::size_t) const -> std::size_t
         {
             return sizeOf<DatumDomain>;
         }
 
-        template<std::size_t... DatumDomainCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain) const
-            -> NrAndOffset
+        template <std::size_t... DatumDomainCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain) const -> NrAndOffset
         {
             constexpr auto offset = offsetOf<DatumDomain, DatumDomainCoord...>;
             return {0, offset};
         }
     };
-}
+} // namespace llama::mapping
diff --git a/include/llama/mapping/SoA.hpp b/include/llama/mapping/SoA.hpp
index caa0f6df64..07ebd81e42 100644
--- a/include/llama/mapping/SoA.hpp
+++ b/include/llama/mapping/SoA.hpp
@@ -13,7 +13,7 @@ namespace llama::mapping
     /// \tparam LinearizeUserDomainFunctor Defines how the
     /// user domain should be mapped into linear numbers and how big the linear
     /// domain gets.
-    template<
+    template <
         typename T_UserDomain,
         typename T_DatumDomain,
         typename LinearizeUserDomainFunctor = LinearizeUserDomainCpp>
@@ -26,30 +26,26 @@ namespace llama::mapping
         SoA() = default;
 
         LLAMA_FN_HOST_ACC_INLINE
-        SoA(UserDomain size, DatumDomain = {}) : userDomainSize(size) {}
+        SoA(UserDomain size, DatumDomain = {}) : userDomainSize(size)
+        {
+        }
 
         LLAMA_FN_HOST_ACC_INLINE
         auto getBlobSize(std::size_t const) const -> std::size_t
         {
-            return LinearizeUserDomainFunctor{}.size(userDomainSize)
-                * sizeOf<DatumDomain>;
+            return LinearizeUserDomainFunctor {}.size(userDomainSize) * sizeOf<DatumDomain>;
         }
 
-        template<std::size_t... DatumDomainCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const
-            -> NrAndOffset
+        template <std::size_t... DatumDomainCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const -> NrAndOffset
         {
             LLAMA_FORCE_INLINE_RECURSIVE
-            const auto offset
-                = LinearizeUserDomainFunctor{}(coord, userDomainSize)
-                    * sizeof(
-                        GetType<DatumDomain, DatumCoord<DatumDomainCoord...>>)
-                + offsetOf<
-                      DatumDomain,
-                      DatumDomainCoord...> * LinearizeUserDomainFunctor{}.size(userDomainSize);
+            const auto offset = LinearizeUserDomainFunctor {}(coord, userDomainSize)
+                    * sizeof(GetType<DatumDomain, DatumCoord<DatumDomainCoord...>>)
+                + offsetOf<DatumDomain, DatumDomainCoord...> * LinearizeUserDomainFunctor {}.size(userDomainSize);
             return {0, offset};
         }
 
         UserDomain userDomainSize = {};
     };
-}
+} // namespace llama::mapping
diff --git a/include/llama/mapping/Trace.hpp b/include/llama/mapping/Trace.hpp
index 5695781c10..e33c3dcc57 100644
--- a/include/llama/mapping/Trace.hpp
+++ b/include/llama/mapping/Trace.hpp
@@ -14,25 +14,25 @@ namespace llama::mapping
 {
     namespace internal
     {
-        template<typename DatumDomain, std::size_t... Coords>
+        template <typename DatumDomain, std::size_t... Coords>
         auto coordName(DatumCoord<Coords...>) -> std::string
         {
             using Tags = GetTags<DatumDomain, DatumCoord<Coords...>>;
 
             std::string r;
             boost::mp11::mp_for_each<Tags>([&](auto tag) {
-                if(!r.empty())
+                if (!r.empty())
                     r += '.';
                 r += structName(tag);
             });
             return r;
         }
-    }
+    } // namespace internal
 
     /// Forwards all calls to the inner mapping. Traces all accesses made
     /// through this mapping and prints a summary on destruction.
     /// \tparam Mapping The type of the inner mapping.
-    template<typename Mapping>
+    template <typename Mapping>
     struct Trace
     {
         using UserDomain = typename Mapping::UserDomain;
@@ -44,48 +44,41 @@ namespace llama::mapping
         LLAMA_FN_HOST_ACC_INLINE
         Trace(Mapping mapping) : mapping(mapping)
         {
-            forEach<DatumDomain>([&](auto coord) {
-                datumHits[internal::coordName<DatumDomain>(coord)] = 0;
-            });
+            forEach<DatumDomain>([&](auto coord) { datumHits[internal::coordName<DatumDomain>(coord)] = 0; });
         }
 
-        Trace(const Trace &) = delete;
-        auto operator=(const Trace &) -> Trace & = delete;
+        Trace(const Trace&) = delete;
+        auto operator=(const Trace&) -> Trace& = delete;
 
-        Trace(Trace &&) noexcept = default;
-        auto operator=(Trace &&) noexcept -> Trace & = default;
+        Trace(Trace&&) noexcept = default;
+        auto operator=(Trace&&) noexcept -> Trace& = default;
 
         ~Trace()
         {
-            if(!datumHits.empty())
+            if (!datumHits.empty())
             {
                 std::cout << "Trace mapping, number of accesses:\n";
-                for(const auto & [k, v] : datumHits)
+                for (const auto& [k, v] : datumHits)
                     std::cout << '\t' << k << ":\t" << v << '\n';
             }
         }
 
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobSize(std::size_t i) const
-            -> std::size_t
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobSize(std::size_t i) const -> std::size_t
         {
             LLAMA_FORCE_INLINE_RECURSIVE
             return mapping.getBlobSize(i);
         }
 
-        template<std::size_t... DatumDomainCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const
-            -> NrAndOffset
+        template <std::size_t... DatumDomainCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const -> NrAndOffset
         {
-            const static auto name = internal::coordName<DatumDomain>(
-                DatumCoord<DatumDomainCoord...>{});
+            const static auto name = internal::coordName<DatumDomain>(DatumCoord<DatumDomainCoord...> {});
             datumHits.at(name)++;
 
-            LLAMA_FORCE_INLINE_RECURSIVE return mapping
-                .template getBlobNrAndOffset<DatumDomainCoord...>(coord);
+            LLAMA_FORCE_INLINE_RECURSIVE return mapping.template getBlobNrAndOffset<DatumDomainCoord...>(coord);
         }
 
         Mapping mapping;
-        mutable std::unordered_map<std::string, std::atomic<std::size_t>>
-            datumHits;
+        mutable std::unordered_map<std::string, std::atomic<std::size_t>> datumHits;
     };
-}
+} // namespace llama::mapping
diff --git a/include/llama/mapping/tree/Functors.hpp b/include/llama/mapping/tree/Functors.hpp
index d7a7a32603..44429aa0bc 100644
--- a/include/llama/mapping/tree/Functors.hpp
+++ b/include/llama/mapping/tree/Functors.hpp
@@ -11,25 +11,22 @@ namespace llama::mapping::tree::functor
     /// used for testing.
     struct Idem
     {
-        template<typename Tree>
-        LLAMA_FN_HOST_ACC_INLINE auto basicToResult(const Tree & tree) const
-            -> Tree
+        template <typename Tree>
+        LLAMA_FN_HOST_ACC_INLINE auto basicToResult(const Tree& tree) const -> Tree
         {
             return tree;
         }
 
-        template<typename Tree, typename TreeCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(
-            const TreeCoord & basicCoord,
-            const Tree &) const -> TreeCoord
+        template <typename Tree, typename TreeCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(const TreeCoord& basicCoord, const Tree&) const
+            -> TreeCoord
         {
             return basicCoord;
         }
 
-        template<typename Tree, typename TreeCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(
-            const TreeCoord & resultCoord,
-            const Tree &) const -> TreeCoord
+        template <typename Tree, typename TreeCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(const TreeCoord& resultCoord, const Tree&) const
+            -> TreeCoord
         {
             return resultCoord;
         }
@@ -39,283 +36,216 @@ namespace llama::mapping::tree::functor
     /// creating a SoA layout.
     struct LeafOnlyRT
     {
-        template<typename Tree>
+        template <typename Tree>
         LLAMA_FN_HOST_ACC_INLINE auto basicToResult(Tree tree) const
         {
             return basicToResultImpl(tree, 1);
         }
 
-        template<typename Tree, typename BasicCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(
-            const BasicCoord & basicCoord,
-            const Tree & tree) const
+        template <typename Tree, typename BasicCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(const BasicCoord& basicCoord, const Tree& tree) const
         {
             return basicCoordToResultCoordImpl(basicCoord, tree);
         }
 
-        template<typename Tree, typename ResultCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(
-            const ResultCoord & resultCoord,
-            const Tree & tree) const -> ResultCoord
+        template <typename Tree, typename ResultCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(const ResultCoord& resultCoord, const Tree& tree) const
+            -> ResultCoord
         {
             return resultCoord;
         }
 
     private:
-        template<typename Identifier, typename Type, typename CountType>
+        template <typename Identifier, typename Type, typename CountType>
         LLAMA_FN_HOST_ACC_INLINE static auto basicToResultImpl(
-            const Node<Identifier, Type, CountType> & node,
+            const Node<Identifier, Type, CountType>& node,
             std::size_t arraySize)
         {
             auto children = tupleTransform(node.childs, [&](auto element) {
-                return basicToResultImpl(
-                    element, LLAMA_COPY(node.count) * arraySize);
+                return basicToResultImpl(element, LLAMA_COPY(node.count) * arraySize);
             });
-            return Node<
-                Identifier,
-                decltype(children),
-                boost::mp11::mp_size_t<1>>{{}, children};
+            return Node<Identifier, decltype(children), boost::mp11::mp_size_t<1>> {{}, children};
         }
 
-        template<typename Identifier, typename Type, typename CountType>
+        template <typename Identifier, typename Type, typename CountType>
         LLAMA_FN_HOST_ACC_INLINE static auto basicToResultImpl(
-            const Leaf<Identifier, Type, CountType> & leaf,
+            const Leaf<Identifier, Type, CountType>& leaf,
             std::size_t arraySize)
         {
-            return Leaf<Identifier, Type, std::size_t>{
-                LLAMA_COPY(leaf.count) * arraySize};
+            return Leaf<Identifier, Type, std::size_t> {LLAMA_COPY(leaf.count) * arraySize};
         }
 
-        template<typename BasicCoord, typename NodeOrLeaf>
+        template <typename BasicCoord, typename NodeOrLeaf>
         LLAMA_FN_HOST_ACC_INLINE static auto basicCoordToResultCoordImpl(
-            const BasicCoord & basicCoord,
-            const NodeOrLeaf & nodeOrLeaf,
+            const BasicCoord& basicCoord,
+            const NodeOrLeaf& nodeOrLeaf,
             std::size_t arraySize = 0)
         {
-            if constexpr(tupleSize<BasicCoord> == 1)
-                return Tuple{
-                    TreeCoordElement<BasicCoord::FirstElement::childIndex>{
-                        arraySize + LLAMA_COPY(basicCoord.first.arrayIndex)}};
+            if constexpr (tupleSize<BasicCoord> == 1)
+                return Tuple {TreeCoordElement<BasicCoord::FirstElement::childIndex> {
+                    arraySize + LLAMA_COPY(basicCoord.first.arrayIndex)}};
             else
             {
-                const auto & branch = get<BasicCoord::FirstElement::childIndex>(
-                    nodeOrLeaf.childs);
-                auto first = TreeCoordElement<
-                    BasicCoord::FirstElement::childIndex,
-                    boost::mp11::mp_size_t<0>>{};
+                const auto& branch = get<BasicCoord::FirstElement::childIndex>(nodeOrLeaf.childs);
+                auto first = TreeCoordElement<BasicCoord::FirstElement::childIndex, boost::mp11::mp_size_t<0>> {};
 
                 return tupleCat(
-                    Tuple{first},
+                    Tuple {first},
                     basicCoordToResultCoordImpl(
                         basicCoord.rest,
                         branch,
-                        (arraySize + LLAMA_COPY(basicCoord.first.arrayIndex))
-                            * LLAMA_COPY(branch.count)));
+                        (arraySize + LLAMA_COPY(basicCoord.first.arrayIndex)) * LLAMA_COPY(branch.count)));
             }
         }
     };
 
     namespace internal
     {
-        template<typename TreeCoord, typename Node>
-        LLAMA_FN_HOST_ACC_INLINE auto getNode(const Node & node)
+        template <typename TreeCoord, typename Node>
+        LLAMA_FN_HOST_ACC_INLINE auto getNode(const Node& node)
         {
-            if constexpr(std::is_same_v<TreeCoord, Tuple<>>)
+            if constexpr (std::is_same_v<TreeCoord, Tuple<>>)
                 return node;
             else
-                return getNode<typename TreeCoord::RestTuple>(
-                    get<TreeCoord::FirstElement::childIndex>(node.childs));
+                return getNode<typename TreeCoord::RestTuple>(get<TreeCoord::FirstElement::childIndex>(node.childs));
         }
 
-        template<
-            typename TreeCoord,
-            typename Identifier,
-            typename Type,
-            typename CountType>
+        template <typename TreeCoord, typename Identifier, typename Type, typename CountType>
         LLAMA_FN_HOST_ACC_INLINE auto changeNodeRuntime(
-            const Node<Identifier, Type, CountType> & tree,
+            const Node<Identifier, Type, CountType>& tree,
             std::size_t newValue)
         {
-            if constexpr(std::is_same_v<TreeCoord, Tuple<>>)
-                return Node<Identifier, Type>{newValue, tree.childs};
+            if constexpr (std::is_same_v<TreeCoord, Tuple<>>)
+                return Node<Identifier, Type> {newValue, tree.childs};
             else
             {
-                auto current
-                    = get<TreeCoord::FirstElement::childIndex>(tree.childs);
-                auto replacement
-                    = changeNodeRuntime<typename TreeCoord::RestTuple>(
-                        current, newValue);
-                auto children
-                    = tupleReplace<TreeCoord::FirstElement::childIndex>(
-                        tree.childs, replacement);
-                return Node<Identifier, decltype(children)>{
-                    tree.count, children};
+                auto current = get<TreeCoord::FirstElement::childIndex>(tree.childs);
+                auto replacement = changeNodeRuntime<typename TreeCoord::RestTuple>(current, newValue);
+                auto children = tupleReplace<TreeCoord::FirstElement::childIndex>(tree.childs, replacement);
+                return Node<Identifier, decltype(children)> {tree.count, children};
             }
         }
 
-        template<
-            typename TreeCoord,
-            typename Identifier,
-            typename Type,
-            typename CountType>
+        template <typename TreeCoord, typename Identifier, typename Type, typename CountType>
         LLAMA_FN_HOST_ACC_INLINE auto changeNodeRuntime(
-            const Leaf<Identifier, Type, CountType> & tree,
+            const Leaf<Identifier, Type, CountType>& tree,
             std::size_t newValue)
         {
-            return Leaf<Identifier, Type, std::size_t>{newValue};
+            return Leaf<Identifier, Type, std::size_t> {newValue};
         }
 
         struct ChangeNodeChildsRuntimeFunctor
         {
             const std::size_t newValue;
 
-            template<typename Identifier, typename Type, typename CountType>
-            LLAMA_FN_HOST_ACC_INLINE auto
-            operator()(const Node<Identifier, Type, CountType> & element) const
+            template <typename Identifier, typename Type, typename CountType>
+            LLAMA_FN_HOST_ACC_INLINE auto operator()(const Node<Identifier, Type, CountType>& element) const
             {
-                return Node<Identifier, Type, std::size_t>{
-                    element.count * newValue, element.childs};
+                return Node<Identifier, Type, std::size_t> {element.count * newValue, element.childs};
             }
 
-            template<typename Identifier, typename Type, typename CountType>
-            LLAMA_FN_HOST_ACC_INLINE auto
-            operator()(const Leaf<Identifier, Type, CountType> & element) const
+            template <typename Identifier, typename Type, typename CountType>
+            LLAMA_FN_HOST_ACC_INLINE auto operator()(const Leaf<Identifier, Type, CountType>& element) const
             {
-                return Leaf<Identifier, Type, std::size_t>{
-                    element.count * newValue};
+                return Leaf<Identifier, Type, std::size_t> {element.count * newValue};
             }
         };
 
-        template<
-            typename TreeCoord,
-            typename Identifier,
-            typename Type,
-            typename CountType>
+        template <typename TreeCoord, typename Identifier, typename Type, typename CountType>
         LLAMA_FN_HOST_ACC_INLINE auto changeNodeChildsRuntime(
-            const Node<Identifier, Type, CountType> & tree,
+            const Node<Identifier, Type, CountType>& tree,
             std::size_t newValue)
         {
-            if constexpr(std::is_same_v<TreeCoord, Tuple<>>)
+            if constexpr (std::is_same_v<TreeCoord, Tuple<>>)
             {
-                auto children = tupleTransform(
-                    tree.childs, ChangeNodeChildsRuntimeFunctor{newValue});
-                return Node<Identifier, decltype(children)>{
-                    tree.count, children};
+                auto children = tupleTransform(tree.childs, ChangeNodeChildsRuntimeFunctor {newValue});
+                return Node<Identifier, decltype(children)> {tree.count, children};
             }
             else
             {
-                auto current
-                    = get<TreeCoord::FirstElement::childIndex>(tree.childs);
-                auto replacement
-                    = changeNodeChildsRuntime<typename TreeCoord::RestTuple>(
-                        current, newValue);
-                auto children
-                    = tupleReplace<TreeCoord::FirstElement::childIndex>(
-                        tree.childs, replacement);
-                return Node<Identifier, decltype(children)>{
-                    tree.count, children};
+                auto current = get<TreeCoord::FirstElement::childIndex>(tree.childs);
+                auto replacement = changeNodeChildsRuntime<typename TreeCoord::RestTuple>(current, newValue);
+                auto children = tupleReplace<TreeCoord::FirstElement::childIndex>(tree.childs, replacement);
+                return Node<Identifier, decltype(children)> {tree.count, children};
             }
         }
 
-        template<
-            typename TreeCoord,
-            typename Identifier,
-            typename Type,
-            typename CountType>
+        template <typename TreeCoord, typename Identifier, typename Type, typename CountType>
         LLAMA_FN_HOST_ACC_INLINE auto changeNodeChildsRuntime(
-            const Leaf<Identifier, Type, CountType> & tree,
+            const Leaf<Identifier, Type, CountType>& tree,
             std::size_t newValue)
         {
             return tree;
         }
-    }
+    } // namespace internal
 
     /// Functor for \ref tree::Mapping. Move the run time part of a node one
     /// level down in direction of the leaves by the given amount (runtime or
     /// compile time value).
     /// \tparam TreeCoord tree coordinate in the mapping tree which's run time
     /// part shall be moved down one level \see tree::Mapping
-    template<typename TreeCoord, typename Amount = std::size_t>
+    template <typename TreeCoord, typename Amount = std::size_t>
     struct MoveRTDown
     {
         const Amount amount = {};
 
-        template<typename Tree>
-        LLAMA_FN_HOST_ACC_INLINE auto basicToResult(const Tree & tree) const
+        template <typename Tree>
+        LLAMA_FN_HOST_ACC_INLINE auto basicToResult(const Tree& tree) const
         {
             return internal::changeNodeChildsRuntime<TreeCoord>(
                 internal::changeNodeRuntime<TreeCoord>(
                     tree,
-                    (internal::getNode<TreeCoord>(tree).count + amount - 1)
-                        / amount),
+                    (internal::getNode<TreeCoord>(tree).count + amount - 1) / amount),
                 amount);
         }
 
-        template<typename Tree, typename BasicCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(
-            const BasicCoord & basicCoord,
-            const Tree & tree) const
+        template <typename Tree, typename BasicCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(const BasicCoord& basicCoord, const Tree& tree) const
         {
             return basicCoordToResultCoordImpl<TreeCoord>(basicCoord, tree);
         }
 
-        template<typename Tree, typename ResultCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(
-            const ResultCoord & resultCoord,
-            const Tree &) const -> ResultCoord
+        template <typename Tree, typename ResultCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(const ResultCoord& resultCoord, const Tree&) const
+            -> ResultCoord
         {
             return resultCoord;
         }
 
     private:
-        template<typename InternalTreeCoord, typename BasicCoord, typename Tree>
-        LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoordImpl(
-            const BasicCoord & basicCoord,
-            const Tree & tree) const
+        template <typename InternalTreeCoord, typename BasicCoord, typename Tree>
+        LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoordImpl(const BasicCoord& basicCoord, const Tree& tree) const
         {
-            if constexpr(std::is_same_v<InternalTreeCoord, Tuple<>>)
+            if constexpr (std::is_same_v<InternalTreeCoord, Tuple<>>)
             {
-                if constexpr(std::is_same_v<BasicCoord, Tuple<>>)
-                    return Tuple<>{};
+                if constexpr (std::is_same_v<BasicCoord, Tuple<>>)
+                    return Tuple<> {};
                 else
                 {
-                    const auto & childTree
-                        = get<BasicCoord::FirstElement::childIndex>(
-                            tree.childs);
+                    const auto& childTree = get<BasicCoord::FirstElement::childIndex>(tree.childs);
                     const auto rt1 = basicCoord.first.arrayIndex / amount;
                     const auto rt2
-                        = basicCoord.first.arrayIndex % amount * childTree.count
-                        + basicCoord.rest.first.arrayIndex;
-                    auto rt1Child = TreeCoordElement<
-                        BasicCoord::FirstElement::childIndex>{rt1};
-                    auto rt2Child = TreeCoordElement<
-                        BasicCoord::RestTuple::FirstElement::childIndex>{rt2};
-                    return tupleCat(
-                        Tuple{rt1Child},
-                        tupleCat(
-                            Tuple{rt2Child},
-                            tupleWithoutFirst(basicCoord.rest)));
+                        = basicCoord.first.arrayIndex % amount * childTree.count + basicCoord.rest.first.arrayIndex;
+                    auto rt1Child = TreeCoordElement<BasicCoord::FirstElement::childIndex> {rt1};
+                    auto rt2Child = TreeCoordElement<BasicCoord::RestTuple::FirstElement::childIndex> {rt2};
+                    return tupleCat(Tuple {rt1Child}, tupleCat(Tuple {rt2Child}, tupleWithoutFirst(basicCoord.rest)));
                 }
             }
             else
             {
-                if constexpr(
-                    InternalTreeCoord::FirstElement::childIndex
-                    != BasicCoord::FirstElement::childIndex)
+                if constexpr (InternalTreeCoord::FirstElement::childIndex != BasicCoord::FirstElement::childIndex)
                     return basicCoord;
                 else
                 {
-                    auto rest = basicCoordToResultCoordImpl<
-                        typename InternalTreeCoord::RestTuple>(
+                    auto rest = basicCoordToResultCoordImpl<typename InternalTreeCoord::RestTuple>(
                         tupleWithoutFirst(basicCoord),
                         get<BasicCoord::FirstElement::childIndex>(tree.childs));
-                    return tupleCat(Tuple{basicCoord.first}, rest);
+                    return tupleCat(Tuple {basicCoord.first}, rest);
                 }
             }
         }
     };
 
-    template<typename TreeCoord, std::size_t Amount>
-    using MoveRTDownFixed
-        = MoveRTDown<TreeCoord, boost::mp11::mp_size_t<Amount>>;
-}
+    template <typename TreeCoord, std::size_t Amount>
+    using MoveRTDownFixed = MoveRTDown<TreeCoord, boost::mp11::mp_size_t<Amount>>;
+} // namespace llama::mapping::tree::functor
diff --git a/include/llama/mapping/tree/Mapping.hpp b/include/llama/mapping/tree/Mapping.hpp
index 18ee1968f6..2117a9ba46 100644
--- a/include/llama/mapping/tree/Mapping.hpp
+++ b/include/llama/mapping/tree/Mapping.hpp
@@ -16,49 +16,44 @@ namespace llama::mapping::tree
 {
     namespace internal
     {
-        template<typename Tree, typename TreeOperationList>
+        template <typename Tree, typename TreeOperationList>
         struct MergeFunctors
-        {};
+        {
+        };
 
-        template<typename Tree, typename... Operations>
+        template <typename Tree, typename... Operations>
         struct MergeFunctors<Tree, Tuple<Operations...>>
         {
             boost::mp11::mp_first<Tuple<Operations...>> operation = {};
             using ResultTree = decltype(operation.basicToResult(Tree()));
             ResultTree treeAfterOp;
-            MergeFunctors<
-                ResultTree,
-                boost::mp11::mp_drop_c<Tuple<Operations...>, 1>>
-                next = {};
+            MergeFunctors<ResultTree, boost::mp11::mp_drop_c<Tuple<Operations...>, 1>> next = {};
 
             MergeFunctors() = default;
 
             LLAMA_FN_HOST_ACC_INLINE
-            MergeFunctors(
-                const Tree & tree,
-                const Tuple<Operations...> & treeOperationList) :
-                    operation(treeOperationList.first),
-                    treeAfterOp(operation.basicToResult(tree)),
-                    next(treeAfterOp, tupleWithoutFirst(treeOperationList))
-            {}
+            MergeFunctors(const Tree& tree, const Tuple<Operations...>& treeOperationList)
+                : operation(treeOperationList.first)
+                , treeAfterOp(operation.basicToResult(tree))
+                , next(treeAfterOp, tupleWithoutFirst(treeOperationList))
+            {
+            }
 
             LLAMA_FN_HOST_ACC_INLINE
-            auto basicToResult(const Tree & tree) const
+            auto basicToResult(const Tree& tree) const
             {
-                if constexpr(sizeof...(Operations) > 1)
+                if constexpr (sizeof...(Operations) > 1)
                     return next.basicToResult(treeAfterOp);
-                else if constexpr(sizeof...(Operations) == 1)
+                else if constexpr (sizeof...(Operations) == 1)
                     return operation.basicToResult(tree);
                 else
                     return tree;
             }
 
-            template<typename TreeCoord>
-            LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(
-                const TreeCoord & basicCoord,
-                const Tree & tree) const
+            template <typename TreeCoord>
+            LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(const TreeCoord& basicCoord, const Tree& tree) const
             {
-                if constexpr(sizeof...(Operations) >= 1)
+                if constexpr (sizeof...(Operations) >= 1)
                     return next.basicCoordToResultCoord(
                         operation.basicCoordToResultCoord(basicCoord, tree),
                         treeAfterOp);
@@ -66,12 +61,10 @@ namespace llama::mapping::tree
                     return basicCoord;
             }
 
-            template<typename TreeCoord>
-            LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(
-                const TreeCoord & resultCoord,
-                const Tree & tree) const
+            template <typename TreeCoord>
+            LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(const TreeCoord& resultCoord, const Tree& tree) const
             {
-                if constexpr(sizeof...(Operations) >= 1)
+                if constexpr (sizeof...(Operations) >= 1)
                     return next.resultCoordToBasicCoord(
                         operation.resultCoordToBasicCoord(resultCoord, tree),
                         operation.basicToResult(tree));
@@ -80,132 +73,104 @@ namespace llama::mapping::tree
             }
         };
 
-        template<typename Tree>
+        template <typename Tree>
         struct MergeFunctors<Tree, Tuple<>>
         {
             MergeFunctors() = default;
 
             LLAMA_FN_HOST_ACC_INLINE
-            MergeFunctors(const Tree &, const Tuple<> & treeOperationList) {}
+            MergeFunctors(const Tree&, const Tuple<>& treeOperationList)
+            {
+            }
 
             LLAMA_FN_HOST_ACC_INLINE
-            auto basicToResult(const Tree & tree) const
+            auto basicToResult(const Tree& tree) const
             {
                 return tree;
             }
 
-            template<typename TreeCoord>
-            LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(
-                TreeCoord const & basicCoord,
-                Tree const & tree) const -> TreeCoord
+            template <typename TreeCoord>
+            LLAMA_FN_HOST_ACC_INLINE auto basicCoordToResultCoord(TreeCoord const& basicCoord, Tree const& tree) const
+                -> TreeCoord
             {
                 return basicCoord;
             }
 
-            template<typename TreeCoord>
-            LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(
-                TreeCoord const & resultCoord,
-                Tree const & tree) const -> TreeCoord
+            template <typename TreeCoord>
+            LLAMA_FN_HOST_ACC_INLINE auto resultCoordToBasicCoord(TreeCoord const& resultCoord, Tree const& tree) const
+                -> TreeCoord
             {
                 return resultCoord;
             }
         };
 
-        template<typename Identifier, typename Type, typename CountType>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        getTreeBlobSize(const Node<Identifier, Type, CountType> & node)
-            -> std::size_t;
+        template <typename Identifier, typename Type, typename CountType>
+        LLAMA_FN_HOST_ACC_INLINE auto getTreeBlobSize(const Node<Identifier, Type, CountType>& node) -> std::size_t;
 
-        template<typename Identifier, typename Type, typename CountType>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        getTreeBlobSize(const Leaf<Identifier, Type, CountType> & leaf)
-            -> std::size_t;
+        template <typename Identifier, typename Type, typename CountType>
+        LLAMA_FN_HOST_ACC_INLINE auto getTreeBlobSize(const Leaf<Identifier, Type, CountType>& leaf) -> std::size_t;
 
-        template<typename... Children, std::size_t... Is, typename Count>
+        template <typename... Children, std::size_t... Is, typename Count>
         LLAMA_FN_HOST_ACC_INLINE auto getChildrenBlobSize(
-            const Tuple<Children...> & childs,
+            const Tuple<Children...>& childs,
             std::index_sequence<Is...> ii,
-            const Count & count) -> std::size_t
+            const Count& count) -> std::size_t
         {
             return count * (getTreeBlobSize(get<Is>(childs)) + ...);
         }
 
-        template<typename Identifier, typename Type, typename CountType>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        getTreeBlobSize(const Node<Identifier, Type, CountType> & node)
-            -> std::size_t
+        template <typename Identifier, typename Type, typename CountType>
+        LLAMA_FN_HOST_ACC_INLINE auto getTreeBlobSize(const Node<Identifier, Type, CountType>& node) -> std::size_t
         {
-            constexpr std::size_t childCount = boost::mp11::mp_size<
-                std::decay_t<decltype(node.childs)>>::value;
-            return getChildrenBlobSize(
-                node.childs,
-                std::make_index_sequence<childCount>{},
-                LLAMA_COPY(node.count));
+            constexpr std::size_t childCount = boost::mp11::mp_size<std::decay_t<decltype(node.childs)>>::value;
+            return getChildrenBlobSize(node.childs, std::make_index_sequence<childCount> {}, LLAMA_COPY(node.count));
         }
 
-        template<typename Identifier, typename Type, typename CountType>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        getTreeBlobSize(const Leaf<Identifier, Type, CountType> & leaf)
-            -> std::size_t
+        template <typename Identifier, typename Type, typename CountType>
+        LLAMA_FN_HOST_ACC_INLINE auto getTreeBlobSize(const Leaf<Identifier, Type, CountType>& leaf) -> std::size_t
         {
             return leaf.count * sizeof(Type);
         }
 
-        template<typename Childs, typename CountType>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        getTreeBlobSize(const Childs & childs, const CountType & count)
-            -> std::size_t
+        template <typename Childs, typename CountType>
+        LLAMA_FN_HOST_ACC_INLINE auto getTreeBlobSize(const Childs& childs, const CountType& count) -> std::size_t
         {
-            return getTreeBlobSize(
-                Node<NoName, Childs, CountType>{count, childs});
+            return getTreeBlobSize(Node<NoName, Childs, CountType> {count, childs});
         }
 
-        template<
-            std::size_t MaxPos,
-            typename Identifier,
-            typename Type,
-            typename CountType,
-            std::size_t... Is>
+        template <std::size_t MaxPos, typename Identifier, typename Type, typename CountType, std::size_t... Is>
         LLAMA_FN_HOST_ACC_INLINE auto sumChildrenSmallerThan(
-            const Node<Identifier, Type, CountType> & node,
+            const Node<Identifier, Type, CountType>& node,
             std::index_sequence<Is...>) -> std::size_t
         {
-            return (
-                (getTreeBlobSize(get<Is>(node.childs)) * (Is < MaxPos)) + ...);
+            return ((getTreeBlobSize(get<Is>(node.childs)) * (Is < MaxPos)) + ...);
         }
 
-        template<typename Tree, typename... Coords>
-        LLAMA_FN_HOST_ACC_INLINE auto
-        getTreeBlobByte(const Tree & tree, const Tuple<Coords...> & treeCoord)
+        template <typename Tree, typename... Coords>
+        LLAMA_FN_HOST_ACC_INLINE auto getTreeBlobByte(const Tree& tree, const Tuple<Coords...>& treeCoord)
             -> std::size_t
         {
             const auto firstArrayIndex = treeCoord.first.arrayIndex;
-            if constexpr(sizeof...(Coords) > 1)
+            if constexpr (sizeof...(Coords) > 1)
             {
-                constexpr auto firstChildIndex
-                    = decltype(treeCoord.first.childIndex)::value;
+                constexpr auto firstChildIndex = decltype(treeCoord.first.childIndex)::value;
                 return getTreeBlobSize(tree.childs, firstArrayIndex)
                     + sumChildrenSmallerThan<firstChildIndex>(
                            tree,
-                           std::make_index_sequence<
-                               tupleSize<typename Tree::ChildrenTuple>>{})
-                    + getTreeBlobByte(
-                           get<firstChildIndex>(tree.childs), treeCoord.rest);
+                           std::make_index_sequence<tupleSize<typename Tree::ChildrenTuple>> {})
+                    + getTreeBlobByte(get<firstChildIndex>(tree.childs), treeCoord.rest);
             }
             else
                 return sizeof(typename Tree::Type) * firstArrayIndex;
         }
-    }
+    } // namespace internal
 
     /// An experimental attempt to provide a general purpose description of a
     /// mapping. \ref UserDomain and datum domain are represented by a compile
     /// time tree data structure. This tree is mapped into memory by means of a
     /// breadth-first tree traversal. By specifying additional tree operations,
     /// the tree can be modified at compile time before being mapped to memory.
-    template<
-        typename T_UserDomain,
-        typename T_DatumDomain,
-        typename TreeOperationList>
+    template <typename T_UserDomain, typename T_DatumDomain, typename TreeOperationList>
     struct Mapping
     {
         using UserDomain = T_UserDomain;
@@ -214,8 +179,7 @@ namespace llama::mapping::tree
         // TODO, support more than one blob
         static constexpr std::size_t blobCount = 1;
 
-        using MergedFunctors
-            = internal::MergeFunctors<BasicTree, TreeOperationList>;
+        using MergedFunctors = internal::MergeFunctors<BasicTree, TreeOperationList>;
 
         UserDomain userDomainSize = {};
         BasicTree basicTree;
@@ -227,15 +191,13 @@ namespace llama::mapping::tree
         Mapping() = default;
 
         LLAMA_FN_HOST_ACC_INLINE
-        Mapping(
-            UserDomain size,
-            TreeOperationList treeOperationList,
-            DatumDomain = {}) :
-                userDomainSize(size),
-                basicTree(createTree<DatumDomain>(size)),
-                mergedFunctors(basicTree, treeOperationList),
-                resultTree(mergedFunctors.basicToResult(basicTree))
-        {}
+        Mapping(UserDomain size, TreeOperationList treeOperationList, DatumDomain = {})
+            : userDomainSize(size)
+            , basicTree(createTree<DatumDomain>(size))
+            , mergedFunctors(basicTree, treeOperationList)
+            , resultTree(mergedFunctors.basicToResult(basicTree))
+        {
+        }
 
         LLAMA_FN_HOST_ACC_INLINE
         auto getBlobSize(std::size_t const) const -> std::size_t
@@ -243,17 +205,13 @@ namespace llama::mapping::tree
             return internal::getTreeBlobSize(resultTree);
         }
 
-        template<std::size_t... DatumDomainCoord>
-        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const
-            -> NrAndOffset
+        template <std::size_t... DatumDomainCoord>
+        LLAMA_FN_HOST_ACC_INLINE auto getBlobNrAndOffset(UserDomain coord) const -> NrAndOffset
         {
-            auto const basicTreeCoord
-                = createTreeCoord<DatumCoord<DatumDomainCoord...>>(coord);
-            auto const resultTreeCoord = mergedFunctors.basicCoordToResultCoord(
-                basicTreeCoord, basicTree);
-            const auto offset
-                = internal::getTreeBlobByte(resultTree, resultTreeCoord);
+            auto const basicTreeCoord = createTreeCoord<DatumCoord<DatumDomainCoord...>>(coord);
+            auto const resultTreeCoord = mergedFunctors.basicCoordToResultCoord(basicTreeCoord, basicTree);
+            const auto offset = internal::getTreeBlobByte(resultTree, resultTreeCoord);
             return {0, offset};
         }
     };
-}
+} // namespace llama::mapping::tree
diff --git a/include/llama/mapping/tree/TreeFromDomains.hpp b/include/llama/mapping/tree/TreeFromDomains.hpp
index 4b2fa5c81e..7aad948ba4 100644
--- a/include/llama/mapping/tree/TreeFromDomains.hpp
+++ b/include/llama/mapping/tree/TreeFromDomains.hpp
@@ -10,17 +10,13 @@
 
 namespace llama::mapping::tree
 {
-    template<typename T>
+    template <typename T>
     inline constexpr auto one = 1;
 
-    template<>
-    inline constexpr auto
-        one<boost::mp11::mp_size_t<1>> = boost::mp11::mp_size_t<1>{};
+    template <>
+    inline constexpr auto one<boost::mp11::mp_size_t<1>> = boost::mp11::mp_size_t<1> {};
 
-    template<
-        typename T_Identifier,
-        typename T_Type,
-        typename CountType = std::size_t>
+    template <typename T_Identifier, typename T_Type, typename CountType = std::size_t>
     struct Leaf
     {
         using Identifier = T_Identifier;
@@ -29,10 +25,7 @@ namespace llama::mapping::tree
         const CountType count = one<CountType>;
     };
 
-    template<
-        typename T_Identifier,
-        typename T_ChildrenTuple,
-        typename CountType = std::size_t>
+    template <typename T_Identifier, typename T_ChildrenTuple, typename CountType = std::size_t>
     struct Node
     {
         using Identifier = T_Identifier;
@@ -42,51 +35,47 @@ namespace llama::mapping::tree
         const ChildrenTuple childs = {};
     };
 
-    template<std::size_t ChildIndex = 0, typename ArrayIndexType = std::size_t>
+    template <std::size_t ChildIndex = 0, typename ArrayIndexType = std::size_t>
     struct TreeCoordElement
     {
         static constexpr boost::mp11::mp_size_t<ChildIndex> childIndex = {};
         const ArrayIndexType arrayIndex = {};
     };
 
-    template<std::size_t... Coords>
-    using TreeCoord
-        = Tuple<TreeCoordElement<Coords, boost::mp11::mp_size_t<0>>...>;
+    template <std::size_t... Coords>
+    using TreeCoord = Tuple<TreeCoordElement<Coords, boost::mp11::mp_size_t<0>>...>;
 
     namespace internal
     {
-        template<typename... Coords, std::size_t... Is>
-        auto treeCoordToString(
-            Tuple<Coords...> treeCoord,
-            std::index_sequence<Is...>) -> std::string
+        template <typename... Coords, std::size_t... Is>
+        auto treeCoordToString(Tuple<Coords...> treeCoord, std::index_sequence<Is...>) -> std::string
         {
             auto s
-                = ((std::to_string(get<Is>(treeCoord).arrayIndex) + ":"
-                    + std::to_string(get<Is>(treeCoord).childIndex) + ", ")
+                = ((std::to_string(get<Is>(treeCoord).arrayIndex) + ":" + std::to_string(get<Is>(treeCoord).childIndex)
+                    + ", ")
                    + ...);
             s.resize(s.length() - 2);
             return s;
         }
-    }
+    } // namespace internal
 
-    template<typename TreeCoord>
+    template <typename TreeCoord>
     auto treeCoordToString(TreeCoord treeCoord) -> std::string
     {
         return std::string("[ ")
-            + internal::treeCoordToString(
-                   treeCoord, std::make_index_sequence<tupleSize<TreeCoord>>{})
+            + internal::treeCoordToString(treeCoord, std::make_index_sequence<tupleSize<TreeCoord>> {})
             + std::string(" ]");
     }
 
     namespace internal
     {
-        template<typename Tag, typename DatumDomain, typename CountType>
+        template <typename Tag, typename DatumDomain, typename CountType>
         struct CreateTreeElement
         {
             using type = Leaf<Tag, DatumDomain, boost::mp11::mp_size_t<1>>;
         };
 
-        template<typename Tag, typename... DatumElements, typename CountType>
+        template <typename Tag, typename... DatumElements, typename CountType>
         struct CreateTreeElement<Tag, DatumStruct<DatumElements...>, CountType>
         {
             using type = Node<
@@ -98,73 +87,63 @@ namespace llama::mapping::tree
                 CountType>;
         };
 
-        template<typename Leaf, std::size_t Count>
+        template <typename Leaf, std::size_t Count>
         struct WrapInNNodes
         {
-            using type = Node<
-                NoName,
-                Tuple<typename WrapInNNodes<Leaf, Count - 1>::type>>;
+            using type = Node<NoName, Tuple<typename WrapInNNodes<Leaf, Count - 1>::type>>;
         };
 
-        template<typename Leaf>
+        template <typename Leaf>
         struct WrapInNNodes<Leaf, 0>
         {
             using type = Leaf;
         };
 
-        template<typename DatumDomain>
-        using TreeFromDatumDomainImpl =
-            typename CreateTreeElement<NoName, DatumDomain, std::size_t>::type;
-    }
+        template <typename DatumDomain>
+        using TreeFromDatumDomainImpl = typename CreateTreeElement<NoName, DatumDomain, std::size_t>::type;
+    } // namespace internal
 
-    template<typename DatumDomain>
+    template <typename DatumDomain>
     using TreeFromDatumDomain = internal::TreeFromDatumDomainImpl<DatumDomain>;
 
-    template<typename UserDomain, typename DatumDomain>
-    using TreeFromDomains = typename internal::WrapInNNodes<
-        internal::TreeFromDatumDomainImpl<DatumDomain>,
-        UserDomain::rank - 1>::type;
+    template <typename UserDomain, typename DatumDomain>
+    using TreeFromDomains =
+        typename internal::WrapInNNodes<internal::TreeFromDatumDomainImpl<DatumDomain>, UserDomain::rank - 1>::type;
 
-    template<typename DatumDomain, typename UserDomain, std::size_t Pos = 0>
-    LLAMA_FN_HOST_ACC_INLINE auto createTree(const UserDomain & size)
+    template <typename DatumDomain, typename UserDomain, std::size_t Pos = 0>
+    LLAMA_FN_HOST_ACC_INLINE auto createTree(const UserDomain& size)
     {
-        if constexpr(Pos == UserDomain::rank - 1)
-            return TreeFromDatumDomain<DatumDomain>{size[UserDomain::rank - 1]};
+        if constexpr (Pos == UserDomain::rank - 1)
+            return TreeFromDatumDomain<DatumDomain> {size[UserDomain::rank - 1]};
         else
         {
-            Tuple inner{createTree<DatumDomain, UserDomain, Pos + 1>(size)};
-            return Node<NoName, decltype(inner)>{size[Pos], inner};
+            Tuple inner {createTree<DatumDomain, UserDomain, Pos + 1>(size)};
+            return Node<NoName, decltype(inner)> {size[Pos], inner};
         }
     };
 
     namespace internal
     {
-        template<
+        template <
             typename UserDomain,
             std::size_t... UDIndices,
             std::size_t FirstDatumDomainCoord,
             std::size_t... DatumDomainCoords>
         LLAMA_FN_HOST_ACC_INLINE auto createTreeCoord(
-            const UserDomain & coord,
+            const UserDomain& coord,
             std::index_sequence<UDIndices...>,
             DatumCoord<FirstDatumDomainCoord, DatumDomainCoords...>)
         {
-            return Tuple{
-                TreeCoordElement<(
-                    UDIndices == UserDomain::rank - 1 ? FirstDatumDomainCoord
-                                                      : 0)>{
-                    coord[UDIndices]}...,
-                TreeCoordElement<
-                    DatumDomainCoords,
-                    boost::mp11::mp_size_t<0>>{}...,
-                TreeCoordElement<0, boost::mp11::mp_size_t<0>>{}};
+            return Tuple {
+                TreeCoordElement<(UDIndices == UserDomain::rank - 1 ? FirstDatumDomainCoord : 0)> {coord[UDIndices]}...,
+                TreeCoordElement<DatumDomainCoords, boost::mp11::mp_size_t<0>> {}...,
+                TreeCoordElement<0, boost::mp11::mp_size_t<0>> {}};
         }
-    }
+    } // namespace internal
 
-    template<typename DatumCoord, typename UserDomain>
-    LLAMA_FN_HOST_ACC_INLINE auto createTreeCoord(const UserDomain & coord)
+    template <typename DatumCoord, typename UserDomain>
+    LLAMA_FN_HOST_ACC_INLINE auto createTreeCoord(const UserDomain& coord)
     {
-        return internal::createTreeCoord(
-            coord, std::make_index_sequence<UserDomain::rank>{}, DatumCoord{});
+        return internal::createTreeCoord(coord, std::make_index_sequence<UserDomain::rank> {}, DatumCoord {});
     }
-}
+} // namespace llama::mapping::tree
diff --git a/include/llama/mapping/tree/toString.hpp b/include/llama/mapping/tree/toString.hpp
index a745ec392b..6f75aa24c6 100644
--- a/include/llama/mapping/tree/toString.hpp
+++ b/include/llama/mapping/tree/toString.hpp
@@ -12,13 +12,13 @@
 
 namespace llama::mapping::tree
 {
-    template<typename T>
+    template <typename T>
     auto toString(T) -> std::string
     {
         return "Unknown";
     }
 
-    template<std::size_t I>
+    template <std::size_t I>
     inline auto toString(Index<I>) -> std::string
     {
         return "";
@@ -29,10 +29,10 @@ namespace llama::mapping::tree
         return "";
     }
 
-    template<typename... Elements>
+    template <typename... Elements>
     auto toString(Tuple<Elements...> tree) -> std::string
     {
-        if constexpr(sizeof...(Elements) > 1)
+        if constexpr (sizeof...(Elements) > 1)
             return toString(tree.first) + " , " + toString(tree.rest);
         else
             return toString(tree.first);
@@ -40,30 +40,26 @@ namespace llama::mapping::tree
 
     namespace internal
     {
-        template<typename NodeOrLeaf>
-        auto countAndIdentToString(const NodeOrLeaf & nodeOrLeaf) -> std::string
+        template <typename NodeOrLeaf>
+        auto countAndIdentToString(const NodeOrLeaf& nodeOrLeaf) -> std::string
         {
             auto r = std::to_string(nodeOrLeaf.count);
-            if constexpr(std::is_same_v<
-                             std::decay_t<decltype(nodeOrLeaf.count)>,
-                             std::size_t>)
+            if constexpr (std::is_same_v<std::decay_t<decltype(nodeOrLeaf.count)>, std::size_t>)
                 r += "R"; // runtime
             else
                 r += "C"; // compile time
-            r += std::string{" * "}
-                + toString(typename NodeOrLeaf::Identifier{});
+            r += std::string {" * "} + toString(typename NodeOrLeaf::Identifier {});
             return r;
         }
-    }
+    } // namespace internal
 
-    template<typename Identifier, typename Type, typename CountType>
-    auto toString(const Node<Identifier, Type, CountType> & node) -> std::string
+    template <typename Identifier, typename Type, typename CountType>
+    auto toString(const Node<Identifier, Type, CountType>& node) -> std::string
     {
-        return internal::countAndIdentToString(node) + "[ "
-            + toString(node.childs) + " ]";
+        return internal::countAndIdentToString(node) + "[ " + toString(node.childs) + " ]";
     }
-    template<typename Identifier, typename Type, typename CountType>
-    auto toString(const Leaf<Identifier, Type, CountType> & leaf) -> std::string
+    template <typename Identifier, typename Type, typename CountType>
+    auto toString(const Leaf<Identifier, Type, CountType>& leaf) -> std::string
     {
         auto raw = boost::core::demangle(typeid(Type).name());
 #ifdef _MSC_VER
@@ -74,4 +70,4 @@ namespace llama::mapping::tree
 #endif
         return internal::countAndIdentToString(leaf) + "(" + raw + ")";
     }
-}
+} // namespace llama::mapping::tree
diff --git a/tests/common.h b/tests/common.h
index d76cece547..8c432dd055 100644
--- a/tests/common.h
+++ b/tests/common.h
@@ -10,7 +10,8 @@
 #include <typeinfo>
 
 template <typename T>
-std::string prettyPrintType(const T& t) {
+std::string prettyPrintType(const T& t)
+{
     auto raw = boost::core::demangle(typeid(t).name());
 #ifdef _MSC_VER
     // remove clutter in MSVC
@@ -18,7 +19,7 @@ std::string prettyPrintType(const T& t) {
 #endif
 #ifdef __GNUG__
     // remove clutter in g++
-    static std::regex ulLiteral{"(\\d+)ul"};
+    static std::regex ulLiteral {"(\\d+)ul"};
     raw = std::regex_replace(raw, ulLiteral, "$1");
 #endif
 
@@ -35,9 +36,9 @@ std::string prettyPrintType(const T& t) {
     boost::algorithm::split(tokens, raw, [](char c) { return c == '\n'; });
     std::string result;
     int indent = 0;
-    for (auto t : tokens) {
-        if (t.back() == '>' ||
-            (t.length() > 1 && t[t.length() - 2] == '>'))
+    for (auto t : tokens)
+    {
+        if (t.back() == '>' || (t.length() > 1 && t[t.length() - 2] == '>'))
             indent -= 4;
         for (int i = 0; i < indent; ++i)
             result += ' ';
@@ -52,27 +53,29 @@ std::string prettyPrintType(const T& t) {
 
 namespace internal
 {
-    inline void zeroBlob(std::shared_ptr<std::byte[]> & sp, size_t blobSize)
+    inline void zeroBlob(std::shared_ptr<std::byte[]>& sp, size_t blobSize)
     {
         std::memset(sp.get(), 0, blobSize);
     }
-    template<typename A>
-    void zeroBlob(std::vector<std::byte, A> & v, size_t blobSize)
+    template <typename A>
+    void zeroBlob(std::vector<std::byte, A>& v, size_t blobSize)
     {
         std::memset(v.data(), 0, blobSize);
     }
-}
+} // namespace internal
 
-template<typename View>
-void zeroStorage(View & view)
+template <typename View>
+void zeroStorage(View& view)
 {
-    for(auto i = 0; i < View::Mapping::blobCount; i++)
+    for (auto i = 0; i < View::Mapping::blobCount; i++)
         internal::zeroBlob(view.storageBlobs[i], view.mapping.getBlobSize(i));
 }
 
 template <typename View>
-void iotaStorage(View& view) {
-    for (auto i = 0; i < View::Mapping::blobCount; i++) {
+void iotaStorage(View& view)
+{
+    for (auto i = 0; i < View::Mapping::blobCount; i++)
+    {
         auto fillFunc = [val = 0]() mutable { return static_cast<typename View::BlobType::PrimType>(val++); };
         std::generate_n(view.storageBlobs[i].storageBlobs.get(), view.mapping.getBlobSize(i), fillFunc);
     }
diff --git a/tests/core.cpp b/tests/core.cpp
index 2c440b9366..06944aacab 100644
--- a/tests/core.cpp
+++ b/tests/core.cpp
@@ -133,4 +133,4 @@ TEST_CASE("offsetOf")
     STATIC_REQUIRE(llama::offsetOf<Particle, 3, 1> == 53);
     STATIC_REQUIRE(llama::offsetOf<Particle, 3, 2> == 54);
     STATIC_REQUIRE(llama::offsetOf<Particle, 3, 3> == 55);
-}
\ No newline at end of file
+}
diff --git a/tests/datatypes.cpp b/tests/datatypes.cpp
index 9c97b6ad68..dd0db6b9df 100644
--- a/tests/datatypes.cpp
+++ b/tests/datatypes.cpp
@@ -10,85 +10,90 @@
 TEST_CASE("type int")
 {
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, int>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    int & e = view(UserDomain{0}).access<Tag>();
+    int& e = view(UserDomain {0}).access<Tag>();
     e = 0;
 }
 
 TEST_CASE("type std::complex<float>")
 {
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, std::complex<float>>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    std::complex<float> & e = view(UserDomain{0}).access<Tag>();
+    std::complex<float>& e = view(UserDomain {0}).access<Tag>();
     e = {2, 3};
 }
 
 TEST_CASE("type std::array<float, 4>")
 {
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, std::array<float, 4>>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    std::array<float, 4> & e = view(UserDomain{0}).access<Tag>();
+    std::array<float, 4>& e = view(UserDomain {0}).access<Tag>();
     e = {2, 3, 4, 5};
 }
 
 TEST_CASE("type std::vector<float>")
 {
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, std::vector<float>>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    std::vector<float> & e = view(UserDomain{0}).access<Tag>();
+    std::vector<float>& e = view(UserDomain {0}).access<Tag>();
     // e = {2, 3, 4, 5}; // FIXME: LLAMA memory is uninitialized
 }
 
 TEST_CASE("type std::atomic<int>")
 {
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, std::atomic<int>>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    std::atomic<int> & e = view(UserDomain{0}).access<Tag>();
+    std::atomic<int>& e = view(UserDomain {0}).access<Tag>();
     // e++; // FIXME: LLAMA memory is uninitialized
 }
 
@@ -97,26 +102,27 @@ TEST_CASE("type noncopyable")
     struct Element
     {
         Element() = default;
-        Element(const Element &) = delete;
-        auto operator=(const Element &) -> Element & = delete;
-        Element(Element &&) noexcept = default;
-        auto operator=(Element &&) noexcept -> Element & = default;
+        Element(const Element&) = delete;
+        auto operator=(const Element&) -> Element& = delete;
+        Element(Element&&) noexcept = default;
+        auto operator=(Element&&) noexcept -> Element& = default;
 
         int value;
     };
 
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, Element>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    Element & e = view(UserDomain{0}).access<Tag>();
+    Element& e = view(UserDomain {0}).access<Tag>();
     e.value = 0;
 }
 
@@ -125,26 +131,27 @@ TEST_CASE("type nonmoveable")
     struct Element
     {
         Element() = default;
-        Element(const Element &) = delete;
-        auto operator=(const Element &) -> Element & = delete;
-        Element(Element &&) noexcept = delete;
-        auto operator=(Element &&) noexcept -> Element & = delete;
+        Element(const Element&) = delete;
+        auto operator=(const Element&) -> Element& = delete;
+        Element(Element&&) noexcept = delete;
+        auto operator=(Element&&) noexcept -> Element& = delete;
 
         int value;
     };
 
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, Element>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    Element & e = view(UserDomain{0}).access<Tag>();
+    Element& e = view(UserDomain {0}).access<Tag>();
     e.value = 0;
 }
 
@@ -157,17 +164,18 @@ TEST_CASE("type not defaultconstructible")
     };
 
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, Element>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    Element & e = view(UserDomain{0}).access<Tag>();
+    Element& e = view(UserDomain {0}).access<Tag>();
     e.value = 0;
 }
 
@@ -179,17 +187,18 @@ TEST_CASE("type nottrivial ctor")
     };
 
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, Element>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    Element & e = view(UserDomain{0}).access<Tag>();
+    Element& e = view(UserDomain {0}).access<Tag>();
     // CHECK(e.value == 42); // FIXME: LLAMA memory is uninitialized
 }
 
@@ -207,45 +216,45 @@ namespace
     private:
         inline static int counter = 0;
     };
-}
+} // namespace
 
 TEST_CASE("type custom initialization")
 {
     struct Tag
-    {};
+    {
+    };
     using Name = llama::DS<llama::DE<Tag, UniqueInt>>;
 
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
     // FIXME: LLAMA memory is uninitialized
-    //CHECK(view(UserDomain{0}).access<Tag>() == 0);
-    //CHECK(view(UserDomain{1}).access<Tag>() == 1);
-    //CHECK(view(UserDomain{2}).access<Tag>() == 2);
-    //CHECK(view(UserDomain{15}).access<Tag>() == 15);
+    // CHECK(view(UserDomain{0}).access<Tag>() == 0);
+    // CHECK(view(UserDomain{1}).access<Tag>() == 1);
+    // CHECK(view(UserDomain{2}).access<Tag>() == 2);
+    // CHECK(view(UserDomain{15}).access<Tag>() == 15);
 }
 
 TEST_CASE("type just double")
 {
     using DatumDomain = double;
-    llama::UserDomain userDomain{16};
-    llama::mapping::SoA mapping{userDomain, DatumDomain{}};
+    llama::UserDomain userDomain {16};
+    llama::mapping::SoA mapping {userDomain, DatumDomain {}};
     auto view = allocView(mapping);
 
     STATIC_REQUIRE(std::is_same_v<decltype(view(0u)), double&>);
     view(0u) = 42.0;
     CHECK(view(0u) == 42.0);
 
-    STATIC_REQUIRE(std::is_same_v<decltype(view[0u]), double &>);
+    STATIC_REQUIRE(std::is_same_v<decltype(view[0u]), double&>);
     view[0u] = 42.0;
     CHECK(view[0u] == 42.0);
 
-    STATIC_REQUIRE(
-        std::is_same_v<decltype(view[llama::UserDomain{0}]), double &>);
-    view[llama::UserDomain{0}] = 42.0;
-    CHECK(view[llama::UserDomain{0}] == 42.0);
+    STATIC_REQUIRE(std::is_same_v<decltype(view[llama::UserDomain {0}]), double&>);
+    view[llama::UserDomain {0}] = 42.0;
+    CHECK(view[llama::UserDomain {0}] == 42.0);
 }
diff --git a/tests/datumcoord.cpp b/tests/datumcoord.cpp
index 5ec3ebb449..d50a6d1bc4 100644
--- a/tests/datumcoord.cpp
+++ b/tests/datumcoord.cpp
@@ -26,4 +26,4 @@ TEST_CASE("DatumCoordCommonPrefixIsBigger")
     STATIC_REQUIRE(!llama::DatumCoordCommonPrefixIsBigger<llama::DatumCoord<0, 0   >, llama::DatumCoord<0, 0, 1>>);
     STATIC_REQUIRE(!llama::DatumCoordCommonPrefixIsBigger<llama::DatumCoord<0      >, llama::DatumCoord<0, 0, 1>>);
     // clang-format on
-}
\ No newline at end of file
+}
diff --git a/tests/dump.cpp b/tests/dump.cpp
index b997bf08ac..446897e938 100644
--- a/tests/dump.cpp
+++ b/tests/dump.cpp
@@ -31,24 +31,20 @@ using Particle = llama::DS<
 >;
 // clang-format on
 
-template<typename Mapping>
-void dump(const Mapping & mapping, std::string filename)
+template <typename Mapping>
+void dump(const Mapping& mapping, std::string filename)
 {
-    std::ofstream{filename + ".svg"} << llama::toSvg(mapping);
-    std::ofstream{filename + ".html"} << llama::toHtml(mapping);
+    std::ofstream {filename + ".svg"} << llama::toSvg(mapping);
+    std::ofstream {filename + ".html"} << llama::toHtml(mapping);
 }
 
 TEST_CASE("dump")
 {
     using UserDomain = llama::UserDomain<2>;
-    UserDomain userDomain{8, 8};
+    UserDomain userDomain {8, 8};
 
-    dump(llama::mapping::AoS<UserDomain, Particle>{userDomain}, "AoSMapping");
-    dump(llama::mapping::SoA<UserDomain, Particle>{userDomain}, "SoAMapping");
-    dump(
-        llama::mapping::AoSoA<UserDomain, Particle, 8>{userDomain},
-        "AoSoAMapping8");
-    dump(
-        llama::mapping::AoSoA<UserDomain, Particle, 32>{userDomain},
-        "AoSoAMapping32");
+    dump(llama::mapping::AoS<UserDomain, Particle> {userDomain}, "AoSMapping");
+    dump(llama::mapping::SoA<UserDomain, Particle> {userDomain}, "SoAMapping");
+    dump(llama::mapping::AoSoA<UserDomain, Particle, 8> {userDomain}, "AoSoAMapping8");
+    dump(llama::mapping::AoSoA<UserDomain, Particle, 32> {userDomain}, "AoSoAMapping32");
 }
diff --git a/tests/mapping.cpp b/tests/mapping.cpp
index 13b3407e15..6dcc3f8444 100644
--- a/tests/mapping.cpp
+++ b/tests/mapping.cpp
@@ -34,11 +34,11 @@ using Particle = llama::DS<
 TEST_CASE("address.AoS")
 {
     using UserDomain = llama::UserDomain<2>;
-    auto userDomain = UserDomain{16, 16};
-    auto mapping = llama::mapping::AoS<UserDomain, Particle>{userDomain};
+    auto userDomain = UserDomain {16, 16};
+    auto mapping = llama::mapping::AoS<UserDomain, Particle> {userDomain};
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 16);
@@ -53,7 +53,7 @@ TEST_CASE("address.AoS")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 56);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 64);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 72);
@@ -68,7 +68,7 @@ TEST_CASE("address.AoS")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 904);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 912);
@@ -86,13 +86,11 @@ TEST_CASE("address.AoS")
 TEST_CASE("address.AoS.fortran")
 {
     using UserDomain = llama::UserDomain<2>;
-    auto userDomain = UserDomain{16, 16};
-    auto mapping = llama::mapping::
-        AoS<UserDomain, Particle, llama::mapping::LinearizeUserDomainFortran>{
-            userDomain};
+    auto userDomain = UserDomain {16, 16};
+    auto mapping = llama::mapping::AoS<UserDomain, Particle, llama::mapping::LinearizeUserDomainFortran> {userDomain};
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 16);
@@ -107,7 +105,7 @@ TEST_CASE("address.AoS.fortran")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 904);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 912);
@@ -122,7 +120,7 @@ TEST_CASE("address.AoS.fortran")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 56);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 64);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 72);
@@ -140,13 +138,11 @@ TEST_CASE("address.AoS.fortran")
 TEST_CASE("address.AoS.morton")
 {
     using UserDomain = llama::UserDomain<2>;
-    auto userDomain = UserDomain{16, 16};
-    auto mapping = llama::mapping::
-        AoS<UserDomain, Particle, llama::mapping::LinearizeUserDomainMorton>{
-            userDomain};
+    auto userDomain = UserDomain {16, 16};
+    auto mapping = llama::mapping::AoS<UserDomain, Particle, llama::mapping::LinearizeUserDomainMorton> {userDomain};
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 16);
@@ -161,7 +157,7 @@ TEST_CASE("address.AoS.morton")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 56);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 64);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 72);
@@ -176,7 +172,7 @@ TEST_CASE("address.AoS.morton")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 112);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 120);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 128);
@@ -194,11 +190,11 @@ TEST_CASE("address.AoS.morton")
 TEST_CASE("address.SoA")
 {
     using UserDomain = llama::UserDomain<2>;
-    auto userDomain = UserDomain{16, 16};
-    auto mapping = llama::mapping::SoA<UserDomain, Particle>{userDomain};
+    auto userDomain = UserDomain {16, 16};
+    auto mapping = llama::mapping::SoA<UserDomain, Particle> {userDomain};
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2048);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4096);
@@ -213,7 +209,7 @@ TEST_CASE("address.SoA")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2056);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4104);
@@ -228,7 +224,7 @@ TEST_CASE("address.SoA")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 128);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2176);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4224);
@@ -246,13 +242,11 @@ TEST_CASE("address.SoA")
 TEST_CASE("address.SoA.fortran")
 {
     using UserDomain = llama::UserDomain<2>;
-    auto userDomain = UserDomain{16, 16};
-    auto mapping = llama::mapping::
-        SoA<UserDomain, Particle, llama::mapping::LinearizeUserDomainFortran>{
-            userDomain};
+    auto userDomain = UserDomain {16, 16};
+    auto mapping = llama::mapping::SoA<UserDomain, Particle, llama::mapping::LinearizeUserDomainFortran> {userDomain};
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2048);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4096);
@@ -267,7 +261,7 @@ TEST_CASE("address.SoA.fortran")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 128);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2176);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4224);
@@ -282,7 +276,7 @@ TEST_CASE("address.SoA.fortran")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2056);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4104);
@@ -300,16 +294,15 @@ TEST_CASE("address.SoA.fortran")
 TEST_CASE("address.SoA.morton")
 {
     struct Value
-    {};
+    {
+    };
 
     using UserDomain = llama::UserDomain<2>;
-    auto userDomain = UserDomain{16, 16};
-    auto mapping = llama::mapping::
-        SoA<UserDomain, Particle, llama::mapping::LinearizeUserDomainMorton>{
-            userDomain};
+    auto userDomain = UserDomain {16, 16};
+    auto mapping = llama::mapping::SoA<UserDomain, Particle, llama::mapping::LinearizeUserDomainMorton> {userDomain};
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2048);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4096);
@@ -324,7 +317,7 @@ TEST_CASE("address.SoA.morton")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2056);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4104);
@@ -339,7 +332,7 @@ TEST_CASE("address.SoA.morton")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 16);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2064);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4112);
@@ -357,11 +350,11 @@ TEST_CASE("address.SoA.morton")
 TEST_CASE("address.AoSoA.4")
 {
     using UserDomain = llama::UserDomain<2>;
-    auto userDomain = UserDomain{16, 16};
-    auto mapping = llama::mapping::AoSoA<UserDomain, Particle, 4>{userDomain};
+    auto userDomain = UserDomain {16, 16};
+    auto mapping = llama::mapping::AoSoA<UserDomain, Particle, 4> {userDomain};
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 32);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 64);
@@ -376,7 +369,7 @@ TEST_CASE("address.AoSoA.4")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 40);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 72);
@@ -391,7 +384,7 @@ TEST_CASE("address.AoSoA.4")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 928);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 960);
diff --git a/tests/treemap.cpp b/tests/treemap.cpp
index b5bcde574d..0a96ef84e7 100644
--- a/tests/treemap.cpp
+++ b/tests/treemap.cpp
@@ -45,7 +45,7 @@ namespace tag
     {
         return "Flags";
     }
-}
+} // namespace tag
 
 // clang-format off
 using Name = llama::DS<
@@ -67,24 +67,27 @@ using Name = llama::DS<
 TEST_CASE("treemapping.empty")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList = llama::Tuple{};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 14336);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 16);
@@ -99,7 +102,7 @@ TEST_CASE("treemapping.empty")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 56);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 64);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 72);
@@ -114,7 +117,7 @@ TEST_CASE("treemapping.empty")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 904);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 912);
@@ -132,24 +135,27 @@ TEST_CASE("treemapping.empty")
 TEST_CASE("treemapping.Idem")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList = llama::Tuple{tree::functor::Idem()};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {tree::functor::Idem()};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 14336);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 16);
@@ -164,7 +170,7 @@ TEST_CASE("treemapping.Idem")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 56);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 64);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 72);
@@ -179,7 +185,7 @@ TEST_CASE("treemapping.Idem")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 904);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 912);
@@ -197,24 +203,27 @@ TEST_CASE("treemapping.Idem")
 TEST_CASE("treemapping.LeafOnlyRT")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList = llama::Tuple{tree::functor::LeafOnlyRT()};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {tree::functor::LeafOnlyRT()};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "1C * [ 1C * [ 1C * Pos[ 256R * X(double) , 256R * Y(double) , 256R * Z(double) ] , 256R * Weight(float) , 1C * Momentum[ 256R * Z(double) , 256R * Y(double) "
-          ", 256R * X(double) ] , 1C * Flags[ 256R * (bool) , 256R * (bool) , 256R * (bool) , 256R * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "1C * [ 1C * [ 1C * Pos[ 256R * X(double) , 256R * Y(double) , 256R * Z(double) ] , 256R * Weight(float) , "
+           "1C * Momentum[ 256R * Z(double) , 256R * Y(double) "
+           ", 256R * X(double) ] , 1C * Flags[ 256R * (bool) , 256R * (bool) , 256R * (bool) , 256R * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 14336);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2048);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4096);
@@ -229,7 +238,7 @@ TEST_CASE("treemapping.LeafOnlyRT")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2056);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4104);
@@ -244,7 +253,7 @@ TEST_CASE("treemapping.LeafOnlyRT")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 128);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2176);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 4224);
@@ -262,25 +271,27 @@ TEST_CASE("treemapping.LeafOnlyRT")
 TEST_CASE("treemapping.MoveRTDown<>")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList
-        = llama::Tuple{tree::functor::MoveRTDown<tree::TreeCoord<>>{4}};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {tree::functor::MoveRTDown<tree::TreeCoord<>> {4}};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "4R * [ 64R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "4R * [ 64R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 14336);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 16);
@@ -291,7 +302,7 @@ TEST_CASE("treemapping.MoveRTDown<>")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 56);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 64);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 72);
@@ -302,7 +313,7 @@ TEST_CASE("treemapping.MoveRTDown<>")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 904);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 912);
@@ -316,25 +327,27 @@ TEST_CASE("treemapping.MoveRTDown<>")
 TEST_CASE("treemapping.MoveRTDown<0>")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList
-        = llama::Tuple{tree::functor::MoveRTDown<tree::TreeCoord<0>>{4}};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {tree::functor::MoveRTDown<tree::TreeCoord<0>> {4}};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "16R * [ 4R * [ 4R * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 4R * Weight(float) , 4R * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 4R * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "16R * [ 4R * [ 4R * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 4R * Weight(float) , 4R * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 4R * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 14336);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 16);
@@ -345,7 +358,7 @@ TEST_CASE("treemapping.MoveRTDown<0>")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 24);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 32);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 40);
@@ -356,7 +369,7 @@ TEST_CASE("treemapping.MoveRTDown<0>")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 904);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 912);
@@ -370,25 +383,27 @@ TEST_CASE("treemapping.MoveRTDown<0>")
 TEST_CASE("treemapping.MoveRTDown<0,0>")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList
-        = llama::Tuple{tree::functor::MoveRTDown<tree::TreeCoord<0, 0>>{4}};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {tree::functor::MoveRTDown<tree::TreeCoord<0, 0>> {4}};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "16R * [ 16R * [ 1R * Pos[ 4R * X(double) , 4R * Y(double) , 4R * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "16R * [ 16R * [ 1R * Pos[ 4R * X(double) , 4R * Y(double) , 4R * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 32768);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 32);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 64);
@@ -399,7 +414,7 @@ TEST_CASE("treemapping.MoveRTDown<0,0>")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 128);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 160);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 192);
@@ -410,7 +425,7 @@ TEST_CASE("treemapping.MoveRTDown<0,0>")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 2048);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2080);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 2112);
@@ -424,25 +439,27 @@ TEST_CASE("treemapping.MoveRTDown<0,0>")
 TEST_CASE("treemapping.MoveRTDownFixed<>")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList
-        = llama::Tuple{tree::functor::MoveRTDownFixed<tree::TreeCoord<>, 4>{}};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {tree::functor::MoveRTDownFixed<tree::TreeCoord<>, 4> {}};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "4R * [ 64R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "4R * [ 64R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 14336);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 16);
@@ -453,7 +470,7 @@ TEST_CASE("treemapping.MoveRTDownFixed<>")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 56);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 64);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 72);
@@ -464,7 +481,7 @@ TEST_CASE("treemapping.MoveRTDownFixed<>")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 904);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 912);
@@ -478,25 +495,27 @@ TEST_CASE("treemapping.MoveRTDownFixed<>")
 TEST_CASE("treemapping.MoveRTDownFixed<0>")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList
-        = llama::Tuple{tree::functor::MoveRTDownFixed<tree::TreeCoord<0>, 4>{}};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {tree::functor::MoveRTDownFixed<tree::TreeCoord<0>, 4> {}};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "16R * [ 4R * [ 4R * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 4R * Weight(float) , 4R * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 4R * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "16R * [ 4R * [ 4R * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 4R * Weight(float) , 4R * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 4R * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 14336);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 16);
@@ -507,7 +526,7 @@ TEST_CASE("treemapping.MoveRTDownFixed<0>")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 24);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 32);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 40);
@@ -518,7 +537,7 @@ TEST_CASE("treemapping.MoveRTDownFixed<0>")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 904);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 912);
@@ -532,25 +551,27 @@ TEST_CASE("treemapping.MoveRTDownFixed<0>")
 TEST_CASE("treemapping.MoveRTDownFixed<0,0>")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList = llama::Tuple{
-        tree::functor::MoveRTDownFixed<tree::TreeCoord<0, 0>, 4>{}};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {tree::functor::MoveRTDownFixed<tree::TreeCoord<0, 0>, 4> {}};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "16R * [ 16R * [ 1R * Pos[ 4R * X(double) , 4R * Y(double) , 4R * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "16R * [ 16R * [ 1R * Pos[ 4R * X(double) , 4R * Y(double) , 4R * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 32768);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 32);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 64);
@@ -561,7 +582,7 @@ TEST_CASE("treemapping.MoveRTDownFixed<0,0>")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 128);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 160);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 192);
@@ -572,7 +593,7 @@ TEST_CASE("treemapping.MoveRTDownFixed<0,0>")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 2048);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 2080);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 2112);
@@ -586,34 +607,34 @@ TEST_CASE("treemapping.MoveRTDownFixed<0,0>")
 TEST_CASE("treemapping.vectorblocks.runtime")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
     const auto vectorWidth = 8;
 
-    auto treeOperationList = llama::Tuple{
-        tree::functor::MoveRTDown<tree::TreeCoord<0>>{
-            vectorWidth}, // move 8 down from UserDomain (to
-                          // Position/Weight/Momentum)
-        tree::functor::MoveRTDown<tree::TreeCoord<0, 0>>{
-            vectorWidth}, // move 8 down from Position (to X/Y/Z)
-        tree::functor::MoveRTDown<tree::TreeCoord<0, 2>>{
-            vectorWidth}, // move 8 down from Momentum (to X/Y/Z)
+    auto treeOperationList = llama::Tuple {
+        tree::functor::MoveRTDown<tree::TreeCoord<0>> {vectorWidth}, // move 8 down from UserDomain (to
+                                                                     // Position/Weight/Momentum)
+        tree::functor::MoveRTDown<tree::TreeCoord<0, 0>> {vectorWidth}, // move 8 down from Position (to X/Y/Z)
+        tree::functor::MoveRTDown<tree::TreeCoord<0, 2>> {vectorWidth}, // move 8 down from Momentum (to X/Y/Z)
     };
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "16R * [ 2R * [ 1R * Pos[ 8R * X(double) , 8R * Y(double) , 8R * Z(double) ] , 8R * Weight(float) , "
-          "1R * Momentum[ 8R * Z(double) , 8R * Y(double) , 8R * X(double) ] , 8R * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "16R * [ 2R * [ 1R * Pos[ 8R * X(double) , 8R * Y(double) , 8R * Z(double) ] , 8R * Weight(float) , "
+           "1R * Momentum[ 8R * Z(double) , 8R * Y(double) , 8R * X(double) ] , 8R * Flags[ 1C * (bool) , 1C * (bool) "
+           ", 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 14336);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 64);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 128);
@@ -624,7 +645,7 @@ TEST_CASE("treemapping.vectorblocks.runtime")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 72);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 136);
@@ -635,7 +656,7 @@ TEST_CASE("treemapping.vectorblocks.runtime")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 960);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 1024);
@@ -649,37 +670,34 @@ TEST_CASE("treemapping.vectorblocks.runtime")
 TEST_CASE("treemapping.vectorblocks.compiletime")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
     constexpr auto vectorWidth = 8;
 
-    auto treeOperationList = llama::Tuple{
-        tree::functor::MoveRTDownFixed<
-            tree::TreeCoord<0>,
-            vectorWidth>{}, // move 8 down from UserDomain (to
-                            // Position/Weight/Momentum)
-        tree::functor::MoveRTDownFixed<
-            tree::TreeCoord<0, 0>,
-            vectorWidth>{}, // move 8 down from Position (to X/Y/Z)
-        tree::functor::MoveRTDownFixed<
-            tree::TreeCoord<0, 2>,
-            vectorWidth>{}, // move 8 down from Momentum (to X/Y/Z)
+    auto treeOperationList = llama::Tuple {
+        tree::functor::MoveRTDownFixed<tree::TreeCoord<0>, vectorWidth> {}, // move 8 down from UserDomain (to
+                                                                            // Position/Weight/Momentum)
+        tree::functor::MoveRTDownFixed<tree::TreeCoord<0, 0>, vectorWidth> {}, // move 8 down from Position (to X/Y/Z)
+        tree::functor::MoveRTDownFixed<tree::TreeCoord<0, 2>, vectorWidth> {}, // move 8 down from Momentum (to X/Y/Z)
     };
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "16R * [ 2R * [ 1R * Pos[ 8R * X(double) , 8R * Y(double) , 8R * Z(double) ] , 8R * Weight(float) , "
-          "1R * Momentum[ 8R * Z(double) , 8R * Y(double) , 8R * X(double) ] , 8R * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "16R * [ 2R * [ 1R * Pos[ 8R * X(double) , 8R * Y(double) , 8R * Z(double) ] , 8R * Weight(float) , "
+           "1R * Momentum[ 8R * Z(double) , 8R * Y(double) , 8R * X(double) ] , 8R * Flags[ 1C * (bool) , 1C * (bool) "
+           ", 1C * (bool) , 1C * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 14336);
 
     {
-        const auto coord = UserDomain{0, 0};
+        const auto coord = UserDomain {0, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 0);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 64);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 128);
@@ -690,7 +708,7 @@ TEST_CASE("treemapping.vectorblocks.compiletime")
     }
 
     {
-        const auto coord = UserDomain{0, 1};
+        const auto coord = UserDomain {0, 1};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 8);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 72);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 136);
@@ -701,7 +719,7 @@ TEST_CASE("treemapping.vectorblocks.compiletime")
     }
 
     {
-        const auto coord = UserDomain{1, 0};
+        const auto coord = UserDomain {1, 0};
         CHECK(mapping.getBlobNrAndOffset<0, 0>(coord).offset == 896);
         CHECK(mapping.getBlobNrAndOffset<0, 1>(coord).offset == 960);
         CHECK(mapping.getBlobNrAndOffset<0, 2>(coord).offset == 1024);
@@ -715,64 +733,45 @@ TEST_CASE("treemapping.vectorblocks.compiletime")
 TEST_CASE("treemapping.getNode")
 {
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{16, 16};
+    const UserDomain userDomain {16, 16};
 
-    auto treeOperationList = llama::Tuple{};
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    auto treeOperationList = llama::Tuple {};
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
     using namespace tree;
     using namespace tree::functor::internal;
 
-    CHECK(toString(getNode<TreeCoord<>>(mapping.resultTree)) ==
-          "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) "
-          ", 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(toString(getNode<TreeCoord<0>>(mapping.resultTree)) ==
-          "16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
-          "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ]");
-    CHECK(
-        toString(getNode<TreeCoord<0, 0>>(mapping.resultTree))
-        == "1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ]");
-    CHECK(
-        toString(getNode<TreeCoord<0, 0, 0>>(mapping.resultTree))
-        == "1C * X(double)");
     CHECK(
-        toString(getNode<TreeCoord<0, 0, 1>>(mapping.resultTree))
-        == "1C * Y(double)");
+        toString(getNode<TreeCoord<>>(mapping.resultTree))
+        == "16R * [ 16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) "
+           ", 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * X(double) ] , 1C * Flags[ 1C * (bool) , 1C * "
+           "(bool) , 1C * (bool) , 1C * (bool) ] ] ]");
     CHECK(
-        toString(getNode<TreeCoord<0, 0, 2>>(mapping.resultTree))
-        == "1C * Z(double)");
+        toString(getNode<TreeCoord<0>>(mapping.resultTree))
+        == "16R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C "
+           "* (bool) , 1C * (bool) ] ]");
     CHECK(
-        toString(getNode<TreeCoord<0, 1>>(mapping.resultTree))
-        == "1C * Weight(float)");
+        toString(getNode<TreeCoord<0, 0>>(mapping.resultTree))
+        == "1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ]");
+    CHECK(toString(getNode<TreeCoord<0, 0, 0>>(mapping.resultTree)) == "1C * X(double)");
+    CHECK(toString(getNode<TreeCoord<0, 0, 1>>(mapping.resultTree)) == "1C * Y(double)");
+    CHECK(toString(getNode<TreeCoord<0, 0, 2>>(mapping.resultTree)) == "1C * Z(double)");
+    CHECK(toString(getNode<TreeCoord<0, 1>>(mapping.resultTree)) == "1C * Weight(float)");
     CHECK(
         toString(getNode<TreeCoord<0, 2>>(mapping.resultTree))
         == "1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * X(double) ]");
-    CHECK(
-        toString(getNode<TreeCoord<0, 2, 0>>(mapping.resultTree))
-        == "1C * Z(double)");
-    CHECK(
-        toString(getNode<TreeCoord<0, 2, 1>>(mapping.resultTree))
-        == "1C * Y(double)");
-    CHECK(
-        toString(getNode<TreeCoord<0, 2, 2>>(mapping.resultTree))
-        == "1C * X(double)");
+    CHECK(toString(getNode<TreeCoord<0, 2, 0>>(mapping.resultTree)) == "1C * Z(double)");
+    CHECK(toString(getNode<TreeCoord<0, 2, 1>>(mapping.resultTree)) == "1C * Y(double)");
+    CHECK(toString(getNode<TreeCoord<0, 2, 2>>(mapping.resultTree)) == "1C * X(double)");
     CHECK(
         toString(getNode<TreeCoord<0, 3>>(mapping.resultTree))
         == "1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ]");
-    CHECK(
-        toString(getNode<TreeCoord<0, 3, 0>>(mapping.resultTree))
-        == "1C * (bool)");
-    CHECK(
-        toString(getNode<TreeCoord<0, 3, 1>>(mapping.resultTree))
-        == "1C * (bool)");
-    CHECK(
-        toString(getNode<TreeCoord<0, 3, 2>>(mapping.resultTree))
-        == "1C * (bool)");
-    CHECK(
-        toString(getNode<TreeCoord<0, 3, 3>>(mapping.resultTree))
-        == "1C * (bool)");
+    CHECK(toString(getNode<TreeCoord<0, 3, 0>>(mapping.resultTree)) == "1C * (bool)");
+    CHECK(toString(getNode<TreeCoord<0, 3, 1>>(mapping.resultTree)) == "1C * (bool)");
+    CHECK(toString(getNode<TreeCoord<0, 3, 2>>(mapping.resultTree)) == "1C * (bool)");
+    CHECK(toString(getNode<TreeCoord<0, 3, 3>>(mapping.resultTree)) == "1C * (bool)");
 }
 
 TEST_CASE("treemapping")
@@ -780,15 +779,11 @@ TEST_CASE("treemapping")
     constexpr std::size_t userDomainSize = 12;
 
     using UserDomain = llama::UserDomain<2>;
-    const UserDomain userDomain{userDomainSize, userDomainSize};
+    const UserDomain userDomain {userDomainSize, userDomainSize};
 
-    auto treeOperationList = llama::Tuple{
-        tree::functor::Idem(),
-        tree::functor::LeafOnlyRT{},
-        tree::functor::Idem{}};
+    auto treeOperationList = llama::Tuple {tree::functor::Idem(), tree::functor::LeafOnlyRT {}, tree::functor::Idem {}};
 
-    using Mapping
-        = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
+    using Mapping = tree::Mapping<UserDomain, Name, decltype(treeOperationList)>;
     const Mapping mapping(userDomain, treeOperationList);
 
     auto raw = prettyPrintType(mapping.basicTree);
@@ -1052,11 +1047,16 @@ TEST_CASE("treemapping")
     >
 >)");
 
-    CHECK(tree::toString(mapping.basicTree) ==
-          "12R * [ 12R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
-          "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
-    CHECK(tree::toString(mapping.resultTree) ==
-          "1C * [ 1C * [ 1C * Pos[ 144R * X(double) , 144R * Y(double) , 144R * Z(double) ] , 144R * Weight(float) , 1C * Momentum[ 144R * Z(double) , 144R * Y(double) , 144R * X(double) ] , 1C * Flags[ 144R * (bool) , 144R * (bool) , 144R * (bool) , 144R * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.basicTree)
+        == "12R * [ 12R * [ 1C * Pos[ 1C * X(double) , 1C * Y(double) , 1C * Z(double) ] , 1C * Weight(float) , 1C * "
+           "Momentum[ 1C * Z(double) , 1C * Y(double) , 1C * "
+           "X(double) ] , 1C * Flags[ 1C * (bool) , 1C * (bool) , 1C * (bool) , 1C * (bool) ] ] ]");
+    CHECK(
+        tree::toString(mapping.resultTree)
+        == "1C * [ 1C * [ 1C * Pos[ 144R * X(double) , 144R * Y(double) , 144R * Z(double) ] , 144R * Weight(float) , "
+           "1C * Momentum[ 144R * Z(double) , 144R * Y(double) , 144R * X(double) ] , 1C * Flags[ 144R * (bool) , 144R "
+           "* (bool) , 144R * (bool) , 144R * (bool) ] ] ]");
 
     CHECK(mapping.getBlobSize(0) == 8064);
     CHECK(mapping.getBlobNrAndOffset<2, 1>({50, 100}).offset == 10784);
@@ -1065,57 +1065,45 @@ TEST_CASE("treemapping")
     auto view = allocView(mapping);
     zeroStorage(view);
 
-    for(size_t x = 0; x < userDomain[0]; ++x)
-        for(size_t y = 0; y < userDomain[1]; ++y)
+    for (size_t x = 0; x < userDomain[0]; ++x)
+        for (size_t y = 0; y < userDomain[1]; ++y)
         {
             auto datum = view(x, y);
-            llama::forEach<Name>(
-                [&](auto coord) { datum(coord) = 0; }, tag::Momentum{});
+            llama::forEach<Name>([&](auto coord) { datum(coord) = 0; }, tag::Momentum {});
         }
     double sum = 0.0;
-    for(size_t x = 0; x < userDomain[0]; ++x)
-        for(size_t y = 0; y < userDomain[1]; ++y)
+    for (size_t x = 0; x < userDomain[0]; ++x)
+        for (size_t y = 0; y < userDomain[1]; ++y)
             sum += view({x, y}).access<0, 1>();
     CHECK(sum == 0);
 }
 
 TEST_CASE("treeCoordToString")
 {
-    const auto coord = llama::UserDomain<3>{6, 7, 8};
+    const auto coord = llama::UserDomain<3> {6, 7, 8};
     CHECK(
-        tree::treeCoordToString(
-            tree::createTreeCoord<llama::DatumCoord<0, 0>>(coord))
+        tree::treeCoordToString(tree::createTreeCoord<llama::DatumCoord<0, 0>>(coord))
         == "[ 6:0, 7:0, 8:0, 0:0, 0:0 ]");
     CHECK(
-        tree::treeCoordToString(
-            tree::createTreeCoord<llama::DatumCoord<0, 1>>(coord))
+        tree::treeCoordToString(tree::createTreeCoord<llama::DatumCoord<0, 1>>(coord))
         == "[ 6:0, 7:0, 8:0, 0:1, 0:0 ]");
     CHECK(
-        tree::treeCoordToString(
-            tree::createTreeCoord<llama::DatumCoord<0, 2>>(coord))
+        tree::treeCoordToString(tree::createTreeCoord<llama::DatumCoord<0, 2>>(coord))
         == "[ 6:0, 7:0, 8:0, 0:2, 0:0 ]");
+    CHECK(tree::treeCoordToString(tree::createTreeCoord<llama::DatumCoord<1>>(coord)) == "[ 6:0, 7:0, 8:1, 0:0 ]");
     CHECK(
-        tree::treeCoordToString(
-            tree::createTreeCoord<llama::DatumCoord<1>>(coord))
-        == "[ 6:0, 7:0, 8:1, 0:0 ]");
-    CHECK(
-        tree::treeCoordToString(
-            tree::createTreeCoord<llama::DatumCoord<2, 0>>(coord))
+        tree::treeCoordToString(tree::createTreeCoord<llama::DatumCoord<2, 0>>(coord))
         == "[ 6:0, 7:0, 8:2, 0:0, 0:0 ]");
     CHECK(
-        tree::treeCoordToString(
-            tree::createTreeCoord<llama::DatumCoord<2, 1>>(coord))
+        tree::treeCoordToString(tree::createTreeCoord<llama::DatumCoord<2, 1>>(coord))
         == "[ 6:0, 7:0, 8:2, 0:1, 0:0 ]");
     CHECK(
-        tree::treeCoordToString(
-            tree::createTreeCoord<llama::DatumCoord<2, 2>>(coord))
+        tree::treeCoordToString(tree::createTreeCoord<llama::DatumCoord<2, 2>>(coord))
         == "[ 6:0, 7:0, 8:2, 0:2, 0:0 ]");
     CHECK(
-        tree::treeCoordToString(
-            tree::createTreeCoord<llama::DatumCoord<3, 0>>(coord))
+        tree::treeCoordToString(tree::createTreeCoord<llama::DatumCoord<3, 0>>(coord))
         == "[ 6:0, 7:0, 8:3, 0:0, 0:0 ]");
     CHECK(
-        tree::treeCoordToString(
-            tree::createTreeCoord<llama::DatumCoord<3, 1>>(coord))
+        tree::treeCoordToString(tree::createTreeCoord<llama::DatumCoord<3, 1>>(coord))
         == "[ 6:0, 7:0, 8:3, 0:1, 0:0 ]");
 }
diff --git a/tests/uid.cpp b/tests/uid.cpp
index 18e805dce2..2d9c6fb6c2 100644
--- a/tests/uid.cpp
+++ b/tests/uid.cpp
@@ -77,10 +77,8 @@ TEST_CASE("GetTag")
 
 TEST_CASE("hasSameTags")
 {
-    using PosDomain
-        = llama::GetType<Particle, llama::GetCoordFromTags<Particle, tag::Pos>>;
-    using VelDomain
-        = llama::GetType<Particle, llama::GetCoordFromTags<Particle, tag::Vel>>;
+    using PosDomain = llama::GetType<Particle, llama::GetCoordFromTags<Particle, tag::Pos>>;
+    using VelDomain = llama::GetType<Particle, llama::GetCoordFromTags<Particle, tag::Vel>>;
 
     STATIC_REQUIRE(
         llama::hasSameTags<
diff --git a/tests/userdomain.cpp b/tests/userdomain.cpp
index 254287339a..9983ec3a93 100644
--- a/tests/userdomain.cpp
+++ b/tests/userdomain.cpp
@@ -23,10 +23,10 @@ using Name = llama::DS<
 
 TEST_CASE("UserDomain.CTAD")
 {
-    llama::UserDomain ud0{};
-    llama::UserDomain ud1{1};
-    llama::UserDomain ud2{1, 1};
-    llama::UserDomain ud3{1, 1, 1};
+    llama::UserDomain ud0 {};
+    llama::UserDomain ud1 {1};
+    llama::UserDomain ud2 {1, 1};
+    llama::UserDomain ud3 {1, 1, 1};
 
     STATIC_REQUIRE(decltype(ud0)::rank == 0);
     STATIC_REQUIRE(decltype(ud1)::rank == 1);
@@ -37,129 +37,120 @@ TEST_CASE("UserDomain.CTAD")
 TEST_CASE("UserDomain.dim0")
 {
     using UserDomain = llama::UserDomain<0>;
-    UserDomain userDomain{};
+    UserDomain userDomain {};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    float & x = view(UserDomain{}).access<tag::Pos, tag::X>();
+    float& x = view(UserDomain {}).access<tag::Pos, tag::X>();
     x = 0;
 }
 
 TEST_CASE("UserDomain.dim1")
 {
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{16};
+    UserDomain userDomain {16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    float & x = view(UserDomain{0}).access<tag::Pos, tag::X>();
+    float& x = view(UserDomain {0}).access<tag::Pos, tag::X>();
     x = 0;
 }
 
 TEST_CASE("UserDomain.dim2")
 {
     using UserDomain = llama::UserDomain<2>;
-    UserDomain userDomain{16, 16};
+    UserDomain userDomain {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    float & x = view(UserDomain{0, 0}).access<tag::Pos, tag::X>();
+    float& x = view(UserDomain {0, 0}).access<tag::Pos, tag::X>();
     x = 0;
 }
 
 TEST_CASE("UserDomain.dim3")
 {
     using UserDomain = llama::UserDomain<3>;
-    UserDomain userDomain{16, 16, 16};
+    UserDomain userDomain {16, 16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    float & x = view(UserDomain{0, 0, 0}).access<tag::Pos, tag::X>();
+    float& x = view(UserDomain {0, 0, 0}).access<tag::Pos, tag::X>();
     x = 0;
 }
 
 TEST_CASE("UserDomain.dim10")
 {
     using UserDomain = llama::UserDomain<10>;
-    UserDomain userDomain{2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+    UserDomain userDomain {2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
 
     using Mapping = llama::mapping::SoA<UserDomain, Name>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    float & x = view(UserDomain{0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
-                    .access<tag::Pos, tag::X>();
+    float& x = view(UserDomain {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}).access<tag::Pos, tag::X>();
     x = 0;
 }
 
 TEST_CASE("UserDomain.ctor")
 {
-    llama::UserDomain<1> ud{};
+    llama::UserDomain<1> ud {};
     CHECK(ud[0] == 0);
 }
 
 TEST_CASE("UserDomainCoordRange1D")
 {
-    llama::UserDomain<1> ud{3};
+    llama::UserDomain<1> ud {3};
 
     std::vector<llama::UserDomain<1>> coords;
-    for(auto coord : llama::UserDomainCoordRange{ud}) coords.push_back(coord);
+    for (auto coord : llama::UserDomainCoordRange {ud})
+        coords.push_back(coord);
 
-    CHECK(coords == std::vector<llama::UserDomain<1>>{{0}, {1}, {2}});
+    CHECK(coords == std::vector<llama::UserDomain<1>> {{0}, {1}, {2}});
 }
 
 TEST_CASE("UserDomainCoordRange2D")
 {
-    llama::UserDomain<2> ud{3, 3};
+    llama::UserDomain<2> ud {3, 3};
 
     std::vector<llama::UserDomain<2>> coords;
-    for(auto coord : llama::UserDomainCoordRange{ud}) coords.push_back(coord);
+    for (auto coord : llama::UserDomainCoordRange {ud})
+        coords.push_back(coord);
 
     CHECK(
         coords
-        == std::vector<llama::UserDomain<2>>{
-            {0, 0},
-            {0, 1},
-            {0, 2},
-            {1, 0},
-            {1, 1},
-            {1, 2},
-            {2, 0},
-            {2, 1},
-            {2, 2}});
+        == std::vector<llama::UserDomain<2>> {{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}, {2, 2}});
 }
 
 TEST_CASE("UserDomainCoordRange3D")
 {
-    llama::UserDomain<3> ud{3, 3, 3};
+    llama::UserDomain<3> ud {3, 3, 3};
 
     std::vector<llama::UserDomain<3>> coords;
-    for(auto coord : llama::UserDomainCoordRange{ud}) coords.push_back(coord);
+    for (auto coord : llama::UserDomainCoordRange {ud})
+        coords.push_back(coord);
 
     CHECK(
         coords
-        == std::vector<llama::UserDomain<3>>{
-            {0, 0, 0}, {0, 0, 1}, {0, 0, 2}, {0, 1, 0}, {0, 1, 1}, {0, 1, 2},
-            {0, 2, 0}, {0, 2, 1}, {0, 2, 2}, {1, 0, 0}, {1, 0, 1}, {1, 0, 2},
-            {1, 1, 0}, {1, 1, 1}, {1, 1, 2}, {1, 2, 0}, {1, 2, 1}, {1, 2, 2},
-            {2, 0, 0}, {2, 0, 1}, {2, 0, 2}, {2, 1, 0}, {2, 1, 1}, {2, 1, 2},
-            {2, 2, 0}, {2, 2, 1}, {2, 2, 2},
+        == std::vector<llama::UserDomain<3>> {
+            {0, 0, 0}, {0, 0, 1}, {0, 0, 2}, {0, 1, 0}, {0, 1, 1}, {0, 1, 2}, {0, 2, 0}, {0, 2, 1}, {0, 2, 2},
+            {1, 0, 0}, {1, 0, 1}, {1, 0, 2}, {1, 1, 0}, {1, 1, 1}, {1, 1, 2}, {1, 2, 0}, {1, 2, 1}, {1, 2, 2},
+            {2, 0, 0}, {2, 0, 1}, {2, 0, 2}, {2, 1, 0}, {2, 1, 1}, {2, 1, 2}, {2, 2, 0}, {2, 2, 1}, {2, 2, 2},
         });
 }
 
 TEST_CASE("UserDomainCoordRange3D.destructering")
 {
-    llama::UserDomain<3> ud{1, 1, 1};
+    llama::UserDomain<3> ud {1, 1, 1};
 
-    for(auto [x, y, z] : llama::UserDomainCoordRange{ud})
+    for (auto [x, y, z] : llama::UserDomainCoordRange {ud})
     {
         CHECK(x == 0);
         CHECK(y == 0);
@@ -170,28 +161,28 @@ TEST_CASE("UserDomainCoordRange3D.destructering")
 TEST_CASE("Morton")
 {
     using UserDomain = llama::UserDomain<2>;
-    UserDomain userDomain{2, 3};
+    UserDomain userDomain {2, 3};
 
     llama::mapping::LinearizeUserDomainMorton lin;
-    CHECK(lin.size(UserDomain{2, 3}) == 4 * 4);
-    CHECK(lin.size(UserDomain{2, 4}) == 4 * 4);
-    CHECK(lin.size(UserDomain{2, 5}) == 8 * 8);
-    CHECK(lin.size(UserDomain{8, 8}) == 8 * 8);
-
-    CHECK(lin(UserDomain{0, 0}, {}) == 0);
-    CHECK(lin(UserDomain{0, 1}, {}) == 1);
-    CHECK(lin(UserDomain{0, 2}, {}) == 4);
-    CHECK(lin(UserDomain{0, 3}, {}) == 5);
-    CHECK(lin(UserDomain{1, 0}, {}) == 2);
-    CHECK(lin(UserDomain{1, 1}, {}) == 3);
-    CHECK(lin(UserDomain{1, 2}, {}) == 6);
-    CHECK(lin(UserDomain{1, 3}, {}) == 7);
-    CHECK(lin(UserDomain{2, 0}, {}) == 8);
-    CHECK(lin(UserDomain{2, 1}, {}) == 9);
-    CHECK(lin(UserDomain{2, 2}, {}) == 12);
-    CHECK(lin(UserDomain{2, 3}, {}) == 13);
-    CHECK(lin(UserDomain{3, 0}, {}) == 10);
-    CHECK(lin(UserDomain{3, 1}, {}) == 11);
-    CHECK(lin(UserDomain{3, 2}, {}) == 14);
-    CHECK(lin(UserDomain{3, 3}, {}) == 15);
+    CHECK(lin.size(UserDomain {2, 3}) == 4 * 4);
+    CHECK(lin.size(UserDomain {2, 4}) == 4 * 4);
+    CHECK(lin.size(UserDomain {2, 5}) == 8 * 8);
+    CHECK(lin.size(UserDomain {8, 8}) == 8 * 8);
+
+    CHECK(lin(UserDomain {0, 0}, {}) == 0);
+    CHECK(lin(UserDomain {0, 1}, {}) == 1);
+    CHECK(lin(UserDomain {0, 2}, {}) == 4);
+    CHECK(lin(UserDomain {0, 3}, {}) == 5);
+    CHECK(lin(UserDomain {1, 0}, {}) == 2);
+    CHECK(lin(UserDomain {1, 1}, {}) == 3);
+    CHECK(lin(UserDomain {1, 2}, {}) == 6);
+    CHECK(lin(UserDomain {1, 3}, {}) == 7);
+    CHECK(lin(UserDomain {2, 0}, {}) == 8);
+    CHECK(lin(UserDomain {2, 1}, {}) == 9);
+    CHECK(lin(UserDomain {2, 2}, {}) == 12);
+    CHECK(lin(UserDomain {2, 3}, {}) == 13);
+    CHECK(lin(UserDomain {3, 0}, {}) == 10);
+    CHECK(lin(UserDomain {3, 1}, {}) == 11);
+    CHECK(lin(UserDomain {3, 2}, {}) == 14);
+    CHECK(lin(UserDomain {3, 3}, {}) == 15);
 }
diff --git a/tests/view.cpp b/tests/view.cpp
index e8dd901d0e..394446d57b 100644
--- a/tests/view.cpp
+++ b/tests/view.cpp
@@ -17,27 +17,19 @@ using DatumDomain = llama::DS<
 TEST_CASE("view.default-ctor")
 {
     using UserDomain = llama::UserDomain<2>;
-    constexpr UserDomain viewSize{16, 16};
-
-    [[maybe_unused]] llama::
-        View<llama::mapping::SoA<UserDomain, DatumDomain>, std::byte *>
-            view1;
-    [[maybe_unused]] llama::
-        View<llama::mapping::AoS<UserDomain, DatumDomain>, std::byte *>
-            view2;
-    [[maybe_unused]] llama::
-        View<llama::mapping::One<UserDomain, DatumDomain>, std::byte *>
-            view3;
-    [[maybe_unused]] llama::View<
-        llama::mapping::tree::Mapping<UserDomain, DatumDomain, llama::Tuple<>>,
-        std::byte *>
+    constexpr UserDomain viewSize {16, 16};
+
+    [[maybe_unused]] llama::View<llama::mapping::SoA<UserDomain, DatumDomain>, std::byte*> view1;
+    [[maybe_unused]] llama::View<llama::mapping::AoS<UserDomain, DatumDomain>, std::byte*> view2;
+    [[maybe_unused]] llama::View<llama::mapping::One<UserDomain, DatumDomain>, std::byte*> view3;
+    [[maybe_unused]] llama::View<llama::mapping::tree::Mapping<UserDomain, DatumDomain, llama::Tuple<>>, std::byte*>
         view4;
 }
 
 TEST_CASE("view.move")
 {
     using UserDomain = llama::UserDomain<2>;
-    constexpr UserDomain viewSize{16, 16};
+    constexpr UserDomain viewSize {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, DatumDomain>;
     auto view1 = allocView(Mapping(viewSize));
@@ -51,7 +43,7 @@ TEST_CASE("view.move")
 TEST_CASE("view.swap")
 {
     using UserDomain = llama::UserDomain<2>;
-    constexpr UserDomain viewSize{16, 16};
+    constexpr UserDomain viewSize {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, DatumDomain>;
     auto view1 = allocView(Mapping(viewSize));
@@ -69,52 +61,53 @@ TEST_CASE("view.swap")
 TEST_CASE("view.allocator.Vector")
 {
     using UserDomain = llama::UserDomain<2>;
-    constexpr UserDomain viewSize{16, 16};
+    constexpr UserDomain viewSize {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, DatumDomain>;
-    auto view = allocView(Mapping(viewSize), llama::allocator::Vector{});
+    auto view = allocView(Mapping(viewSize), llama::allocator::Vector {});
 
-    for(auto i : llama::UserDomainCoordRange{viewSize}) view(i) = 42;
+    for (auto i : llama::UserDomainCoordRange {viewSize})
+        view(i) = 42;
 }
 
 TEST_CASE("view.allocator.SharedPtr")
 {
     using UserDomain = llama::UserDomain<2>;
-    constexpr UserDomain viewSize{16, 16};
+    constexpr UserDomain viewSize {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, DatumDomain>;
-    auto view = allocView(Mapping(viewSize), llama::allocator::SharedPtr{});
+    auto view = allocView(Mapping(viewSize), llama::allocator::SharedPtr {});
 
-    for(auto i : llama::UserDomainCoordRange{viewSize}) view(i) = 42;
+    for (auto i : llama::UserDomainCoordRange {viewSize})
+        view(i) = 42;
 }
 
 TEST_CASE("view.allocator.stack")
 {
     using UserDomain = llama::UserDomain<2>;
-    constexpr UserDomain viewSize{16, 16};
+    constexpr UserDomain viewSize {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, DatumDomain>;
-    auto view = allocView(
-        Mapping(viewSize),
-        llama::allocator::Stack<16 * 16 * llama::sizeOf<DatumDomain>>{});
+    auto view = allocView(Mapping(viewSize), llama::allocator::Stack<16 * 16 * llama::sizeOf<DatumDomain>> {});
 
-    for(auto i : llama::UserDomainCoordRange{viewSize}) view(i) = 42;
+    for (auto i : llama::UserDomainCoordRange {viewSize})
+        view(i) = 42;
 }
 
 TEST_CASE("view.non-memory-owning")
 {
     using UserDomain = llama::UserDomain<1>;
-    UserDomain userDomain{256};
+    UserDomain userDomain {256};
 
     using Mapping = llama::mapping::SoA<UserDomain, DatumDomain>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
 
     std::vector<std::byte> storage(mapping.getBlobSize(0));
-    auto view = llama::View<Mapping, std::byte *>{mapping, {storage.data()}};
+    auto view = llama::View<Mapping, std::byte*> {mapping, {storage.data()}};
 
-    for(auto i = 0u; i < 256u; i++)
+    for (auto i = 0u; i < 256u; i++)
     {
-        auto * v = (std::byte *)&view(i)(tag::Value{});
+        auto* v = (std::byte*) &view(i)(tag::Value {});
         CHECK(&storage.front() <= v);
         CHECK(v <= &storage.back());
     }
@@ -151,59 +144,41 @@ using Particle = llama::DS<
 TEST_CASE("view.access")
 {
     using UserDomain = llama::UserDomain<2>;
-    UserDomain userDomain{16, 16};
+    UserDomain userDomain {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Particle>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
     zeroStorage(view);
 
-    auto l = [](auto & view) {
-        const UserDomain pos{0, 0};
+    auto l = [](auto& view) {
+        const UserDomain pos {0, 0};
         CHECK((view(pos) == view[pos]));
         CHECK((view(pos) == view[{0, 0}]));
         CHECK((view(pos) == view({0, 0})));
 
-        const auto & x = view(pos).template access<0, 0>();
+        const auto& x = view(pos).template access<0, 0>();
         CHECK(&x == &view(pos).template access<0>().template access<0>());
         CHECK(&x == &view(pos).template access<0>().template access<tag::X>());
-        CHECK(
-            &x == &view(pos).template access<tag::Pos>().template access<0>());
+        CHECK(&x == &view(pos).template access<tag::Pos>().template access<0>());
         CHECK(&x == &view(pos).template access<tag::Pos, tag::X>());
-        CHECK(
-            &x
-            == &view(pos)
-                    .template access<tag::Pos>()
-                    .template access<tag::X>());
-        CHECK(&x == &view(pos)(tag::Pos{}, tag::X{}));
-        CHECK(&x == &view(pos)(tag::Pos{})(tag::X{}));
-        CHECK(&x == &view(pos).template access<tag::Pos>()(tag::X{}));
-        CHECK(&x == &view(pos)(tag::Pos{}).template access<tag::X>());
-        CHECK(&x == &view(pos)(llama::DatumCoord<0, 0>{}));
-        CHECK(&x == &view(pos)(llama::DatumCoord<0>{})(llama::DatumCoord<0>{}));
+        CHECK(&x == &view(pos).template access<tag::Pos>().template access<tag::X>());
+        CHECK(&x == &view(pos)(tag::Pos {}, tag::X {}));
+        CHECK(&x == &view(pos)(tag::Pos {})(tag::X {}));
+        CHECK(&x == &view(pos).template access<tag::Pos>()(tag::X {}));
+        CHECK(&x == &view(pos)(tag::Pos {}).template access<tag::X>());
+        CHECK(&x == &view(pos)(llama::DatumCoord<0, 0> {}));
+        CHECK(&x == &view(pos)(llama::DatumCoord<0> {})(llama::DatumCoord<0> {}));
         CHECK(&x == &view(pos).template access<llama::DatumCoord<0, 0>>());
-        CHECK(
-            &x
-            == &view(pos)
-                    .template access<llama::DatumCoord<0>>()
-                    .template access<llama::DatumCoord<0>>());
+        CHECK(&x == &view(pos).template access<llama::DatumCoord<0>>().template access<llama::DatumCoord<0>>());
         // there are even more combinations
 
         // also test arrays
-        const bool & o0
-            = view(pos).template access<tag::Flags>().template access<0>();
-        CHECK(
-            &o0
-            == &view(pos)
-                    .template access<tag::Flags>()
-                    .template access<llama::Index<0>>());
-        CHECK(
-            &o0
-            == &view(pos).template access<tag::Flags>().access(
-                llama::Index<0>{}));
-        CHECK(
-            &o0 == &view(pos).template access<tag::Flags>()(llama::Index<0>{}));
+        const bool& o0 = view(pos).template access<tag::Flags>().template access<0>();
+        CHECK(&o0 == &view(pos).template access<tag::Flags>().template access<llama::Index<0>>());
+        CHECK(&o0 == &view(pos).template access<tag::Flags>().access(llama::Index<0> {}));
+        CHECK(&o0 == &view(pos).template access<tag::Flags>()(llama::Index<0> {}));
     };
     l(view);
     l(std::as_const(view));
@@ -212,76 +187,76 @@ TEST_CASE("view.access")
 TEST_CASE("view.assign-one-datum")
 {
     using UserDomain = llama::UserDomain<2>;
-    UserDomain userDomain{16, 16};
+    UserDomain userDomain {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Particle>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
     auto datum = llama::allocVirtualDatumStack<Particle>();
-    datum(tag::Pos{}, tag::X{}) = 14.0f;
-    datum(tag::Pos{}, tag::Y{}) = 15.0f;
-    datum(tag::Pos{}, tag::Z{}) = 16.0f;
-    datum(tag::Momentum{}) = 0;
-    datum(tag::Weight{}) = 500.0f;
-    datum(tag::Flags{}).access<0>() = true;
-    datum(tag::Flags{}).access<1>() = false;
-    datum(tag::Flags{}).access<2>() = true;
-    datum(tag::Flags{}).access<3>() = false;
+    datum(tag::Pos {}, tag::X {}) = 14.0f;
+    datum(tag::Pos {}, tag::Y {}) = 15.0f;
+    datum(tag::Pos {}, tag::Z {}) = 16.0f;
+    datum(tag::Momentum {}) = 0;
+    datum(tag::Weight {}) = 500.0f;
+    datum(tag::Flags {}).access<0>() = true;
+    datum(tag::Flags {}).access<1>() = false;
+    datum(tag::Flags {}).access<2>() = true;
+    datum(tag::Flags {}).access<3>() = false;
 
     view({3, 4}) = datum;
 
-    CHECK(datum(tag::Pos{}, tag::X{}) == 14.0f);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 15.0f);
-    CHECK(datum(tag::Pos{}, tag::Z{}) == 16.0f);
-    CHECK(datum(tag::Momentum{}, tag::X{}) == 0);
-    CHECK(datum(tag::Momentum{}, tag::Y{}) == 0);
-    CHECK(datum(tag::Momentum{}, tag::Z{}) == 0);
-    CHECK(datum(tag::Weight{}) == 500.0f);
-    CHECK(datum(tag::Flags{}).access<0>() == true);
-    CHECK(datum(tag::Flags{}).access<1>() == false);
-    CHECK(datum(tag::Flags{}).access<2>() == true);
-    CHECK(datum(tag::Flags{}).access<3>() == false);
+    CHECK(datum(tag::Pos {}, tag::X {}) == 14.0f);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 15.0f);
+    CHECK(datum(tag::Pos {}, tag::Z {}) == 16.0f);
+    CHECK(datum(tag::Momentum {}, tag::X {}) == 0);
+    CHECK(datum(tag::Momentum {}, tag::Y {}) == 0);
+    CHECK(datum(tag::Momentum {}, tag::Z {}) == 0);
+    CHECK(datum(tag::Weight {}) == 500.0f);
+    CHECK(datum(tag::Flags {}).access<0>() == true);
+    CHECK(datum(tag::Flags {}).access<1>() == false);
+    CHECK(datum(tag::Flags {}).access<2>() == true);
+    CHECK(datum(tag::Flags {}).access<3>() == false);
 }
 
 TEST_CASE("view.addresses")
 {
     using UserDomain = llama::UserDomain<2>;
-    UserDomain userDomain{16, 16};
+    UserDomain userDomain {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Particle>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
-    const UserDomain pos{0, 0};
-    auto & x = view(pos).access<tag::Pos, tag::X>();
-    auto & y = view(pos).access<tag::Pos, tag::Y>();
-    auto & z = view(pos).access<tag::Pos, tag::Z>();
-    auto & w = view(pos).access<tag::Weight>();
-    auto & mx = view(pos).access<tag::Momentum, tag::X>();
-    auto & my = view(pos).access<tag::Momentum, tag::Y>();
-    auto & mz = view(pos).access<tag::Momentum, tag::Z>();
-    auto & o0 = view(pos).access<tag::Flags>().access<0>();
-    auto & o1 = view(pos).access<tag::Flags>().access<1>();
-    auto & o2 = view(pos).access<tag::Flags>().access<2>();
-    auto & o3 = view(pos).access<tag::Flags>().access<3>();
-
-    CHECK((size_t)&y - (size_t)&x == 2048);
-    CHECK((size_t)&z - (size_t)&x == 4096);
-    CHECK((size_t)&mx - (size_t)&x == 7168);
-    CHECK((size_t)&my - (size_t)&x == 9216);
-    CHECK((size_t)&mz - (size_t)&x == 11264);
-    CHECK((size_t)&w - (size_t)&x == 6144);
-    CHECK((size_t)&o0 - (size_t)&x == 13312);
-    CHECK((size_t)&o1 - (size_t)&x == 13568);
-    CHECK((size_t)&o2 - (size_t)&x == 13824);
-    CHECK((size_t)&o3 - (size_t)&x == 14080);
+    const UserDomain pos {0, 0};
+    auto& x = view(pos).access<tag::Pos, tag::X>();
+    auto& y = view(pos).access<tag::Pos, tag::Y>();
+    auto& z = view(pos).access<tag::Pos, tag::Z>();
+    auto& w = view(pos).access<tag::Weight>();
+    auto& mx = view(pos).access<tag::Momentum, tag::X>();
+    auto& my = view(pos).access<tag::Momentum, tag::Y>();
+    auto& mz = view(pos).access<tag::Momentum, tag::Z>();
+    auto& o0 = view(pos).access<tag::Flags>().access<0>();
+    auto& o1 = view(pos).access<tag::Flags>().access<1>();
+    auto& o2 = view(pos).access<tag::Flags>().access<2>();
+    auto& o3 = view(pos).access<tag::Flags>().access<3>();
+
+    CHECK((size_t) &y - (size_t) &x == 2048);
+    CHECK((size_t) &z - (size_t) &x == 4096);
+    CHECK((size_t) &mx - (size_t) &x == 7168);
+    CHECK((size_t) &my - (size_t) &x == 9216);
+    CHECK((size_t) &mz - (size_t) &x == 11264);
+    CHECK((size_t) &w - (size_t) &x == 6144);
+    CHECK((size_t) &o0 - (size_t) &x == 13312);
+    CHECK((size_t) &o1 - (size_t) &x == 13568);
+    CHECK((size_t) &o2 - (size_t) &x == 13824);
+    CHECK((size_t) &o3 - (size_t) &x == 14080);
 }
 
-template<typename VirtualDatum>
+template <typename VirtualDatum>
 struct SetZeroFunctor
 {
-    template<typename Coord>
+    template <typename Coord>
     void operator()(Coord coord)
     {
         vd(coord) = 0;
@@ -292,27 +267,26 @@ struct SetZeroFunctor
 TEST_CASE("view.iteration-and-access")
 {
     using UserDomain = llama::UserDomain<2>;
-    UserDomain userDomain{16, 16};
+    UserDomain userDomain {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Particle>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
     zeroStorage(view);
 
-    for(size_t x = 0; x < userDomain[0]; ++x)
-        for(size_t y = 0; y < userDomain[1]; ++y)
+    for (size_t x = 0; x < userDomain[0]; ++x)
+        for (size_t y = 0; y < userDomain[1]; ++y)
         {
-            SetZeroFunctor<decltype(view(x, y))> szf{view(x, y)};
-            llama::forEach<Particle>(szf, llama::DatumCoord<0, 0>{});
-            llama::forEach<Particle>(szf, tag::Momentum{});
-            view({x, y})
-                = double(x + y) / double(userDomain[0] + userDomain[1]);
+            SetZeroFunctor<decltype(view(x, y))> szf {view(x, y)};
+            llama::forEach<Particle>(szf, llama::DatumCoord<0, 0> {});
+            llama::forEach<Particle>(szf, tag::Momentum {});
+            view({x, y}) = double(x + y) / double(userDomain[0] + userDomain[1]);
         }
 
     double sum = 0.0;
-    for(size_t x = 0; x < userDomain[0]; ++x)
-        for(size_t y = 0; y < userDomain[1]; ++y)
+    for (size_t x = 0; x < userDomain[0]; ++x)
+        for (size_t y = 0; y < userDomain[1]; ++y)
             sum += view(x, y).access<2, 0>();
     CHECK(sum == 120.0);
 }
@@ -320,29 +294,27 @@ TEST_CASE("view.iteration-and-access")
 TEST_CASE("view.datum-access")
 {
     using UserDomain = llama::UserDomain<2>;
-    UserDomain userDomain{16, 16};
+    UserDomain userDomain {16, 16};
 
     using Mapping = llama::mapping::SoA<UserDomain, Particle>;
-    Mapping mapping{userDomain};
+    Mapping mapping {userDomain};
     auto view = allocView(mapping);
 
     zeroStorage(view);
 
-    for(size_t x = 0; x < userDomain[0]; ++x)
-        for(size_t y = 0; y < userDomain[1]; ++y)
+    for (size_t x = 0; x < userDomain[0]; ++x)
+        for (size_t y = 0; y < userDomain[1]; ++y)
         {
             auto datum = view(x, y);
-            datum.access<tag::Pos, tag::X>()
-                += datum.access<llama::DatumCoord<2, 0>>();
-            datum.access(tag::Pos(), tag::Y())
-                += datum.access(llama::DatumCoord<2, 1>());
+            datum.access<tag::Pos, tag::X>() += datum.access<llama::DatumCoord<2, 0>>();
+            datum.access(tag::Pos(), tag::Y()) += datum.access(llama::DatumCoord<2, 1>());
             datum(tag::Pos(), tag::Z()) += datum(llama::DatumCoord<1>());
             datum(tag::Pos()) += datum(tag::Momentum());
         }
 
     double sum = 0.0;
-    for(size_t x = 0; x < userDomain[0]; ++x)
-        for(size_t y = 0; y < userDomain[1]; ++y)
+    for (size_t x = 0; x < userDomain[0]; ++x)
+        for (size_t y = 0; y < userDomain[1]; ++y)
             sum += view(x, y).access<2, 0>();
 
     CHECK(sum == 0.0);
diff --git a/tests/virtualdatum.cpp b/tests/virtualdatum.cpp
index 859480812a..8fece8e1ba 100644
--- a/tests/virtualdatum.cpp
+++ b/tests/virtualdatum.cpp
@@ -32,52 +32,52 @@ TEST_CASE("VirtualDatum.operator=")
     auto datum = llama::allocVirtualDatumStack<Name>();
 
     // scalar to multiple elements in virtual datum
-    datum(tag::Pos{}) = 1;
-    CHECK(datum(tag::Pos{}, tag::A{}) == 1);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 0);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 0);
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 0);
-    CHECK(datum(tag::Weight{}) == 0);
+    datum(tag::Pos {}) = 1;
+    CHECK(datum(tag::Pos {}, tag::A {}) == 1);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 0);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 0);
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 0);
+    CHECK(datum(tag::Weight {}) == 0);
 
     // scalar to multiple elements in virtual datum
     datum = 2;
-    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 2);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 2);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 2);
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 2);
-    CHECK(datum(tag::Weight{}) == 2);
+    CHECK(datum(tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 2);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 2);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 2);
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 2);
+    CHECK(datum(tag::Weight {}) == 2);
 
     // smaller virtual datum to larger virtual datum
-    datum(tag::Pos{}) = 3;
-    datum(tag::Vel{}) = datum(tag::Pos{});
-    CHECK(datum(tag::Pos{}, tag::A{}) == 3);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 2);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 3); // only Y is propagated
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 2);
-    CHECK(datum(tag::Weight{}) == 2);
+    datum(tag::Pos {}) = 3;
+    datum(tag::Vel {}) = datum(tag::Pos {});
+    CHECK(datum(tag::Pos {}, tag::A {}) == 3);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 3);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 2);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 3); // only Y is propagated
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 2);
+    CHECK(datum(tag::Weight {}) == 2);
 
     // larger virtual datum to smaller virtual datum
-    datum(tag::Vel{}) = 4;
-    datum(tag::Pos{}) = datum(tag::Vel{});
-    CHECK(datum(tag::Pos{}, tag::A{}) == 3);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 4); // only Y is propagated
-    CHECK(datum(tag::Vel{}, tag::X{}) == 4);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 4);
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 4);
-    CHECK(datum(tag::Weight{}) == 2);
+    datum(tag::Vel {}) = 4;
+    datum(tag::Pos {}) = datum(tag::Vel {});
+    CHECK(datum(tag::Pos {}, tag::A {}) == 3);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 4); // only Y is propagated
+    CHECK(datum(tag::Vel {}, tag::X {}) == 4);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 4);
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 4);
+    CHECK(datum(tag::Weight {}) == 2);
 
     // scalar virtual datum to larger virtual datum, full broadcast
-    datum(tag::Weight{}) = 5;
-    datum(tag::Vel{}) = datum(tag::Weight{});
-    CHECK(datum(tag::Pos{}, tag::A{}) == 3);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 4);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 5); // updated
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 5); // updated
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 5); // updated
-    CHECK(datum(tag::Weight{}) == 5);
+    datum(tag::Weight {}) = 5;
+    datum(tag::Vel {}) = datum(tag::Weight {});
+    CHECK(datum(tag::Pos {}, tag::A {}) == 3);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 4);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 5); // updated
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 5); // updated
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 5); // updated
+    CHECK(datum(tag::Weight {}) == 5);
 }
 
 TEST_CASE("VirtualDatum.operator+=")
@@ -85,49 +85,49 @@ TEST_CASE("VirtualDatum.operator+=")
     auto datum = llama::allocVirtualDatumStack<Name>();
 
     // scalar to multiple elements in virtual datum
-    datum(tag::Pos{}) += 1;
-    CHECK(datum(tag::Pos{}, tag::A{}) == 1);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 0);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 0);
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 0);
-    CHECK(datum(tag::Weight{}) == 0);
+    datum(tag::Pos {}) += 1;
+    CHECK(datum(tag::Pos {}, tag::A {}) == 1);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 0);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 0);
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 0);
+    CHECK(datum(tag::Weight {}) == 0);
 
     // scalar to multiple elements in virtual datum
     datum += 1;
-    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 2);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
-    CHECK(datum(tag::Weight{}) == 1);
+    CHECK(datum(tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 2);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 1);
+    CHECK(datum(tag::Weight {}) == 1);
 
     // smaller virtual datum to larger virtual datum
-    datum(tag::Vel{}) += datum(tag::Pos{});
-    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 2);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 3); // only Y is propagated
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
-    CHECK(datum(tag::Weight{}) == 1);
+    datum(tag::Vel {}) += datum(tag::Pos {});
+    CHECK(datum(tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 2);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 3); // only Y is propagated
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 1);
+    CHECK(datum(tag::Weight {}) == 1);
 
     // larger virtual datum to smaller virtual datum
-    datum(tag::Pos{}) += datum(tag::Vel{});
-    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 5); // only Y is propagated
-    CHECK(datum(tag::Vel{}, tag::X{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 3);
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
-    CHECK(datum(tag::Weight{}) == 1);
+    datum(tag::Pos {}) += datum(tag::Vel {});
+    CHECK(datum(tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 5); // only Y is propagated
+    CHECK(datum(tag::Vel {}, tag::X {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 3);
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 1);
+    CHECK(datum(tag::Weight {}) == 1);
 
     // scalar virtual datum to larger virtual datum, full broadcast
-    datum(tag::Vel{}) += datum(tag::Weight{});
-    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 5);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 2); // updated
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 4); // updated
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 2); // updated
-    CHECK(datum(tag::Weight{}) == 1);
+    datum(tag::Vel {}) += datum(tag::Weight {});
+    CHECK(datum(tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 5);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 2); // updated
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 4); // updated
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 2); // updated
+    CHECK(datum(tag::Weight {}) == 1);
 }
 
 TEST_CASE("VirtualDatum.operator+")
@@ -135,49 +135,49 @@ TEST_CASE("VirtualDatum.operator+")
     auto datum = llama::allocVirtualDatumStack<Name>();
 
     // scalar to multiple elements in virtual datum
-    datum(tag::Pos{}) = datum(tag::Pos{}) + 1;
-    CHECK(datum(tag::Pos{}, tag::A{}) == 1);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 0);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 0);
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 0);
-    CHECK(datum(tag::Weight{}) == 0);
+    datum(tag::Pos {}) = datum(tag::Pos {}) + 1;
+    CHECK(datum(tag::Pos {}, tag::A {}) == 1);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 0);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 0);
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 0);
+    CHECK(datum(tag::Weight {}) == 0);
 
     // scalar to multiple elements in virtual datum
     datum = datum + 1;
-    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 2);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
-    CHECK(datum(tag::Weight{}) == 1);
+    CHECK(datum(tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 2);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 1);
+    CHECK(datum(tag::Weight {}) == 1);
 
     // smaller virtual datum to larger virtual datum
-    datum(tag::Vel{}) = datum(tag::Vel{}) + datum(tag::Pos{});
-    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 2);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 3); // only Y is propagated
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
-    CHECK(datum(tag::Weight{}) == 1);
+    datum(tag::Vel {}) = datum(tag::Vel {}) + datum(tag::Pos {});
+    CHECK(datum(tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 2);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 3); // only Y is propagated
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 1);
+    CHECK(datum(tag::Weight {}) == 1);
 
     // larger virtual datum to smaller virtual datum
-    datum(tag::Pos{}) = datum(tag::Pos{}) + datum(tag::Vel{});
-    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 5); // only Y is propagated
-    CHECK(datum(tag::Vel{}, tag::X{}) == 1);
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 3);
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
-    CHECK(datum(tag::Weight{}) == 1);
+    datum(tag::Pos {}) = datum(tag::Pos {}) + datum(tag::Vel {});
+    CHECK(datum(tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 5); // only Y is propagated
+    CHECK(datum(tag::Vel {}, tag::X {}) == 1);
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 3);
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 1);
+    CHECK(datum(tag::Weight {}) == 1);
 
     // scalar virtual datum to larger virtual datum, full broadcast
-    datum(tag::Vel{}) = datum(tag::Vel{}) + datum(tag::Weight{});
-    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Pos{}, tag::Y{}) == 5);
-    CHECK(datum(tag::Vel{}, tag::X{}) == 2); // updated
-    CHECK(datum(tag::Vel{}, tag::Y{}) == 4); // updated
-    CHECK(datum(tag::Vel{}, tag::Z{}) == 2); // updated
-    CHECK(datum(tag::Weight{}) == 1);
+    datum(tag::Vel {}) = datum(tag::Vel {}) + datum(tag::Weight {});
+    CHECK(datum(tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Pos {}, tag::Y {}) == 5);
+    CHECK(datum(tag::Vel {}, tag::X {}) == 2); // updated
+    CHECK(datum(tag::Vel {}, tag::Y {}) == 4); // updated
+    CHECK(datum(tag::Vel {}, tag::Z {}) == 2); // updated
+    CHECK(datum(tag::Weight {}) == 1);
 }
 
 // clang-format off
@@ -206,28 +206,28 @@ TEST_CASE("VirtualDatum.operator=.propagation")
 {
     auto datum = llama::allocVirtualDatumStack<Name2>();
 
-    datum(tag::Part1{}) = 1;
-    datum(tag::Part2{}) = 2;
-    CHECK(datum(tag::Part1{}, tag::Weight{}) == 1);
-    CHECK(datum(tag::Part1{}, tag::Pos{}, tag::X{}) == 1);
-    CHECK(datum(tag::Part1{}, tag::Pos{}, tag::Y{}) == 1);
-    CHECK(datum(tag::Part1{}, tag::Pos{}, tag::Z{}) == 1);
-    CHECK(datum(tag::Part2{}, tag::Weight{}) == 2);
-    CHECK(datum(tag::Part2{}, tag::Pos{}, tag::X{}) == 2);
-    CHECK(datum(tag::Part2{}, tag::Pos{}, tag::Y{}) == 2);
-    CHECK(datum(tag::Part2{}, tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Part2{}, tag::Z{}) == 2);
-
-    datum(tag::Part2{}) = datum(tag::Part1{});
-    CHECK(datum(tag::Part1{}, tag::Weight{}) == 1);
-    CHECK(datum(tag::Part1{}, tag::Pos{}, tag::X{}) == 1);
-    CHECK(datum(tag::Part1{}, tag::Pos{}, tag::Y{}) == 1);
-    CHECK(datum(tag::Part1{}, tag::Pos{}, tag::Z{}) == 1);
-    CHECK(datum(tag::Part2{}, tag::Weight{}) == 1); // propagated
-    CHECK(datum(tag::Part2{}, tag::Pos{}, tag::X{}) == 1); // propagated
-    CHECK(datum(tag::Part2{}, tag::Pos{}, tag::Y{}) == 1); // propagated
-    CHECK(datum(tag::Part2{}, tag::Pos{}, tag::A{}) == 2);
-    CHECK(datum(tag::Part2{}, tag::Z{}) == 2);
+    datum(tag::Part1 {}) = 1;
+    datum(tag::Part2 {}) = 2;
+    CHECK(datum(tag::Part1 {}, tag::Weight {}) == 1);
+    CHECK(datum(tag::Part1 {}, tag::Pos {}, tag::X {}) == 1);
+    CHECK(datum(tag::Part1 {}, tag::Pos {}, tag::Y {}) == 1);
+    CHECK(datum(tag::Part1 {}, tag::Pos {}, tag::Z {}) == 1);
+    CHECK(datum(tag::Part2 {}, tag::Weight {}) == 2);
+    CHECK(datum(tag::Part2 {}, tag::Pos {}, tag::X {}) == 2);
+    CHECK(datum(tag::Part2 {}, tag::Pos {}, tag::Y {}) == 2);
+    CHECK(datum(tag::Part2 {}, tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Part2 {}, tag::Z {}) == 2);
+
+    datum(tag::Part2 {}) = datum(tag::Part1 {});
+    CHECK(datum(tag::Part1 {}, tag::Weight {}) == 1);
+    CHECK(datum(tag::Part1 {}, tag::Pos {}, tag::X {}) == 1);
+    CHECK(datum(tag::Part1 {}, tag::Pos {}, tag::Y {}) == 1);
+    CHECK(datum(tag::Part1 {}, tag::Pos {}, tag::Z {}) == 1);
+    CHECK(datum(tag::Part2 {}, tag::Weight {}) == 1); // propagated
+    CHECK(datum(tag::Part2 {}, tag::Pos {}, tag::X {}) == 1); // propagated
+    CHECK(datum(tag::Part2 {}, tag::Pos {}, tag::Y {}) == 1); // propagated
+    CHECK(datum(tag::Part2 {}, tag::Pos {}, tag::A {}) == 2);
+    CHECK(datum(tag::Part2 {}, tag::Z {}) == 2);
 }
 
 TEST_CASE("VirtualDatum.operator=.multiview")
@@ -237,20 +237,20 @@ TEST_CASE("VirtualDatum.operator=.multiview")
 
     datum2 = 1;
     datum1 = datum2;
-    CHECK(datum1(tag::Pos{}, tag::A{}) == 0);
-    CHECK(datum1(tag::Pos{}, tag::Y{}) == 0);
-    CHECK(datum1(tag::Vel{}, tag::X{}) == 0);
-    CHECK(datum1(tag::Vel{}, tag::Y{}) == 0);
-    CHECK(datum1(tag::Vel{}, tag::Z{}) == 0);
-    CHECK(datum1(tag::Weight{}) == 0);
-
-    datum1 = datum2(tag::Part1{});
-    CHECK(datum1(tag::Pos{}, tag::A{}) == 0);
-    CHECK(datum1(tag::Pos{}, tag::Y{}) == 1);
-    CHECK(datum1(tag::Vel{}, tag::X{}) == 0);
-    CHECK(datum1(tag::Vel{}, tag::Y{}) == 0);
-    CHECK(datum1(tag::Vel{}, tag::Z{}) == 0);
-    CHECK(datum1(tag::Weight{}) == 1);
+    CHECK(datum1(tag::Pos {}, tag::A {}) == 0);
+    CHECK(datum1(tag::Pos {}, tag::Y {}) == 0);
+    CHECK(datum1(tag::Vel {}, tag::X {}) == 0);
+    CHECK(datum1(tag::Vel {}, tag::Y {}) == 0);
+    CHECK(datum1(tag::Vel {}, tag::Z {}) == 0);
+    CHECK(datum1(tag::Weight {}) == 0);
+
+    datum1 = datum2(tag::Part1 {});
+    CHECK(datum1(tag::Pos {}, tag::A {}) == 0);
+    CHECK(datum1(tag::Pos {}, tag::Y {}) == 1);
+    CHECK(datum1(tag::Vel {}, tag::X {}) == 0);
+    CHECK(datum1(tag::Vel {}, tag::Y {}) == 0);
+    CHECK(datum1(tag::Vel {}, tag::Z {}) == 0);
+    CHECK(datum1(tag::Weight {}) == 1);
 }
 
 TEST_CASE("VirtualDatum.operator==")
@@ -259,22 +259,22 @@ TEST_CASE("VirtualDatum.operator==")
 
     datum = 1;
 
-    CHECK((datum(tag::Pos{}, tag::Y{}) == datum(tag::Pos{}, tag::Y{})));
-    CHECK((datum(tag::Pos{}) == datum(tag::Pos{})));
+    CHECK((datum(tag::Pos {}, tag::Y {}) == datum(tag::Pos {}, tag::Y {})));
+    CHECK((datum(tag::Pos {}) == datum(tag::Pos {})));
     CHECK((datum == datum));
-    CHECK((datum(tag::Pos{}) == datum(tag::Vel{})));
+    CHECK((datum(tag::Pos {}) == datum(tag::Vel {})));
 
     // scalar to multiple elements in virtual datum
-    CHECK((datum(tag::Pos{}, tag::Y{}) == 1));
-    CHECK((datum(tag::Pos{}) == 1));
+    CHECK((datum(tag::Pos {}, tag::Y {}) == 1));
+    CHECK((datum(tag::Pos {}) == 1));
     CHECK((datum == 1));
 
-    datum(tag::Pos{}, tag::Y{}) = 2;
+    datum(tag::Pos {}, tag::Y {}) = 2;
 
-    CHECK((datum(tag::Pos{}, tag::Y{}) == 2));
-    CHECK(!(datum(tag::Pos{}) == 1));
+    CHECK((datum(tag::Pos {}, tag::Y {}) == 2));
+    CHECK(!(datum(tag::Pos {}) == 1));
     CHECK(!(datum == 1));
-    CHECK(!(datum(tag::Pos{}) == datum(tag::Vel{})));
+    CHECK(!(datum(tag::Pos {}) == datum(tag::Vel {})));
 }
 
 TEST_CASE("VirtualDatum.operator<")
@@ -283,23 +283,23 @@ TEST_CASE("VirtualDatum.operator<")
 
     datum = 1;
 
-    CHECK(!(datum(tag::Pos{}, tag::Y{}) < datum(tag::Pos{}, tag::Y{})));
-    CHECK(!(datum(tag::Pos{}) < datum(tag::Pos{})));
+    CHECK(!(datum(tag::Pos {}, tag::Y {}) < datum(tag::Pos {}, tag::Y {})));
+    CHECK(!(datum(tag::Pos {}) < datum(tag::Pos {})));
     CHECK(!(datum < datum));
-    CHECK(!(datum(tag::Pos{}) < datum(tag::Vel{})));
+    CHECK(!(datum(tag::Pos {}) < datum(tag::Vel {})));
 
     // scalar to multiple elements in virtual datum
-    CHECK((datum(tag::Pos{}, tag::Y{}) < 2));
-    CHECK((datum(tag::Pos{}) < 2));
+    CHECK((datum(tag::Pos {}, tag::Y {}) < 2));
+    CHECK((datum(tag::Pos {}) < 2));
     CHECK((datum < 2));
-    CHECK(!(datum(tag::Pos{}, tag::Y{}) < 1));
-    CHECK(!(datum(tag::Pos{}) < 1));
+    CHECK(!(datum(tag::Pos {}, tag::Y {}) < 1));
+    CHECK(!(datum(tag::Pos {}) < 1));
     CHECK(!(datum < 1));
 
-    datum(tag::Pos{}, tag::Y{}) = 2;
+    datum(tag::Pos {}, tag::Y {}) = 2;
 
-    CHECK((datum(tag::Pos{}, tag::Y{}) < 3));
-    CHECK(!(datum(tag::Pos{}) < 2));
+    CHECK((datum(tag::Pos {}, tag::Y {}) < 3));
+    CHECK(!(datum(tag::Pos {}) < 2));
     CHECK(!(datum < 2));
-    CHECK(!(datum(tag::Pos{}) < datum(tag::Vel{})));
+    CHECK(!(datum(tag::Pos {}) < datum(tag::Vel {})));
 }
diff --git a/tests/virtualview.cpp b/tests/virtualview.cpp
index a3e7220a77..e3e3212490 100644
--- a/tests/virtualview.cpp
+++ b/tests/virtualview.cpp
@@ -29,10 +29,10 @@ using Particle = llama::DS<
 >;
 // clang-format on
 
-template<typename VirtualDatum>
+template <typename VirtualDatum>
 struct SqrtFunctor
 {
-    template<typename Coord>
+    template <typename Coord>
     void operator()(Coord coord)
     {
         vd(coord) *= std::sqrt(vd(coord));
@@ -43,83 +43,78 @@ struct SqrtFunctor
 TEST_CASE("fast virtual view")
 {
     using UserDomain = llama::UserDomain<2>;
-    constexpr UserDomain viewSize{4096, 4096};
+    constexpr UserDomain viewSize {4096, 4096};
 
     using Mapping = llama::mapping::SoA<UserDomain, Particle>;
     auto view = allocView(Mapping(viewSize));
 
-    for(std::size_t x = 0; x < viewSize[0]; ++x)
-        for(std::size_t y = 0; y < viewSize[1]; ++y) view(x, y) = x * y;
+    for (std::size_t x = 0; x < viewSize[0]; ++x)
+        for (std::size_t y = 0; y < viewSize[1]; ++y)
+            view(x, y) = x * y;
 
-    llama::VirtualView<decltype(view)> virtualView{
+    llama::VirtualView<decltype(view)> virtualView {
         view,
         {23, 42}, // offset
         {13, 37} // size
     };
 
-    CHECK(virtualView.offset == UserDomain{23, 42});
-    CHECK(virtualView.size == UserDomain{13, 37});
+    CHECK(virtualView.offset == UserDomain {23, 42});
+    CHECK(virtualView.size == UserDomain {13, 37});
 
     CHECK(view(virtualView.offset)(tag::Pos(), tag::X()) == 966);
     CHECK(virtualView({0, 0})(tag::Pos(), tag::X()) == 966);
 
-    CHECK(
-        view({virtualView.offset[0] + 2, virtualView.offset[1] + 3})(
-            tag::Vel(), tag::Z())
-        == 1125);
+    CHECK(view({virtualView.offset[0] + 2, virtualView.offset[1] + 3})(tag::Vel(), tag::Z()) == 1125);
     CHECK(virtualView({2, 3})(tag::Vel(), tag::Z()) == 1125);
 }
 
 TEST_CASE("virtual view")
 {
     using UserDomain = llama::UserDomain<2>;
-    constexpr UserDomain viewSize{256, 256};
-    constexpr UserDomain miniSize{8, 8};
+    constexpr UserDomain viewSize {256, 256};
+    constexpr UserDomain miniSize {8, 8};
     using Mapping = llama::mapping::SoA<UserDomain, Particle>;
     auto view = allocView(Mapping(viewSize));
 
-    for(std::size_t x = 0; x < viewSize[0]; ++x)
-        for(std::size_t y = 0; y < viewSize[1]; ++y) view(x, y) = x * y;
+    for (std::size_t x = 0; x < viewSize[0]; ++x)
+        for (std::size_t y = 0; y < viewSize[1]; ++y)
+            view(x, y) = x * y;
 
-    constexpr UserDomain iterations{
+    constexpr UserDomain iterations {
         (viewSize[0] + miniSize[0] - 1) / miniSize[0],
         (viewSize[1] + miniSize[1] - 1) / miniSize[1]};
 
-    for(std::size_t x = 0; x < iterations[0]; ++x)
-        for(std::size_t y = 0; y < iterations[1]; ++y)
+    for (std::size_t x = 0; x < iterations[0]; ++x)
+        for (std::size_t y = 0; y < iterations[1]; ++y)
         {
-            const UserDomain validMiniSize{
-                (x < iterations[0] - 1) ? miniSize[0]
-                                        : (viewSize[0] - 1) % miniSize[0] + 1,
-                (y < iterations[1] - 1) ? miniSize[1]
-                                        : (viewSize[1] - 1) % miniSize[1] + 1};
+            const UserDomain validMiniSize {
+                (x < iterations[0] - 1) ? miniSize[0] : (viewSize[0] - 1) % miniSize[0] + 1,
+                (y < iterations[1] - 1) ? miniSize[1] : (viewSize[1] - 1) % miniSize[1] + 1};
 
-            llama::VirtualView<decltype(view)> virtualView(
-                view, {x * miniSize[0], y * miniSize[1]}, miniSize);
+            llama::VirtualView<decltype(view)> virtualView(view, {x * miniSize[0], y * miniSize[1]}, miniSize);
 
             using MiniMapping = llama::mapping::SoA<UserDomain, Particle>;
             auto miniView = allocView(
                 MiniMapping(miniSize),
-                llama::allocator::Stack<
-                    miniSize[0] * miniSize[1] * llama::sizeOf<Particle>>{});
+                llama::allocator::Stack<miniSize[0] * miniSize[1] * llama::sizeOf<Particle>> {});
 
-            for(std::size_t a = 0; a < validMiniSize[0]; ++a)
-                for(std::size_t b = 0; b < validMiniSize[1]; ++b)
+            for (std::size_t a = 0; a < validMiniSize[0]; ++a)
+                for (std::size_t b = 0; b < validMiniSize[1]; ++b)
                     miniView(a, b) = virtualView(a, b);
 
-            for(std::size_t a = 0; a < validMiniSize[0]; ++a)
-                for(std::size_t b = 0; b < validMiniSize[1]; ++b)
+            for (std::size_t a = 0; a < validMiniSize[0]; ++a)
+                for (std::size_t b = 0; b < validMiniSize[1]; ++b)
                 {
-                    SqrtFunctor<decltype(miniView(a, b))> sqrtF{miniView(a, b)};
+                    SqrtFunctor<decltype(miniView(a, b))> sqrtF {miniView(a, b)};
                     llama::forEach<Particle>(sqrtF);
                 }
 
-            for(std::size_t a = 0; a < validMiniSize[0]; ++a)
-                for(std::size_t b = 0; b < validMiniSize[1]; ++b)
+            for (std::size_t a = 0; a < validMiniSize[0]; ++a)
+                for (std::size_t b = 0; b < validMiniSize[1]; ++b)
                     virtualView(a, b) = miniView(a, b);
         }
 
-    for(std::size_t x = 0; x < viewSize[0]; ++x)
-        for(std::size_t y = 0; y < viewSize[1]; ++y)
+    for (std::size_t x = 0; x < viewSize[0]; ++x)
+        for (std::size_t y = 0; y < viewSize[1]; ++y)
             CHECK((view(x, y) == x * y * std::sqrt(x * y)));
 }