Pith. sign in

REVIEW 2 major objections 6 minor 2 cited by

The Distributed and Unified Numerics Environment (DUNE), Version 2.10

T0 review · 2 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This release paper claims that DUNE 2.10 makes curved geometries, C++20 concepts, and faster sparse matrix assembly native to its core modules.

desk verdict Useful incremental release documentation, but the Table 1 speedup claim lacks a reproducible benchmark protocol. read the letter →

arxiv 2506.23558 v1 pith:YPQMDESO submitted 2025-06-30 cs.MS

Markus Blatt , Samuel Burbulla , Ansgar Burchardt , Andreas Dedner , Christian Engwer , Carsten Gräser , Christoph Grüninger , Robert Klöfkorn
show 4 more authors
Timo Koch Santiago Ospina De Los Ríos Simon Praetorius Oliver Sander
This is my paper · ORCID
classification cs.MS MSC 65M6065Y15
keywords DUNEfiniteelementsvolumescurvedgeometriesC++20conceptssparsematrixassemblyRaviart–ThomasCMakebuildsystem
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper is the release description for DUNE version 2.10, an open-source framework of C++ modules for grid-based PDE simulation. It claims the release makes curved geometries a core capability through two new geometry classes, brings C++20 concepts to the grid interface, adds standard-style multidimensional arrays, accelerates sparse matrix pattern setup, and adds finite elements for mixed and Stokes problems on hybrid grids. A sympathetic reader would take the paper as establishing that these features work as advertised and that users can rely on them for finite element and finite volume simulations.

What carries the argument

The load-bearing pieces are the new geometry classes and the sorted-pattern sparse-matrix strategy. Dune::MappedGeometry wraps a reference geometry plus a differentiable coordinate map whose derivative is supplied by a friend derivative() function, so integrationElement and Jacobian come from the map; Dune::LocalFiniteElementGeometry does the same by interpolating the map into a local finite element basis, enabling discrete geometries that can move. On the linear algebra side, MatrixIndexSet stores each row's column indices in a sorted vector, a flat-set analogue below a size threshold, and BCRSMatrix::setIndicesNoSort uses this pre-sorted order to skip a redundant sorting pass, while the new jacobian() and jacobianInverse() methods rely on transposedView() and leftInvA()/rightInvA() utilities to serve both covariant and contravariant Piola transforms.

What would settle it

Run the benchmark in Appendix A.11 repeatedly on identical hardware with the same compiler and flags, comparing releases/2.10 against the dune-istl branch 'undo/changes-to-matrixindexset'; if the median pattern-setup time of the new code is not below the old code's, the paper's central performance claim fails. Separately, a unit test can check that a Dune::MappedGeometry of a sine surface produces the analytic derivative of sin(xy) at sampled points.

Watch

Extended reading notes

Core claim

The central claim is that version 2.10 of DUNE provides a coherent set of engineering advances that extend what a grid-based PDE code can express without breaking the C++17 baseline. Specifically, Dune::MappedGeometry and Dune::LocalFiniteElementGeometry give users curved domain parametrizations defined either by a differentiable map or by interpolation into a local finite element space; the grid interface is augmented with non-transposed jacobian() and jacobianInverse() methods using left and right pseudo-inverses; Dune::Std::mdspan and mdarray supply standard-like multidimensional arrays; MatrixIndexSet now stores rows in a sorted-vector flat set and BCRSMatrix::setIndicesNoSort exploits the pre-sorted rows, which the paper reports as a significant setup-time improvement; and dune-localfunctions adds lowest-order Raviart–Thomas elements on prisms and pyramids plus hierarchical P1/P2-with-bubble elements. If true, DUNE users gain H(div)-conforming discretizations on hybrid meshes, stable Stokes pairs like MINI and Crouzeix–Raviart, and a clearer path to high-order methods on curved boundaries.

Load-bearing premise

The reported speedup from the MatrixIndexSet and BCRSMatrix changes assumes the single benchmark in Table 1 was run under representative, fully specified conditions, since the paper gives neither hardware, compiler, optimization flags, nor repetitions for the old-versus-new comparison.

Editorial extensions

If this is right

  • Curved-domain simulations — higher-order surface finite elements, curved boundary conditions, moving meshes — can now be built directly on dune-geometry without external geometry modules.
  • Lowest-order Raviart–Thomas elements on prisms and pyramids make H(div)-conforming mixed discretizations possible on hybrid grids that mix hexahedra, prisms, and pyramids.
  • The hierarchical P1-bubble and P2-bubble elements give DUNE users ready building blocks for the MINI and Crouzeix–Raviart stable Stokes pairs in arbitrary dimension.
  • The flat-set MatrixIndexSet and setIndicesNoSort path shortens one dominant serial stage of matrix assembly; per Table 1 the pattern-setup step drops from 2.7249 seconds to 0.6946 seconds in the Stokes benchmark.
  • Dune::Std::mdspan and mdarray give C++17 code a standard-style multidimensional array core that future DUNE data structures can build on.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The curved-geometry and Jacobian additions probably matter most for Piola-transform-based elements: with non-transposed Jacobians available, covariant and contravariant transforms for Nédélec and Raviart–Thomas spaces become more direct, a direction the paper only touches on.
  • The sparse-matrix speedup should transfer to other assembly patterns beyond Stokes, but it is conditional on the threshold at which the flat-set storage spills into a real set; the paper does not expose that threshold, so benchmarking small versus large row densities would be a natural extension.
  • The grid concepts are positioned to become the formal interface contract for future grids, since component-wise concept checks let independent implementations be validated without wrapping the entire grid interface, so third-party grid developers are the immediate beneficiaries.
  • The RT0 pyramid element built on an exact-sequence construction suggests the next step is a full de Rham sequence on pyramids, which would give DUNE the conforming H(curl) partners needed for electromagnetics on hybrid meshes.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 6 minor

Summary. Version 2.10 of DUNE is described in this release note, covering C++20 concepts support in dune-common and dune-grid, new curved-geometry classes (Dune::MappedGeometry, Dune::LocalFiniteElementGeometry), non-transposed Jacobian access, Dune::Std::mdspan and mdarray implementations, indexed ranges and sparse-matrix improvements, a target-based CMake build-system modernization, new local finite elements (RT0 on prisms and pyramids, hierarchical P1+P2 bubble elements), and updates in several extension modules. The paper provides runnable code examples in Appendix A and points to the public GitLab repositories for all modules.

Significance. If substantiated, the paper is a useful and verifiable record of an incremental release of a widely used open-source numerical framework. Its main strengths are the concrete code listings, the availability of the full examples in the appendix, and the references to the mathematical constructions for the new finite elements. Most feature claims can be checked directly against the released repositories, and this verifiability is a real asset. The one quantitative claim, the sparse-matrix speedup reported in Section 2.4.3, is not adequately supported as published; this is a local but load-bearing weakness in an otherwise sound release note.

major comments (2)
  1. [Section 2.4.3, Table 1, Appendix A.11] The claim that the MatrixIndexSet and BCRSMatrix changes give a "significant improvement in setup time" is supported by a single timing comparison with no hardware description, compiler version, optimization flags, number of runs, or measured variance. The benchmark comment in Appendix A.11 refers to the branch "undo/changes-to-matrixindexset" in dune-istl, but no commit hash or build configuration is given, and that branch is not a released configuration. As a result, the roughly 4x difference in setupMatrix (2.7249 s versus 0.6946 s) cannot be distinguished from run-to-run noise or from differences in default build settings between the two branches. Please report the environment, the median and spread over multiple repetitions, and either a reproducible script or a clearly qualified statement of the observed speedup on the authors' machine. Without this, the quantitative performance headline is not established.
  2. [Section 2.6] The new local finite elements (RT0 on prisms and pyramids, hierarchical bubble elements) are presented through code listings and literature references, but the paper does not mention any patch tests, convergence checks, or pointers to the repository's test suite. Since these elements are offered as usable numerical components, one short paragraph describing the existing tests, or a minimal verification result, would make the "usable" claim substantially more robust. This is less urgent than the benchmark issue but should be addressed in the revision.
minor comments (6)
  1. [Section 3.2] The text refers to "Dune::LocalFunctionGeometry", but the type introduced in Section 2.3.1 is Dune::LocalFiniteElementGeometry; please align the names.
  2. [Section 4.2] The sentence "The class template Dune::SizeOf was provide" should read "was provided".
  3. [Section 2.1.1] The preprocessor constant appears as "DUNE ENABLE CONCEPTS" in the prose; it should be typeset as DUNE_ENABLE_CONCEPTS for consistency with the code.
  4. [Section 2.6 and Appendix A.12] The main-text RT0 example uses face-orientation value 0b00001 while Appendix A.12 uses bitset("00110"); these are presumably independent examples, but using the same value or adding an explicit note would avoid reader confusion about the orientation convention.
  5. [Table 1] The table would be easier to interpret if the caption stated the grid size and the number of degrees of freedom; the benchmark code uses a 4x4 YaspGrid refined seven times, but the table does not mention this.
  6. [Section 1.1] The text says the full code examples are available in a "supplementary document of the paper", but they appear in Appendix A of the paper itself; please rephrase for accuracy.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: DUNE 2.10 release claims are feature descriptions and benchmark measurements, not derived predictions.

full rationale

This is a software release paper. The central claims are existence and availability of features—C++20 concepts, MappedGeometry and LocalFiniteElementGeometry, mdspan/mdarray implementations, CMake restructuring, and new local finite elements—supported by code listings and public repositories. There is no equation-to-equation derivation chain in which an output quantity is defined as an input quantity. The only quantitative claim, Table 1 in Section 2.4.3, is a benchmark comparing the new MatrixIndexSet/BCRSMatrix code against the older branch 'undo/changes-to-matrixindexset'. A benchmark is an empirical measurement, not a fitted-input prediction; the comparison being against an earlier version of the same project is self-referential but not circular—it does not make the measured speedup true by construction. The self-citations to earlier DUNE papers ([1]–[4], [12], [24]) provide context and provenance; they are not used to establish any of the 2.10 features or benchmark numbers. The RT0 pyramid/prism elements cite Ainsworth and Fu [29], an external mathematical construction. The principal weakness—absence of hardware, compiler, and repetition details for Table 1—is an evidence-quality or reproducibility concern, not circularity. No load-bearing step reduces to its own input, so the circularity score is 0.

Assumptions & free parameters 0 free parameters · 2 assumptions · 0 invented entities

No free parameters are fitted to data. The paper is a software release description, not a theoretical derivation, so no invented scientific entities are proposed. The load-bearing assumptions are about the correctness of the new finite element implementations and the representativeness of the benchmark.

assumptions (2)
  • domain assumption The new local finite elements (RT0 on pyramids and prisms, hierarchical bubble elements) correctly implement the published constructions cited in the paper.
    Section 2.6 introduces these elements and cites [29] and [30], but no numerical verification or test results are shown.
  • domain assumption The benchmark in Table 1 compares the old and new versions of MatrixIndexSet and BCRSMatrix under identical, representative conditions.
    Appendix A.11 provides the benchmark code but the paper omits hardware, compiler, optimization level, and number of repetitions; the 'old' code is only available on an unmerged branch.

how reviews work

0 comments
Cite this review

Pith. "Pith review of The Distributed and Unified Numerics Environment (DUNE), Version 2.10." pith.science (2026). https://pith.science/paper/YPQMDESO

@misc{pith2026250623558,
  author       = {Pith},
  title        = {Pith review of: The Distributed and Unified Numerics Environment (DUNE), Version 2.10},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YPQMDESO}},
  note         = {Machine review of arXiv:2506.23558}
}
read the original abstract

Version 2.10 of the Distributed and Unified Numerics Environment DUNE introduces a range of enhancements across its core and extension modules, with a continued emphasis on modern C++ integration and improved usability. This release extends support for C++20 features, particularly concepts, through comprehensive refinements in dune-common and dune-grid, enabling safer and more expressive generic programming paradigms. A notable advancement is the improved support for curved geometries, including new geometry implementations and a more flexible interface. Data structures have been modernized through native support for std::mdspan and std::mdarray, performance improvements in sparse matrices, and tools for visualization of matrix patterns. The build system has been restructured towards a modern CMake workflow, emphasizing target-based configuration and improved automation. Furthermore, new local finite elements have been introduced to broaden numerical capabilities. The release also brings updates across DUNE extensions, as well as improvements to infrastructure and module-level components.

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Concepts for Composing Finite Element Function Space Bases

    cs.MS 2025-08 conditional novelty 4.0 of 10

    Representing composed finite element bases as trees, with multi-index trees and merging strategies, yields flexible dof numberings, implemented in dune-functions.

  2. Voltage Support Procurement in Transmission Grids: Incentive Design via Online Bilevel Games

    math.OC 2025-08 unverdicted novelty 4.0 of 10

    The abstract claims an online Stackelberg incentive design for TSO-DSO voltage support, but the body text is an unrelated manuscript, leaving the central claim unverifiable.

Reference graph

Works this paper leans on

43 extracted references · 29 canonical work pages · cited by 2 Pith papers

  1. [1]

    part I: abstract framework

    Bastian, P., Blatt, M., Dedner, A., Engwer, C., Kl¨ ofkorn, R., Ohlberger, M., Sander, O.: A generic grid interface for parallel and adaptive scientific computing. part I: abstract framework. Computing 82(2–3), 103–119 (2008) https://doi.org/ 10.1007/s00607-008-0003-x

    doi:10.1007/s00607-008-0003-x 2008

  2. [2]

    Kornhuber, Ohlberger, M., Sander, O.: A generic grid interface for parallel and adaptive scientific computing

    Bastian, P., Blatt, M., Dedner, A., Engwer, C., Kl¨ ofkorn, R., , R. Kornhuber, Ohlberger, M., Sander, O.: A generic grid interface for parallel and adaptive scientific computing. part II: Implementation and tests in DUNE. Computing 82, 121–138 (2008) https://doi.org/10.1007/s00607-008-0004-9

    doi:10.1007/s00607-008-0004-9 2008

  3. [3]

    Technical report, Interdisciplinary Centre for Scientific Computing (IWR), University Heidelberg, Im Neuenheimer Feld 368, 69120 Heidelberg, Germany (2007)

    Blatt, M., Bastian, P.: The iterative solver template library. Technical report, Interdisciplinary Centre for Scientific Computing (IWR), University Heidelberg, Im Neuenheimer Feld 368, 69120 Heidelberg, Germany (2007)

    2007

  4. [4]

    International Journal of Computational Science and Engineering 4(1), 56–69 (2008) https://doi.org/10.1504/IJCSE.2008.021112

    Blatt, M., Bastian, P.: On the generic parallelisation of iterative solvers for the finite element method. International Journal of Computational Science and Engineering 4(1), 56–69 (2008) https://doi.org/10.1504/IJCSE.2008.021112

    arXiv 2008

  5. [5]

    https://gitlab.com/amdis/amdis

    Praetorius, S.: The Adaptive Multi-Dimensional Simulation Toolbox (AMDiS), Version 2.10. https://gitlab.com/amdis/amdis. Version: 2.10 (2025)

    work page 2025

  6. [6]

    Computers & Mathematics with Applications 81, 423–443 (2021) https: //doi.org/10.1016/j.camwa.2020.02.012

    Koch, T., Gl¨ aser, D., Weishaupt, K.,et al.: DuMux 3 – an open-source simulator for solving flow and transport problems in porous media with a focus on model 21 coupling. Computers & Mathematics with Applications 81, 423–443 (2021) https: //doi.org/10.1016/j.camwa.2020.02.012

    doi:10.1016/j.camwa.2020.02.012 2021

  7. [7]

    Computing 90(3–4), 165–196 (2010) https://doi.org/10.1007/ s00607-010-0110-3

    Dedner, A., Kl¨ ofkorn, R., Nolte, M., Ohlberger, M.: A generic interface for parallel and adaptive discretization schemes: abstraction principles and the Dune-Fem module. Computing 90(3–4), 165–196 (2010) https://doi.org/10.1007/ s00607-010-0110-3

    work page 2010

  8. [8]

    https://gitlab.dune-project.org/fufem/ dune-fufem (2025)

    The Dune-Fufem Team: Dune-Fufem. https://gitlab.dune-project.org/fufem/ dune-fufem (2025)

    work page 2025

Show all 43 references
  1. [9]

    Kybernetika 46(2), 294–315 (2010)

    Bastian, P., Heimann, F., Marnach, S.: Generic implementation of finite ele- ment methods in the Distributed and Unified Numerics Environment (DUNE). Kybernetika 46(2), 294–315 (2010)

    2010

  2. [10]

    Computers & Mathematics with Applications 81, 444–458 (2021) https: //doi.org/10.1016/j.camwa.2020.02.011

    G¨ otschel, S., Schiela, A., Weiser, M.: Kaskade 7 — A flexible finite element toolbox. Computers & Mathematics with Applications 81, 444–458 (2021) https: //doi.org/10.1016/j.camwa.2020.02.011

    2021 doi

  3. [11]

    Computers & Mathematics with Applications 81, 159–185 (2021) https://doi.org/10.1016/j.camwa.2020.05.014

    Rasmussen, A.F., Sandve, T.H., Bao, K., Lauser, A., Hove, J., Skaflestad, B., Kl¨ ofkorn, R., Blatt, M., Rustad, A.B., Sævareid, O., Lie, K.-A., Thune, A.: The open porous media flow reservoir simulator. Computers & Mathematics with Applications 81, 159–185 (2021) https://doi....

    2021 doi

  4. [12]

    Computers and Mathematics with Applications 81, 75–112 (2021) https://doi.org/10.1016/j.camwa.2020.06.007

    Bastian, P., Blatt, M., Dedner, A., Dreier, N.-A., Engwer, C., Fritze, R., Gr¨ aser, C., Gr¨ uninger, C., Kempf, D., Kl¨ ofkorn, R., Ohlberger, M., Sander, O.: TheDune framework: Basic concepts and recent developments. Computers and Mathematics with Applications 81, 75–112 (20...

    2021 doi

  5. [13]

    arXiv: 1612.02967 (2016)

    Fomins, A., Oswald, B.: Dune-CurvilinearGrid: Parallel Dune Grid Manager for Unstructured Tetrahedral Curvilinear Meshes. arXiv: 1612.02967 (2016)

    2016 arXiv

  6. [14]

    https://github.com/LSPR-AG/dune-curvilineargeometry (2016)

    LSPR-AG: Dune-CurvilinearGeometry: Curvilinear Geometry Implementation for Dune. https://github.com/LSPR-AG/dune-curvilineargeometry (2016)

    2016

  7. [15]

    Archive of Numerical Software 6(1), 1–27 (2022) https://doi.org/ 10.11588/ans.2022.1.75917

    Praetorius, S., Stenger, F.: Dune-CurvedGrid – A Dune module for surface parametrization. Archive of Numerical Software 6(1), 1–27 (2022) https://doi.org/ 10.11588/ans.2022.1.75917

    2022 doi

  8. [16]

    https://gitlab.dune-project.org/extensions/dune-curvedgeometry (2020)

    Praetorius, S.: Dune-CurvedGeometry: Parametrizations of curved geometries. https://gitlab.dune-project.org/extensions/dune-curvedgeometry (2020)

    2020

  9. [17]

    Archive of Numerical Software 5(1), 95–110 (2017) https://doi.org/10.11588/ans.2017.1.27683

    Engwer, C., Gr¨ aser, C., M¨ uthing, S., Sander, O.: The interface for functions in the dune-functions module. Archive of Numerical Software 5(1), 95–110 (2017) https://doi.org/10.11588/ans.2017.1.27683

    2017 doi

  10. [18]

    C++ Standard Document D0009R17 (June 2022)

    Trott, C., Hollman, D.S., Lebrun-Grandie, D., Hoemmen, M., Sunderland, D., 22 Edwards, H.C., Lelbach, B.A., Bianco, M., Sander, B., Iliopoulos, A., Michopoulos, J., Liber, N.: Mdspan. C++ Standard Document D0009R17 (June 2022)

    2022

  11. [19]

    C++ Standard Proposal P1684R5 (May 2023)

    Trott, C., Hollman, D., Hoemmen, M., Sunderland, D., Lebrun-Grandie, D.: mdarray: An owning multidimensional array analog of mdspan. C++ Standard Proposal P1684R5 (May 2023)

    2023

  12. [20]

    https://github.com/ kokkos/mdspan

    Reference implementation of mdspan targeting C++23. https://github.com/ kokkos/mdspan. Accessed: 2024-08-09

    2024

  13. [21]

    C++ Standard Proposal P0843R14 (June 2024)

    Gadeschi, G.B., Doumler, T., Liber, N., Sankel, D.: inplace vector: A dynamically-resizable vector with fixed capacity and embedded storage. C++ Standard Proposal P0843R14 (June 2024)

    2024

  14. [22]

    C++ Standard Proposal P2727R4 (June 2024)

    Laine, Z.: std::iterator interface. C++ Standard Proposal P2727R4 (June 2024)

    2024

  15. [23]

    C++ Standard Document P1222R4 (June 2022)

    Laine, Z.: A standard std::flat set. C++ Standard Document P1222R4 (June 2022)

    2022

  16. [24]

    Archive of Numerical Software 4(100), 13–29 (2016) https://doi.org/10.11588/ans.2016.100.26526

    Blatt, M., Burchardt, A., Dedner, A., Engwer, C., Fahlke, J., Flemisch, B., Gersbacher, C., Gr¨ aser, C., Gruber, F., Gr¨ uninger, C., Kempf, D., Kl¨ ofkorn, R., Malkmus, T., M¨ uthing, S., Nolte, M., Piatkowski, M., Sander, O.: The distributed and unified numerics environment...

    2016 doi

  17. [25]

    https://conan.io

    Software package manager for C and C++ developers. https://conan.io. Accessed: 2024-09-02

    2024

  18. [26]

    https://vcpkg.io

    C/C++ dependency manager from Microsoft For all platforms, buildsystems, and workflows. https://vcpkg.io. Accessed: 2024-09-02

    2024

  19. [27]

    https://spack.io

    A flexible package manager supporting multiple versions, configurations, platforms, and compilers. https://spack.io. Accessed: 2024-09-02

    2024

  20. [28]

    In: Dedner, A., Flemisch, B., Kl¨ ofkorn, R

    Dedner, A., Nolte, M.: Construction of local finite element spaces using the generic reference elements. In: Dedner, A., Flemisch, B., Kl¨ ofkorn, R. (eds.) Advances in DUNE, pp. 3–16. Springer, Berlin Heidelberg (2012). https://doi.org/10.1007/ 978-3-642-28589-9 1

    2012

  21. [29]

    Computer Methods in Applied Mechanics and Engineering 324, 110–127 (2017) https://doi.org/10.1016/j.cma.2017.05.030

    Ainsworth, M., Fu, G.: A lowest-order composite finite element exact sequence on pyramids. Computer Methods in Applied Mechanics and Engineering 324, 110–127 (2017) https://doi.org/10.1016/j.cma.2017.05.030

    2017 doi

  22. [30]

    R.A.I.R.O

    Crouzeix, M., Raviart, P.-A.: Conforming and nonconforming finite element meth- ods for solving the stationary Stokes equations I. R.A.I.R.O. 7(R3), 33–75 (1973) https://doi.org/10.1051/m2an/197307R300331 23

    1973 doi

  23. [31]

    Calcolo 21(4), 337–344 (1984) https://doi.org/10.1007/bf02576171

    Arnold, D.N., Brezzi, F., Fortin, M.: A stable finite element for the Stokes equations. Calcolo 21(4), 337–344 (1984) https://doi.org/10.1007/bf02576171

    1984 doi

  24. [32]

    https://github.com/ KarypisLab/METIS

    Serial Graph Partitioning and Fill-reducing Matrix Ordering. https://github.com/ KarypisLab/METIS. Accessed: 2024-08-12

    2024

  25. [33]

    (ed.) METIS and ParMETIS, pp

    Karypis, G.: In: Padua, D. (ed.) METIS and ParMETIS, pp. 1117–1124. Springer, Boston, MA (2011). https://doi.org/10.1007/978-0-387-09766-4 500

    2011 doi

  26. [34]

    http://cs

    Parallel Partitioning, Load Balancing and Data-Management Services. http://cs. sandia.gov/Zoltan. Accessed: 2025-01-01

    2025

  27. [35]

    Scientific Programming 20(2), 129–150 (2012) https://doi

    Boman, E.G., C ¸ataly¨ urek, U.V., Chevalier, C., Devine, K.D.: The Zoltan and Isorropia parallel toolkits for combinatorial scientific computing: Partitioning, ordering, and coloring. Scientific Programming 20(2), 129–150 (2012) https://doi. org/10.1155/2012/713587

    2012 doi

  28. [36]

    https://gitlab.dune-project.org/extensions/ dune-curvedgrid (2020)

    Praetorius, S., Stenger, F.: Dune-CurvedGrid: Meta grid for wrapping element geometries into a curved geometries. https://gitlab.dune-project.org/extensions/ dune-curvedgrid (2020)

    2020

  29. [37]

    Numerische Mathematik 33(2), 211–224 (1979) https://doi.org/10.1007/BF01399555

    Bercovier, M., Pironneau, O.: Error estimates for finite element method solution of the stokes problem in the primitive variables. Numerische Mathematik 33(2), 211–224 (1979) https://doi.org/10.1007/BF01399555

    1979 doi

  30. [38]

    Journal of Open Source Software 9(104), 6836 (2024) https: //doi.org/10.21105/joss.06836

    Ospina De Los Rios, S., Bastian, P., Keegan, L., Sahle, S., Vermoortele, D., Wehling, L.: DuneCopasi: A multi-compartment reaction-diffusion simulator for systems biology. Journal of Open Source Software 9(104), 6836 (2024) https: //doi.org/10.21105/joss.06836

    2024 doi

  31. [39]

    Happel, L., Voigt, A.: Coordinated motion of epithelial layers on curved surfaces. Phys. Rev. Lett. 132, 078401 (2024) https://doi.org/10.1103/PhysRevLett.132. 078401

    2024 doi

  32. [40]

    In: Binder, K., M¨ uller, M., Trautmann, A

    Praetorius, S., Voigt, A.: Collective cell behavior – a cell-based parallelization approach for a phase field active polar gel model. In: Binder, K., M¨ uller, M., Trautmann, A. (eds.) Proceedings: NIC Symposium 2018, vol. 49, pp. 369–376. Forschungszentrum J¨ ulich GmbH Zentr...

    2018

  33. [41]

    https: //gitlab.dune-project.org/extensions/dune-vtk (2019)

    Praetorius, S.: Dune-Vtk: Grid reader and writer for the VTK file format. https: //gitlab.dune-project.org/extensions/dune-vtk (2019)

    2019

  34. [42]

    PhD thesis, ETH Z¨ urich (1992)

    Pommerell, C.: Solution of large unsymmetric systems of linear equations. PhD thesis, ETH Z¨ urich (1992). https://doi.org/10.3929/ethz-a-000669614

    1992 doi

  35. [43]

    time ( a s s e m b l e M a t r i x P a t t e r n ) =

    Alk¨ amper, M., Dedner, A., Kl¨ ofkorn, R., , Nolte, M.: The Dund-ALUGrid 24 module. Archive of Numerical Software 4(1), 1–28 (2016) https://doi.org/10. 11588/ans.2016.1.23252 25 Appendix A Supplemental material: The full source code examples A.1 concepts.cc C++ code # include...

    2016

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.