Newer
Older
Differences Between DuMu<sup>x</sup> 3.10 and DuMu<sup>x</sup> 3.9
=============================================
### General changes / structure
### Improvements and Enhancements
- __Grid I/O__: The vtu/vtp reader now allows to read unstructured grid from (ASCII) vtu/vtp files with e.g. dune-alugrid, dune-uggrid. Grid data can also be handled in parallel. Like for the GmshReader, the grid and data is read on rank 0 and then broadcasted for now.
Anna Mareike Kostelecky
committed
- __Multidomain boundary__: A init function was added to coupling managers of free-flow porenetwork as well as free-flow porousmedium to allow for transient problems.
- __Nonlinear least squares__: Added a nonlinear least squares solver (in `nonlinear/leastsquares.hh`) that can be used to for example fit a curve to data points. The fitting function is general and can be, for example, a whole PDE solver. The solver is based on a Levenberg-Marquardt algorithm.
### Immediate interface changes not allowing/requiring a deprecation period:
### Deprecated properties/classes/functions/files, to be removed after 3.10:
Differences Between DuMu<sup>x</sup> 3.9 and DuMu<sup>x</sup> 3.8
=============================================
- __Requirements__: DuMux requires Dune >=2.9 and CMake >= 3.16. It was successfully tested with dune-mmesh 1.4 and OPM 2023.10.
### Improvements and Enhancements
- __Energy Balance__: Modified the energy balance implementation to correctly include the contribution of gravity.
- __Porous Medium Flow for 2pncmin__: Fixed a bug for the non-isothermal 2pncmin test to use the permeability of the current time and not the reference one as permeability can change over time.
- __TPFA Dispersion__: Fixed the transmissibility calculation for TPFA dispersion fluxes.
- __Darcy-Brinkman Freeflow__: Introduced a convenience function to add a Brinkman term to turn the Navier-Stokes model into the Darcy-Brinkman model. With this, a single domain can contain both free flow and flow through a porous medium.
The term is added as a source term in the problem using the new helper function `addBrinkmanTerm`.
The function uses a new spatial parameter interface implemented in the new `BrinkmanSpatialParams` class (`dumux/freeflow/spatialparams.hh`). The helper function can deal with isotropic and anisotropic permeabilites.
- __Face Centered Velocity Reconstrution__: For the FC Staggered discretization of free flow, a reconstrution method has been implemented to collect the full velocity vector at the face center.
- __Pore network__: Added a model and a test case for two-phase compositional fluid flow.
- __Components__: Added the new class `ShomateMethod` for calculating the heat capacity and enthalpy of components at specified temperatures. An example implementation can be found for methane (CH4).
- __SimpleH2O__: Fixed an issue where the function vaporizationEnthalpy returned the result in the wrong unit, added new nonisothermal test.
- __Facet-Coupling__:
* Fixed the handling of duplicate degrees of freedom in the box facet-coupling model in the corner case that an internal fracture turns into a boundary fracture (see [merge request 3748](https://git.iws.uni-stuttgart.de/dumux-repositories/dumux/-/merge_requests/3748) for images).
* The facet-coupling framework has been modified such that lower-dimensional domains coinciding with the bulk domain boundary are supported.
- __ISTL solver factory__: Fixed an issue with exceptions where an exception thrown during solver construction would lead to a deadlock in parallel simulation. The solver factory now communicated the failure which makes the exception recoverable, e.g. in the Newton solver.
- __Periodic Boundaries__: Fixed an issue for vector-valued unknowns. Other schemes that provide a periodic map at boundaries now also support periodicity.
- __TimeLoop__: Added function to allow adjustments of the time step size in the main file, fixes corner cases.
- __Pipeline__: Variable docker image testing is now possible directly out of dumux. A weekly Ubuntu 24.04 pipeline is introduced for a smooth transition to 24.04 in the future.
- __Dependencies__: Fieldcompare and Pylint have been upgraded to newer versions.
### Immediate interface changes not allowing/requiring a deprecation period:
- __RichardsNewtonSolver__: It is now possible to select the `MPICommunicator` used by the `RichardsNewtonSolver` (either real or dummy communicator).
- __CompositionalFluidState__: `setRelativeHumidity` was removed. Use the other setters. This setter was removed because it was very specific with a lot of specific prerequisites not fitting the general concept of the class. It was also outdated and not used in any example or test and didn't fit the index convention used in the fluid systems anymore.
- __LocalResidual of porousmediumflow/nonisothermal and porousmediumflow/nonequilibrium/thermal__: `fluidPhaseStorage` now requires the problem. The old interface is deprecated but a corresponding function call doesn't calculate anything.
### Deprecated properties/classes/functions/files, to be removed after 3.9:
- __Periodic Map__: `periodicVertexMap` has been deprecated. Use `periodicDofMap` instead.
Differences Between DuMu<sup>x</sup> 3.8 and DuMu<sup>x</sup> 3.7
=============================================
- __Requirements__: DuMux requires Dune >=2.9 and CMake >= 3.16. It was successfully tested with dune-mmesh 1.4 and OPM 2023.10.
### General changes / structure
- __Handbook__: The PDF handbook is discontinued. The content has been merged into the online documentation
### Improvements and Enhancements
Timo Koch
committed
- __Pore network__: Added the dual network model proposed in Koch et al (2021) https://doi.org/10.1007/s11242-021-01602-5
- __Pore network__: Added a model for heat conduction in a solid grain network
- __Nonisothermal__: Added a specialized local residual for incompressible flows where the pressure work term cancels with the pressure-dependent part of the enthalpy so that only the internal energy remains in the advective heat flux.
- __Tpfa__: The scv/scvf interfaces no longer store the geometry (can be obtained via local view of grid geometry). This means the memory footprint and also construction performance of the scv/scvfs is greatly improved, especially in higher dimensions. (Similar changes for the CVFE methods are already implemented since the previous release.)
- __Input file__: A string expression parser was added (implementation based on the ExprTK library which is shipped with DuMux). Using the new class `FunctionFromStringExpression<numArgs, ArgType>` functions based on string expression can parsed and evaluated. The most prominent use case is parsing functions
from the parameter input file. The constructor takes the expression and an array of variable names to be replaced by function arguments. The function can then
be evaluated with the function values provided in the same order as the names where specified. An arbitrary number of arguments is supported. ExprTK support very complex expressions, see https://www.partow.net/programming/exprtk/.
- __Time loop__: Fixed a bug when the time is chosen to be negative and/or the end time is set to zero. (Before we assume time is always positive and endtime never zero.). Moreover, time loops can now be constructed from and time step sizes set with `std::chrono::duration`. Finally, corner cases that may occur when using both periodic and manual check points in the `CheckPointTimeLoop` are now properly handled.
- __Chrono__: Added the conversion function `Dumux::Chrono::toSeconds` to parse strings representing numbers with trailing unit into a `std::chrono::duration`. This allows convenient construction of durations, for instance: `const auto tEnd = Dumux::Chrono::toSeconds(getParam("TimeLoop.TEnd"));`, where `TEnd = 12ms` would be valid content in the input file.
- __Hyperelastic__: Added a hyperelastic model (large deformations) and a test (in geomechanics)
- __Property system__: Added a function `inheritsFrom` that allows to query whether a type tag is present in the inheritance hierarchy of another type tag
- __PDESolver__: The LinearPDESolver/NewtonSolver now has an `apply` method that returns a bool (true if converged) instead of throwing an exception
- __Freeflow Nonisothermal__: An issue with the compositional heat flux's upwinding calculations has been fixed
- __Compositional Staggered__: The staggered discretization method has been updated to fix inconsistencies in handling density when evaluating diffusive boundary fluxes. In addition, a total mass balance is now always considered, rather than a total mole balance.
- __Parameters__: The template argument for `getParam` and `getParamFromGroup` now defaults to `std::string`, such that for string parameters one can simply write `const auto param = getParam("MyParam");`
Ned Coltman
committed
- __Compositional Freeflow FCSFV__: Compositional transport has been implemented for the overhauled face-centered staggered finite volume scheme (FCSFV) discretization method. Ported tests are available in the testing suite.
- __GridGeometry__: No longer store the corners/geometry for scv/scvfs also for cc-mpfa and staggered discretizations. This improves the memory footprint a lot. Geometries can be obtained via the local view of the grid geometry.
Mathis Kelm
committed
- __Python bindings__: Python bindings are now disabled by default if DuMux is built without custom configuration (building without any *.opts file / passing variables to CMake). The default options in `cmake.opts` still enable the Python bindings (like before release 3.8) and thus ensure that all libraries are built when `cmake.opts` is passed to dunecontrol. (This applies also to upstream modules if cmake.opts` is used to configure them.) If you follow the default installation instructions everything should stay the same. This update tries to avoid a problem that occurs when mixing static and shared libraries and tries to make it harder for users to get the wrong setup.
### Immediate interface changes not allowing/requiring a deprecation period:
- __Newton__: The Newton solver no longer supports linear solvers without a `norm` interface when computing the resisual norm is required. The linear solvers available in Dumux all have such an interface.
- __MultiDomain__: The MDTraits are now required to state the LocalResidual type in the Subdomain policy (see multidomain/traits.hh). This only affects users that created their own MDTraits and don't use the default MDTraits.
- __PDESolver__: The PDESolver interface now requires an `apply` method that returns a `bool` instead of throwing when not converged
- DuMux-specific preprocessor macros (defined in `config.h`) are now prefixed by `DUMUX_` in order to avoid name conflicts when being passed down to other modules. Corresponding CMake variables (if existing) are now also prefixed. Explicitly, the following macros have been renamed:
- `HAVE_KOKKOS` to `DUMUX_HAVE_KOKKOS`
- `HAVE_OPENMP` to `DUMUX_HAVE_OPENMP`
- `HAVE_GNUPLOT` to `DUMUX_HAVE_GNUPLOT`
- `HAVE_CPP_PARALLEL_ALGORITHMS` to `DUMUX_HAVE_CPP_PARALLEL_ALGORITHMS`
- `HAVE_GMSH` to `DUMUX_HAVE_GMSH`
- `HAVE_GSTAT` to `DUMUX_HAVE_GSTAT`
- `HAVE_PVPYTHON` to `DUMUX_HAVE_PVPYTHON`
### Deprecated properties/classes/functions/files, to be removed after 3.8:
- __MPFA__: `scvf.corners()/facetCorner()/vertexCorner()` have been deprecated. Use functions from the local view of the grid geometry instead.
Differences Between DuMu<sup>x</sup> 3.7 and DuMu<sup>x</sup> 3.6
=============================================
- __Requirements__: DuMux requires Dune >=2.9 and CMake >= 3.14. It was successfully tested with dune-mmesh 1.4 and OPM 2022.10.
### General changes / structure
Timo Koch
committed
- __Doxygen__: The theme of the Doxygen documentation page has been updated to a more modern look and the content has been restructured. The installation guide, the property system description and the chapter on examples and tutorials have been moved from the handbook to the Doxygen documentation. A chapter on parallelism has been added. One of the CI pipelines now includes a build of the Doxygen documentation. The result of this build can be downloaded from the job artifacts.
- __License__: DuMux is now REUSE compliant. Many files are individually licensed, others covered by rules in `.reuse/dep5`.
- __Testing/CI__: One of the CI pipelines now runs the static code analyzer `cppcheck` on every merge request.
- __Testing/CI__: The example documentation is now re-generated in the CI in order to verify that the generated README files are in sync with the sources from which they are produced.
- __Testing/CI__: The test suite now uses the [`fieldcompare`](https://pypi.org/project/fieldcompare/) library to compare VTK and data files in regression tests. The legacy comparison backend is kept as fallback.
- __Metadata__: Added a codemeta.json file describing DuMux
- __CMake__: DuMux now requires at least CMake version 3.14
### Improvements and Enhancements
- __Linear solvers__: New linear solvers have been added in `istlsolvers.hh`. They offer additional runtime options and most of them can be utilized in MPI parallel computation, eliminating the need to use `istlsolverfactory.hh` which takes longer to compile.
- __Linear solvers__: Added three multi-threaded smoothers that can be used to speedup AMG (ParMTJac, ParMTSOR, ParMTSSOR).
- __Linear solvers__: Added an iterative solver for the Stokes problem with a block-diagonal or block-triagonal preconditioner.
- __Examples__: There are now three more examples. The first example shows how to simulate diffusion using a custom model equation, with finite volume/element methods. The second one models the separation of two phases using Cahn-Hilliard model with two governing nonlinear equations. The third example models tracer spread in blood and tissue using a multi-domain model coupling 1D advection-diffusion equation and 3D diffusion equation in the porous medium.
- __Box/Diamond/Bubble/CVFE Assembly__: All CVFE schemes now use the same element solution and
the same assembler. The old assemblers have been deleted (see below).
- __IO/RasterImageWriter__: A tool now exists for writing `.pbm` and `.pgm` image files.
- __Shallow water equations__: Added new friction law `FrictionLawViscousNoSlip` for viscous thin film flow.
- __Shallow water equations__: Make regularization of the water height / roughness height optional in the friction laws.
- __Projection__: In addition to the L2-projector projecting between different grids added a helper that computes the L2-projection of analytic functions in to discrete FEM spaces (requires `dune-functions`).
- __Box__: No longer store the corners/geometry for scv/scvfs. This improves the memory footprint a lot. Geometries can be obtained via the local view of the grid geometry. (Implementation for other discretization schemes is planned for the coming release and scv/scvfs interfaces are deprecated.)
- __GridGeometry__: The grid geometry inherits from a basic discretization-agnostic implementation that can be swapped out via traits. The basic implementation contains the bounding box tree and mappers and the instance can be shared among multiple grid geometry instances reducing the number of trees/mappers that have to be instantiated for multidomain problems where both domains use the same grid, e.g. Stokes.
- __Fmt__: shipped fmt has been updated to 9.1.0. If the standard library support <format> we now use the standard library instead of fmt. Note that the standard library implementation does not support all features of fmt. In case you have been using such special features you might need to face errors for this reason.
- __Assembler__: `FVAssembler::assembleJacobian` was fixed (didn't actually compile before) and is also tested now. It assembles the Jacobian matrix. Most commonly the method `FVAssembler::assembleJacobianAndResidual` is used which also assembles the residual which is need when computing finite difference approximations of the Jacobian anyway.
- __Poromechanics__: Fixed a bug in `PoroElasticLocalResidual`, where the average density between fluid and solid was computed incorrectly, potentially leading to unphysical body forces.
- __Box/CVFE/Porenetwork Assembly bugfix__: The flux variables caches are now updated when computing the Jacobian. Before this fix, fluxvariable caches depending on the solution were not updates for CVFE schemes such that the resulting Jacobian was only an approximation.
- __Time loop__: Only insert duplicate check points once.
### Immediate interface changes not allowing/requiring a deprecation period:
Timo Koch
committed
- __Assembler/Newton/PDE/Solver__: We now distinguish between `SolutionVector` and `ResidualType`/`ResidualVector`. The former
contain `Dumux`-specific types like `SwitchablePrimaryVariables` as block types. The latter is native to the linear algebra backend.
The only supported linear algebra backend at the moment is Dune (common/istl). If you have implemented your own assembler or
PDE solver, you may also now need to follow this distinction in the assembler and solver interfaces. Moreover, you may need to
use specialized assign and numeric operations in case your code allows for custom block types. If you are using the classes
from the `Dumux` namespace, no change should be necessary in user code in the majority of cases.
- __Box/CVFE/Porenetwork FluxVariablesCache__: The `FluxVariablesCache` class used with CVFE method are now required to have an interface
variable `isSolDependent` that states whether the cache depends on the solution. This is used in the assembler to correctly update the cache. The `ElementFluxVariablesCache` classes with caching disabled now need a method `update` that updates the caches on demand. The
`GridFluxVariablesCache` classes with caching enabled now need a method `updateElement` equivalent to `update` for the corresponding localView for caching disabled.
- __Shallow water friction laws__: The friction laws after Manning and Nikuradse do no longer apply a limiter for the water depth. Previously, based on some application-specific assumption a roughness height was calculated that was added to the water depth. This
height can now be provided as a argument to the respective friction law class constructors
but defaults to `0.0`.
Timo Koch
committed
- __NewtonConvergenceWriter__: The convergence writer now takes three template arguments.
The new and last argument is the `ResidualType` (see above).
- __FaceCenteredDiamond__: The boundary treatment now follows the other control-volume
finite element schemes. This means that problem's `boundaryTypes` and `dirichlet` interfaces
are called with a sub-control volume as argument instead of
a sub-control volume face. The integration point of the scvf corresponds
to the dofPosition of the scv. In case you have been using the
`FaceCenteredDiamond` discretization and not the `boundaryTypesAtPos` and `dirichletAtPos`
version you will face an exception. Replace the functions by the version with an `scv`.
The change is made in the attempt to unify assembly for CVFE schemes
- __Box/Diamond/Bubble/CVFE Assembly__: The classes `BoxLocalAssembler`, `FaceCenteredDiamondLocalAssembler`, `PQ1BubbleLocalAssembler`, `BoxSubdomainLocalAssembler`, `FaceCenteredDiamondSubdomainLocalAssembler`, `PQ1BubbleSubdomainLocalAssembler` and corresponding
headers have been replaced by `CVFELocalAssembler` and `CVFESubdomainLocalAssembler`.
- __Default CO2 Table__: The new header `defaultco2table.hh` provides the CO2 density and enthalpy values with in the range of 290 K to 340 K and 100 KPa to 100 MPa. The script `make_co2_table.py` now generates the `co2table.hh` for a specified range, which can be directly included in the properties file.
### Deprecated properties/classes/functions/files, to be removed after 3.7:
- __AMGBackend__: `AMGBiCGSTABBackend` have been deprecated, use `AMGBiCGSTABIstlSolver` instead
- __IstlSolverFactoryBackend__: `IstlSolverFactoryBackend` now require an additional parameter `LinearAlgebraTraits`
- __BrineCO2__: Fluidsystem `BrineCO2` and binary coefficients `Brine_CO2` receiving a `CO2Table` as
template parameter has been deprecated. Pass a component instead, use `Components::CO2<CO2Table>` to
keep using a tabulated component.
- __GridGeometry__: scv/f.corner/geometry() interfaces
Differences Between DuMu<sup>x</sup> 3.6 and DuMu<sup>x</sup> 3.5
=============================================
### General changes / structure
- __Testing/CI__: Dumux is now tested with C++20 flag enabled in addition to C++17 (which is still the minimum requirement)
- __Testing/CI__: The CI system now checks for common spelling mistakes using the `codespell` tool.
### Improvements and Enhancements
- __bin/extract_as_new_module.py__: Allow for main branch named `main` or `master`
- __Components__: Fixed a bug in `TabularizedComponent` that caused data races in multithreaded applications
- __Discretization__: There is now defaults for `FluxVariablesCache` and `FluxVariablesCacheFiller` for box/cctpfa/ccmpfa/staggered
that implement an empty cache (i.e. nothing is cached for the flux variables).
- __Discretization__: Added a new face-centered FV scheme based on non-conforming FE spaces `FCDiamond`
- __Discretization__: Added a new FV scheme based on conforming FE spaces `pq1bubble`
- __Discretization__: Added a `basicGridGeometry` which isn't discretization specific and may be shared among multiple `gridGeometry`s on the same grid.
- __Grid__: Added stamped subgrids which allow for domains to be generated from repeated images
- __Parallelization__: Update grid caches in parallel
- __Parallelization__: GridView confirms whether multithreaded iteration of the grid is permitted
- __Multidomain__: Added a parallel scalar product for multidomain problems
- __Assembly__: Enabled multithreaded assembly for embedded problems
- __Multiphase and multicomponent__: Added an initial helper to choose an appropriate constraintsolver based on present phases
- __Properties__: There is now a `GetPropOr` helper that evaluates to the property type if that type is specialized for the given TypeTag and a given type if not.
- __1d3d__: Fixed a bug in the extended source stencil which didn't respect a user-defined epsilon for numeric differentiation
- __Pore-network model__: Pore-network model will no longer prevent non-wetting fluid flowing out by default. Throats blocking non-wetting fluid can be specified by setting runtime parameter `InvasionState.BlockNonwettingPhaseAtThroatLabel`.
Maziar Veyskarami
committed
- __Pore network model__: Fixed a bug in the calculation of pc snap-off. To calculate the pc snap-off, corner half angle of the throat cross section shape is needed. Previous implementation was only based on square cross section. We included corner half angle in the calculation to be able to calculate pc snap-off for other cross sections than square.
Maziar Veyskarami
committed
- __Examples__: Extend the porenetwork_upscaling example to include non-creeping flow simulation in pore network. The example is able now to provide not only upscaled Darcy permeability but also Forchheimer permeability and coefficient (employed in Forchheimer equation).
- __Json__: Dumux now ships a fixed version of `https://github.com/nlohmann/json` to read and write JSON files. Only the symbols in the namespace `Dumux::Json` are meant to be used with Dumux. In particular, this now exports the json tree structure. More features may be added in the future.
### Immediate interface changes not allowing/requiring a deprecation period:
- __Experimental features__: All headers with experimental features have been moved into the folder `dumux/experimental`.
Correspondingly, all unit tests for those features have been moved to `test/experimental`.
- __Stokes/Darcy__: In the coupling manager, the diffusion coefficient coupling type had a mode `Arithmetic` misspelled
with an additional letter. The spelling has been corrected. The incorrect spelling will lead now lead to an error.
- __Box__: The grid geometry now passes information to the local view via an internal cache (instead of passing a pointer to itself directly). This allows to hide some internal interfaces. This only concerns implementers of FVElementGeometry classes that inherit from the box implementation and don't overload the constructor.
Then code possibly fails to compile. The fix is to implement the same caching concept. The cache can be a simple wrapper around the grid geometry pointer.
### Deprecated properties/classes/functions/files, to be removed after 3.6:
- __Box__: `scv/scvf.geometry()` have been deprecated, use `fvGeometry.geometry(scv/scvf)` instead
- __Box__: `scv/scvf.corner(i)` have been deprecated, use `fvGeometry.geometry(scv/scvf).corner(i)` instead
- __Cell centered__: The `computeTpfa/MpfaTransmissibilities()` interfaces now require an additional parameter `fvGeometry`
- __Staggered__: `fluxVars.advectivFluxForCellCenter()/inflowOutflowBoundaryFlux()` interfaces now require parameter `fvGeometry` instead of `element`
- __Discretization__: `Extrusion::area/volume(scvf/scv)` have been deprecated, use `Extrusion::area/volume(fvGeometry, scvf/scv)` instead
- __Richards__: Using the extended Richards model accounting for vapor diffusion in the gaseous phase by setting the property `EnableWaterDiffusionInAir` and the use of the corresponding template parameter in `richards/model.hh` has been deprecated. Use the new model `ExtendedRichards` instead
- __Navier-Stokes__: The unified `NavierStokesParentProblem` covering both momentum and mass problems has been deprecated, use separated problems instead
- __Box__: `BoxElementVolumeVariables` and `BoxGridVolumeVariables` have been deprecated, use unified `CVFE` volume variables instead
### New experimental features (possibly subject to backwards-incompatible changes in the future)
- __Meta data__: There is support for extraction of meta data in `dumux/common/metadata.hh`. The extracted features, might change in the future
and we can't give any guarantee that the name of keys and values in the extracted meta data tree will be stable between releases.
Differences Between DuMu<sup>x</sup> 3.5 and DuMu<sup>x</sup> 3.4
=============================================
- __Requirements__: DuMux requires Dune >=2.8 and CMake >= 3.13. It was successfully tested with OPM 2021.10 (which in turn requires Dune <= 2.8), see also [patches](https://git.iws.uni-stuttgart.de/dumux-repositories/dumux/-/tree/master/patches).
- __Sequential__: The old "sequential", "IMPES-style" models have not received updates in several years,
are separate from the rest of the code base and increasingly became a maintenance burden. Deprecation warnings
are emitted when using the sequential models since the DuMu<sup>x</sup> 3.0 release. For DuMu<sup>x</sup> 3.5,
these models are now removed from the code base. To continue using them use `releases/3.4`. IMPES-style algorithms
are possible in the DuMu<sup>x</sup> 3.0 style of implementing models but their development did
not receive much attention. See https://git.iws.uni-stuttgart.de/dumux-repositories/dumux/-/merge_requests/2629
for the state of current efforts. Further improvements and contributions (MRs) on this front
are highly welcome (get in contact via the DuMu<sup>x</sup> mailing list).
- We adopted a code of conduct, see `dumux/CODE_OF_CONDUCT.md`
### Improvements and Enhancements
- __ParallelFor and multithreaded assembly__: For single domain applications using Box of CCTpfa discretization,
the possibility for multithreaded (thread-parallel) assembly has been added. It is using the newly added
`Dumux::parallelFor` interface. This features requires a backend to be available.
This can be either external backends (TBB, Kokkos) or a working C++ STL parallel algorithms setup.
The backend will be selected automatically, if found. You can also specify the backend by setting the
compiler definition `DUMUX_MULTITHREADING_BACKEND=TBB,Cpp,Kokkos,Serial`, where Serial forces to always run in serial.
For the assembly, you can explicitly turn multithreading off setting the runtime parameter `Assembly.Multithreading = false`.
If a backend is available and the discretization allows it, the default is multithreaded assembly.
When using TBB or Kokkos is it required (recommended) to use `Dumux::initialize` in the main file.
- __initialize__: A new control function `Dumux::initialize` has been added which initializes shared and distributed
memory parallelism helpers. It is recommended (and may be required for multithreaded applications) to use `Dumux::initialize`
instead of manually initializing the `Dune::MPIHelper`.
- __Problem/Spatialparams interface__: The interface functions `extrusionFactor`/`extrusionFactorAtPos` and `temperature`/`temperatureAtPos` have been removed from the problem interface and added to the spatial params interface. There is now a default set
for temperature (`293.15K`) which can be changed via the input file parameter `SpatialParams.Temperature`. For more
flexibility overload the function in your spatial parameter class like usual.
- __material/spatialparams__: The folder has been dissolved and the headers have been moved to other folders. For example,
spatial parameter classes specific to porous medium flow problems have been moved to `dumux/porousmediumflow`. This is due
to the realization that spatial parameters do more than defining the "material" (which refers to the porous medium).
For example, free flow problem also have parameters that may spatially vary (such as the extrusion factor in an extruded domain).
- __Tensor average__: Added a function `faceTensorAverage` which performs a particular average of a tensor at interfaces.
This replaces the interface `harmonicMean` in the spatial parameters.
- __Component__: `gasViscosityIsConstant` added to component interface
- __Fluidsystems__: Implemented `viscosityIsConstant(int phaseIdx)` for `H2OAir`
- __Dispersion__: Dispersion fluxes have been added as an option for the compositional and thermal one-phase porous medium flow models. These models use either a Scheidegger-type dispersion tensor, which is dependent on the velocity field and two length parameters, or a full and constant (_not_ solution-dependent, but possibly spatially varying) tensor that can be user defined in the spatial parameters. For compositional models coupled with flow models (e.g. 1pnc), using the Scheidegger-type dispersion tensor is only implemented for the box discretization method.
To enable either thermal or compositional dispersion, please define these properties within your `properties.hh` header. For example:
```cpp
template<class TypeTag>
struct EnableCompositionalDispersion<TypeTag, TTag::MyTest> { static constexpr bool value = true; };
template<class TypeTag>
struct EnableThermalDispersion<TypeTag, TTag::MyTest> { static constexpr bool value = true; };
```
To determine the type of dispersion tensor, please define the property `CompositionalDispersionModel` within your `properties.hh` header. Per default, the `ThermalDispersionModel` is set to the same model as the `CompositionalDispersionModel`, but this can be set specifically as well. For example:
```cpp
template<class TypeTag>
struct CompositionalDispersionModel<TypeTag, TTag::MyTest> { using type = ScheideggersDispersionTensor<TypeTag>; };
template<class TypeTag>
struct ThermalDispersionModel<TypeTag, TTag::MyTest> { using type = FullDispersionTensor<TypeTag>; };
```
The parameters describing your dispersion tensor can then be included in your `spatialparameters.hh` file, and passed via input parameters. An example of this can be seen in the `test/porousmediumflow/1pnc/dispersion/` folder, and in the `test/porousmediumflow/tracer/constvel/` folders.
- __Embedded coupling__: Add a coupling manager for the 1D-3D projection based scheme with resolved interface introduced in Koch 2022 (
https://doi.org/10.1016/j.camwa.2022.01.021)
- __RANS Boundary Types__: Wall boundaries for the RANS turbulence models can now be set using the `setWall` method in the `RANSBoundaryTypes` class. This replaces the old `isOnWall` and `isOnWallAtPos` functions.
- __Discretization tags__: We introduced tags in the namespace `DiscretizationMethods` (with s) for each discretization method.
These tags replace the `enum class DiscretizationMethod`. Tags have several advantages over the enum. Each tag is a named type
(see `dumux/common/tag.hh`) so they can for example be used in tag dispatch. Moreover specializing with tags is extensible.
For example we specialize the template `DarcysLawImplementation` for each discretization. When using the enum no new discretization
methods can be added without changing `enum class DiscretizationMethod`. With tags you can make your own tag and specialize a
class for that tag. This means new discretization methods can be developed in a modular fashion. The introduction of tags
involves a couple of non-backwards-compatible changes, mostly in implementation classes that shouldn't affect most users (see below).
- __Box__: The box scheme now supports the case that volume variables depend on all dofs in the element. In that case, previously
only a Jacobian approximation was assembled. As computing the added derivatives causes a significant
overhead in the assembly, the feature is disabled per default. To enable the full Jacobian in this case set the parameter
`Assembly.BoxVolVarsDependOnAllElementDofs = true`. The new feature is tested in the new test `test_2p3c_surfactant` which
features relative permeability that depend on the pressure gradient. The test only passes with the full Jacobian.
- __Local views__: The bind function associated with the local view of the FVElementGeometry, the ElementVolumeVariables, and the ElementFluxVariablesCache have been simplified. Now it is possible to directly create each of these objects where they are already bound. The following are examples of each new call:
```cpp
const auto fvGeometry = localView(gridGeometry).bind(element);
const auto elemVolVars = localView(gridVolVars).bind(element, fvGeometry, sol);
const auto elemFluxVarsCache = localView(gridFluxVarsCache).bind(element, fvGeometry, elemVolVars);
```
This is also available for the `bind()` `bindElement()` and `bindScvf()` functions. The existing methods for binding will remain.
Please note however that when working with element loops, separating construction and binding of the local view is more efficient, i.e.
```cpp
auto fvGeometry = localView(gridGeometry);
for (const auto& element : elements(gridGeometry.gridView()))
fvGeometry.bind(element);
```
- __Construction and update of GridGeometries changed__: Grid geometries are fully updated after construction. Additional call of update functions are therefore only needed after grid adaption. Calling the update functions after construction now leads to a performance penalty.
- __Geometry__:
- Added implementation of sphere and bounding sphere approximation algorithms
- Added distance queries for Point->BoundingBoxTree
- Added DistanceField - a wrapper around a geometry set for fast distance queries
- Added WallDistance - a utility to compute distances to the domain boundary (e.g. for RANS wall functions)
- Added 3D-3D intersections
- Added 2D-2D intersections in 3D
- Fixed a wrong epsilon for floating comparisons in the 2D-2D intersection algorithm
- __Parallel grid partitioning__: Added a simple backend for using Scotch as partitioner for a grid read on one process (e.g. when using the Dune Gmsh or DGF readers). Repartitioning is not implemented yet.
- __Cake grid creator__: The cake grid creator can now be used in parallel simulations
- __Privarswitch__: Fixed a bug in the privar switch which did not fully reset the `switched` variable. This lead
to a possibly increased number of Newton iterations.
- __1pnc__: `delp` has been removed from the default vtk output fields in an attempt to streamline output between models.
All information present in `delp` is present in `p` and `delp` has generally a reduced precision that also leads to some
problems in automated testing.
- __Richards__: the `Richards` model now works together with the generic `FluidSystem::TwoPImmiscible` as long as a gas
and a liquid phase are present.
- __Richards__: Fixed a bug that creeped into the 1.5-phase model so it actually computes diffusion in the gas phase now.
- __Richards__: Fixed a bug that checked that the fluid viscosity is _not_ constant whereas the check should have asserted that it is constant
### Immediate interface changes not allowing/requiring a deprecation period:
- __Discretization tags__: The following classes have changed from a template argument of type `DiscretizationMethod` (an `enum`) to
class type template arguments and are now specialized for tags: `TwoPScvSaturationReconstruction`, `ScvfToScvBoundaryTypes`, `ProblemTraits`, `FluxStencil`, `EffectiveStressLaw`, `HookesLaw`, `FacetCouplingManager`, `FacetCouplingMapper`. Moreover this affects the following helper classes: `IsFicksLaw`, `CheckOverlapSize`, `PartialReassemblerEngine`, `SubDomainAssemblerType`. Finally, this change has been made for many implementation classes. These should not have been used directly anyway, so we do not explicitly list them here. Examples are `DarcysLawImplementation`, `LinearSolverTraitsImpl`. See !2844 for more details.
If you face a compiler error from these changes, contact us. Most like the solution is to simply try replacing occurrences of `DiscretizationMethod` with the corresponding tag from `DiscretizationMethods`, or types `DiscretizationMethod` in template arguments by generic `class`.
- __Coupling managers__: The coupling managers now store shared_ptrs of the subdomain solutions to be able to manage memory outside. There is compatibility interface that is deprecated but it won't allow for assignments
of the form `this->curSol() = sol;` since curSol returns a MultiTypeVector of references. If assignment is needed for some reason, use a hybrid loop over all subdomain indices.
- __Virtual interface of GridDataTransfer__: The `GridDataTransfer` abstract base class now required the Grid type as a template argument. Furthermore, the `store` and `reconstruct` interface functions do now expect the grid as a function argument. This allows to correctly update grid geometries and corresponding mapper (see "Construction and update of GridGeometries changed" above in the changelog)
- `PengRobinsonMixture::computeMolarVolumes` has been removed without deprecation. It was used nowhere and did not translate.
- __ShallowWaterViscousFlux__: The template argument `PrimaryVariables` has been removed without deprecation. It was not needed.
### Deprecated properties/classes/functions/files, to be removed after 3.5:
- `update()` functions of grid geometries, which do not receive the `gridView`, are deprecated, use `update(gridView)` instead.
- `enum class DiscretizationMethod` and associated functions, to be replaced by tags
- `test_dumux.sh` is deprecated.
- `compareparameters.sh` is deprecated, use `generate_parameterlist.py` instead.
- `replace_property_macros.sh` is removed.
- `isOnWallAtPos` and `isOnWall` are no longer used in the RANS models to designate wall boundaries. These boundaries are now directly set in the RANSBoundaryTypes using the setWall() function.
- the `temperature` and `extrusionFactor` interfaces in the problem class have been deprecated and have been moved to the spatial parameters.
- Porous medium flow models should now inherit from the new base spatial parameters that can be found in the folder `dumux/porousmediumflow/`, which allow users to overload the new `temperature` and `extrusionFactor` interfaces.
- Free flow and pore network models now also expect the user problems to expose spatial parameters, in which `gravity`, `temperature` and `extrusionFactor` are defined. The respective problem interfaces have been deprecated.
- `harmonicMean` has been deprecated in the spatial params use new `faceTensorAverage`
- The problem interfaces for fluid properties in the poroelastic model, namely `effectiveFluidDensity` and `effectivePorePressure`, have been deprecated and were moved to the spatial parameters.
- The function `shearStress` in the class `FrictionLaw` and its child classes has been renamed to `bottomShearStress` and the return value has been changed. The function returns now the actual bottom shear stress and not the bottom shear stress term as it used in the shallow water model. The bottom shear stress term of the shallow water model is the bottom shear stress multiplied with minus one and normalised by the water density.
### New experimental features (possibly subject to backwards-incompatible changes in the future)
- __Staggered grid__: The staggered grid implementation has been overhauled. Unfortunately, this overhaul has not been completed yet.
Most of the Navier-Stokes tests now use the new implementation. The old implementation is still available and not deprecated yet,
but will be phased out after the release. For now both implementation live next to each other in the code base.
The new implementation is more closely built on the multidomain framework and now fully
realizes the finite volume abstractions described in the Dumux paper. The first aspect means that mass and momentum are now
separate sub-models of Navier-Stokes than can be (and are) discretized with different discretization methods and then coupled
together via coupling managers. The implemented mass discretization is CCTpfa. The momentum discretization is a face-centered
staggered finite volume scheme (FCSFV). The second aspect means that for the FCSFV scheme, subcontrol volumes and faces
are now represented by corresponding classes in the code just like for CCTpfa, Box, CCMpfa.
There is a problem class added that helps to implement both the mass and the momentum problem in one (templated) class.
Boundary conditions are now clearly separated into mass and momentum boundary conditions.
When the new implementation is fully adapted the documentation will be updated with it, this might take some time
and is not included in this release yet.
- __FF-PNM__: Added a model and test for coupling a porenetwork with a freeflow domain (see Weishaupt PhD: http://dx.doi.org/10.18419/opus-10932)
- __Python bindings__: The Python bindings work with Dune master now, which features an improved way of installing them.
The new way will be described better in the documentation once Dune 2.9 is release. Until then we refer to the
documentation of Dune. The setup with Dune 2.9 is not compatible with the setup with Dune 2.8 but we made sure
that Dumux 3.5 support both variants.
- __Pore-network models__: The development continues and many smaller things have been improved.
The PNM models remain experimental. The grid creator has been improved in usability. Added a
convenience script to extract PNM with porespy and create a DGF grid usable with Dumux.
### Continuous integration
- __Python bindings__: The Python bindings are now tested in the CI. Furthermore, Python scripts are
automatically checked with linters, see `dumux/python/README.md` for more information.
Differences Between DuMu<sup>x</sup> 3.4 and DuMu<sup>x</sup> 3.3
=============================================
- __Requirements__: DuMux still requires Dune >=2.7 and CMake >= 3.13. It was successfully tested with OPM 2021.04.
- __Pore-network models added to DuMux__:
- Three fully implicit pore-network models (1p, 1pnc, 2p) have been added.
- A quasi-static 2p PNM for the creation of pc-Sw curves has been added.
- A new namespace `Dumux::PoreNetwork` has been introduced, containing all relevant classes and functions for pore-network modeling.
- An example introduces the use of the 1p PNM for the estimation of the upscaled Darcy permeability.
- Advection type including inertia effect for simulations in the non-creeping flow regime is available.
- Note that this is still considered a rather _experimental_ feature. Everything within namespace `Dumux::PoreNetwork` might undergo (backward-compatibility breaking) changes _without prior notice_.
- __Several scripts have been translated to Python__:
Farid Mohammadi
committed
- `installexternal.sh` to install external modules and libraries now rewritten as python script `bin/installexternal.py`
- `getusedversions.sh` to extract the used DuMux/Dune versions of a module (new script: `bin/util/getusedversions.py`)
- `extractmodulepart.sh` no longer creates an install file, instead, you can now generate install scripts for your module using the new script `bin/util/makeinstallscript.py`.
- Note: the old shell scripts will be removed after release 3.4.
Bernd Flemisch
committed
- __Python bindings__: There is now a small finite volume example included in the Python tests using the wrapped grid geometry and problem, see [test_explicit_transport_cctpfa.py](https://git.iws.uni-stuttgart.de/dumux-repositories/dumux/-/blob/releases/3.4/test/python/test_explicit_transport_cctpfa.py).
- __Law for water vapor viscosity in gas mixtures changed__: Polynomial laws for determining the viscosity of vater vapor in gas mixtures are introduced and applied by the new function `h2oGasViscosityInMixture`. The polynomial laws give a better approximation of the gas viscosity especially at higher temperatures ( >273.15 K) and a high water vapor content.
- __Newton line search__: The line search algorithm decreases the step size until the residual decreases. The lower bound
of the step size can now be set in the input file via the parameter `Newton.LineSearchMinRelaxationFactor`.
- __Material / Constant component__: The `Component::Constant` can now be used in non-isothermal simulation. Simple relations
for internal energy and enthalpy depending on temperature and constant heat capacity have been added.
Bernd Flemisch
committed
- __Linear PDE solver__: The `LinearPDESolver` can reuse the matrix and thus avoid unnecessary reassembly. See [test/porousmediumflow/tracer/constvel/main.cc](https://git.iws.uni-stuttgart.de/dumux-repositories/dumux/-/blob/releases/3.4/test/porousmediumflow/tracer/constvel/main.cc#L119) for an example.
- __Ordering strategies for UMFPack__:
Bernd Flemisch
committed
It is now possible to [choose an ordering strategy](https://git.iws.uni-stuttgart.de/dumux-repositories/dumux/-/blob/releases/3.4/dumux/linear/seqsolverbackend.hh#L851) for UMFPack via the runtime parameter `LinearSolver.UMFPackOrdering` or by calling the `setOrdering()` method of `UMFPackBackend`. This can have a positive effect on the solver's performance, depending on the matrix structure.
- __Add setRetryTimeStepReductionFactor() function to NewtonSolver__:
This function allows to set the factor by which the time step is reduced after a failed iteration. Can be used, e.g., for custom Newton solvers inheriting from this class and using a more sophisticated time step management.
- __Improve upwind interface__:
- Additional functions have been added to `upwindscheme.hh` which can be used to `apply` the upwind scheme without the need of `FluxVariables` and to get the `multiplier` by which the flux is multiplied.
- These additional functions are now used in `CCTpfaForchheimersLaw` by providing the upwind scheme as additional template argument.
- __Simplified use of SubGridManger__: It is now possible to specify pixel dimensions when reading an image file used as grid. For instance, `Grid.PixelDimension = 1e-3 1e-3` will scale the domain automatically such that the grid cells have a side length of 1e-3 m and you don't need to specify `Grid.UpperRight` anymore.
- __String utility__: There is a new header `common/stringutilities.hh` that implements two functions `tokenize` and `split`
that can split strings at a given delimiter.
- __Add linearRegression() function to math.hh__:
This function gets a set of (x, y) data and calculates/returns the intercept and the slope of the regression line using the standard least squares method.
- __Shallow water__: Added a heuristic turbulence model based on a mixing length and resulting in a turbulent viscosity term.
### Immediate interface changes not allowing/requiring a deprecation period:
- __Newton__: The global parameter defaults have been substituted for local parameter defaults (in nonlinear/newtonsolver.hh). If
you have been relying on global defaults (reading parameters without supplying a value in the input file nor a default)
you will get a runtime ParameterException. To solve this simply provide a default or set the value in the input file.
- __MPNC__: The `MPAdapter` can now also be called with a temporary `pcKrSw` object. For this, the compiler needs to deduce the
class' template argument types. You may need to adapt your `spatialParams` from
```
using MPAdapter = Dumux::FluidMatrix::MPAdapter<PcKrSwCurve, 2>;
...
auto fluidMatrixInteractionAtPos(const GlobalPosition &globalPos) const
{
return makeFluidMatrixInteraction(MPAdapter(pcKrSwCurve_));
}
```
to
```
// alias for MPAdapter is removed
auto fluidMatrixInteractionAtPos(const GlobalPosition &globalPos) const
{
return makeFluidMatrixInteraction(FluidMatrix::MPAdapter(pcKrSwCurve_));
}
```
- __Grid geometry__: The local views of grid geometries are now required to implement the interfaces
`element()` (returning the bound element) and `isBound()` returning a `bool` which is `true` if the
functions `bind` or `bindElement` have been called (i.e. the local geometry is in a bound state). These
interfaces are currently not used (except in the unit tests) but will be required
### Deprecated properties/classes/functions/files, to be removed after 3.4:
- `Dumux::IsIndexable<T, I>` is deprecated, use `Dune::IsIndexable<T, I>`directly.
- The property `NumEqVector` has been deprecated. The class `NumEqVector` is now defined in the namespace `Dumux` in the header file `dumux/common/numeqvector.hh`.
- The member function `update()` of mappers is deprecated, use `update(gridView)` when updating the mapper after a grid or grid view change.
- All custom mapper implementations should implement `update(gridView)` replacing `update()`. Mappers with `update()` will no longer be supported after support for Dune 2.7 is dropped.
### New experimental features (possibly subject to backwards-incompatible changes in the future)
- __Time stepping__: a first implementation of a generic `Dumux::MultiStageTimeStepper` was introduced,
that allows for using different time integration schemes besides the currently supported implicit and explicit
Euler schemes. However, this poses new requirements on the linear system assemblers, which are not yet met by
the standard assemblers provided in DuMux. This will be extended in future versions.
### Continuous integration
- A first version of the DuMux GitLab CI is now at the disposal of all developers. While every night a complete
test pipeline is triggered automatically, developers have the possibility to manually start test pipelines
within merge requests that automatically identify and run only those tests affected by the changes introduced.
Differences Between DuMu<sup>x</sup> 3.3 and DuMu<sup>x</sup> 3.2
=============================================
### Improvements and Enhancements
- __Requirements__: DuMu<sup>x</sup> now requires Dune >=2.7 and CMake >= 3.13.
- __New way to use material laws__: The usage of laws for pc-Sw and kr-Sw has been completely revised. A caller does not have to pass a `parameters` object to the laws anymore. The `spatialParams` now provide a `fluidMatrixInteraction` function which bundles an arbitrary number of
different interaction laws such as a pc-Sw and kr-Sw curve and interfacial areas.
New pre-cached spline laws were added which can help to increase efficiency. The usage of the old interface is deprecated and warnings will be raised. The old interface will be removed after the release of 3.3.
- __New example__: We have added another free-flow example dealing with lid-driven cavity flow.
- __Install script written in Python__: The DuMu<sup>x</sup> install script has been translated to Python to improve portability. The old shell script will be removed after release 3.3.
- __Improved velocity reconstruction__: The velocity reconstruction for immiscible porous-media models has been improved, leading to slightly
different velocity fields in the vicinity of Neumann boundaries.
- __Python bindings (experimental)__: Basic support for Python bindings has been added. Python bindings are an experimental feature
and might undergo unannounced API changes until further notice. This concerns the files in the folders `python` and `dumux/python`. To activate
- add `-DDUNE_ENABLE_PYTHONBINDINGS=TRUE` and `-DCMAKE_POSITION_INDEPENDENT_CODE=TRUE` to your CMAKE_FLAGS and run dunecontrol
- adapt your PYTHONPATH environment variable as described [here](https://git.iws.uni-stuttgart.de/dumux-repositories/dumux/-/tree/master/python)
- __Obtain DuMux via pip__: The Dumux source code can now be installed using `pip install dumux`. This works for the Python bindings as well as the C++ source code. Matching Dune modules are also installed. Currently not all dune modules have Python packages available. We recommend trying this new feature in a virtual environment by typing
```sh
python3 -m virtualenv venv
source venv/bin/activate
pip install dumux
```
To test the setup you can use the following Python script
```py
from dune.grid import structuredGrid
from dumux.discretization import GridGeometry
gridView = structuredGrid([0,0],[1,1],[5,5])
gridGeometry = GridGeometry(gridView, discMethod="cctpfa")
gridGeometry.update()
print("The total number of scvs is {}".format(gridGeometry.numScv()))
print("The total number of scvfs is {}".format(gridGeometry.numScvf()))
```
- __fmt-library__: We now include a basic version of the [fmt-library](https://github.com/fmtlib/fmt) which implements `std::format` (coming with C++20) without the need for C++20.
In order to use this, include `<dumux/io/format.hh>`. `format`, `format_to`, `format_to_n`, `formatted_size` are available in the `Dumux::Fmt` namespace.
The string formatting is documented [here](https://en.cppreference.com/w/cpp/utility/format/formatter#Standard_format_specification) and follows the Python string formatting rules.
The functions are documented on [cppreference](https://en.cppreference.com/w/cpp/utility/format).
- __RANS__: The RANS models now include variable densities. Compositional or nonisothermal RANS models could produce slightly different, more accurate, results.
### Immediate interface changes not allowing/requiring a deprecation period:
- __Flash/Constraintsolver__: The flashes depending on material laws are immediately required to use new-style material laws (fluidMatrixInteraction interface in spatialparams)
- __Box interface solver__: The box interface solver immediately requires the new material law interface without deprecation period. Use the new class `BoxMaterialInterfaces` and update your spatial params to use the new fluidmatrixinteraction interface to be able to use the box interface solver in version 3.3.
Timo Koch
committed
- For the "sequential" models, the property `BoundaryTypes` has been simply renamed to `SequentialBoundaryTypes`
- __Quadmath__: Dumux::Quad has been removed without deprecation. Use Dune::Float128 instead.
- Within the RANS group, two additional runtime parameters have been included 'IsFlatWallBounded' and 'WriteFlatWallBoundedFields'.
For both the K-Epsilon and Zero-eq RANS models the 'IsFlatWallBounded' runtime parameter should be set as True,
as wall topology is not supported for these models with our geometric constraints. If not set as true, the geometry
Timo Koch
committed
will be checked before the model is run. If either the runtime parameter or the geometry check indicate non-flat walls,
the model will terminate. To add FlatWallBounded specific output to the vtk output, WriteFlatWallBoundedFields can be set as True.
Timo Koch
committed
- __1d3d coupling__: The kernel coupling manager has been replaced with the one from Koch et al (2020) JCP https://doi.org/10.1016/j.jcp.2020.109370
Timo Koch
committed
- __1d3d coupling__: The average and surface coupling managers has been updated with a slightly more accurate version to compute the stencils and the average operator.
The results might differ a bit when using coarse grids. However, both version are expected to converge to the same result with grid refinement.
Timo Koch
committed
### Deprecated properties/classes/functions/files, to be removed after 3.3:
Timo Koch
committed
- The property `BoundaryTypes` has been deprecated. The boundary condition type can now be deduced from the problem type using `ProblemTraits`.
### Deleted classes/files, property names, constants/enums:
Timo Koch
committed
- Everything that has been deprecated before release 3.2 has been removed.
- All of the geometry headers previously saved in `dumux/common/geometry` have been relocated to `dumux/geometry`.
The headers in `dumux/common/geometry` are deprecated and will be removed after 3.3. The geometry tests have been moved from `test/common/geometry`
Timo Koch
committed
- Releases earlier than 3.0 are no longer automatically tested or supported.
Differences Between DuMu<sup>x</sup> 3.2 and DuMu<sup>x</sup> 3.1
=============================================
### Improvements and Enhancements
- __C++17__: DuMu<sup>x</sup> now requires a C++ compiler supporting the C++17 features of GCC 7 (e.g. GCC 7, Clang 5).
- __Radially symmetric problems__: We now have support for radially symmetric problems (disc, ball, toroid). The support comes in form of wrappers for sub control volumes and faces that overload the respective `volume()` and `area()` function turning a 1d or 2d problem into a 2d or 3d radially symmetric problem.
- __Improvements of Beavers-Joseph(-Saffman) condition for the free flow model__: The naming for handling BJ(-S) boundary conditions has been adapted from `isBJS()` to `isBeaversJoseph()` / `setBJS()` to `setBeaversJoseph()`. In order to consider the velocity within the porous medium, the old `velocityPorousMedium(element, scvf)` method (returning a Scalar) has been renamed to `porousMediumVelocity(element, scvf)` (returning a velocity vector). The latter defaults to `VelocityVector(0.0)`.
- __Van Genuchten__: The VanGenuchten-Mualem material law now allows to set a parameter `l` (default to 0.5) which is sometimes fitted.
Simon Emmert
committed
- __Runtime variable output precision e.g. Float64__: The VtkOutputModule has been adapted to allow easy changes of the vtk output precision. It is now possible to specify output precision in the input file using `Vtk.Precision` followed by either `Float32`, `Float64`, `UInt32`, `UInt8` or `Int32`. `Float32` stays the default. We especially advice the use of `Float64` when working with restart files.
An additional new option is `Vtk.CoordPrecision` which changes the precision of the coordinates only and uses the default of `Vtk.Precision`.
Ned Coltman
committed
- __Effective Laws and Diffusion Coefficients__: The effective laws interface has been changed within !1684. The interface for these laws has been unified, and all coefficients are to be stored in containers that fit to the model. These quantities should then be added in the volumeVariables, meaning all effective quantities would be accessible from the volumevariables.
Ned Coltman
committed
- __Examples__: The documentation of the examples has been improved further, focusing on readability and convenience. Further, three additional examples are included the folder `examples`. To get an overview, point your browser to https://git.iws.uni-stuttgart.de/dumux-repositories/dumux/tree/master/examples.
- __Linear solvers__: There is a new ISTL solver factory backend which allows to choose solvers at runtime (requires dune-istl 2.7) and also enables more parallel solvers (requires dune-istl > 2.7.0).
### Immediate interface changes not allowing/requiring a deprecation period
- Remove `Grid.HeapSize` as dune-ugrid removed the according feature as well.
- __Van Genuchten__: Corrected VanGenuchten-Mualem exponent in the nonwetting saturation formula (`1/3` instead of `1/2` (or `l`, see above))
- __Van Genuchten__: Corrected VanGenuchten-Mualem implementation of `dkrn/dSw`
- __Brooks-Corey__: Corrected Brooks-Corey implementation of `dkrn/dSw` and added the derivatives for the regularized version
- __AMGBackend__: The internal structure of the AMGBackend and the ParallelISTLHelper has been overhauled, as only used by the AMG, we did not make the changes backwards-compatible
Timo Koch
committed
- The global default parameters for linear solvers have been removed and moved to the class `LinearSolver`.
This only affects users that directly obtain this parameter via `getParam` somewhere in the code.
- __Sequential linear solver backends__: Remove template argument `precondBlockLevel` from `solve` functions. The preconditioner block level is now determined automatically, assuming a value of
1 for regular BCRS matrices and a value of 2 for MultiTypeBlock matrices. The respective calls from the `NewtonSolver` and `PDESolver`classes have been adapted.
- __Change matrix block arrangement for staggered models__: The matrix block structure has been adapted such to comply with the literature standard, i.e., having the velocity block (A) on `M[0][0]`
rather than on `M[1][1]`. This also requires re-arranging the submodels and properties in dumux-multidomain such that the face-related classes and vector entries now appear before the cell-centered ones.
```math
M = \begin{pmatrix}
\end{pmatrix}
\qquad => \qquad
M = \begin{pmatrix}
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
\end{pmatrix}
```
Backwards-compatibility can only be provided to a certain extent. The following changes need to made in the main file:
1.) change the order of the arguments for the `assembler` such that it reads:
```c++
auto assembler = std::make_shared<Assembler>(std::make_tuple(ffProblem, ffProblem, otherProblem, ...),
std::make_tuple(ffGridGeometry->faceFVGridGeometryPtr(),
ffFvGridGeometry->cellCenterFVGridGeometryPtr(),
otherFvGridGeometry, ...),
std::make_tuple(ffGridVariables->faceGridVariablesPtr(),
ffGridVariables->cellCenterGridVariablesPtr(),
otherGridVariables, ...),
couplingManager,
timeLoop, solOld);
// Not changing the arguments will yield a deprecation warning stating this hint but the code still compiles and runs.
```
2.) change the order of arguments in the `partial` function:
```c++
ffSol = partial(sol, ffFaceIdx, ffCellCenterIdx);
// Not changing the argument will rise a compiler error which makes the MR not fully backwards-compatible.
```
Regarding changes made to the effective laws and diffusionCoefficient containers, Backwards-compatibility is maintined for a large extent, barring any volumevariable classes defined externally that inherit from the non-isothermal volumevariables.
Ned Coltman
committed
If you use a self defined volumevariables class that inherits from the non-isothermal volumevariables, please adapt the your volumevariables class to fit to the non-isothermal volumevariables, and include the new methods for accessing the diffusion and effective diffusion coefficients.
- Tracer model: tracer fluid systems do no longer provide a `getMainComponent` function since this simply doesn't make sense -- the main bulk component is not modeled.
### Deprecated properties, to be removed after 3.2:
- __GridView__: The property `GridView` has been deprecated and can be accessed via `GridGeometry::GridView` instead.
### Deprecated classes/files, to be removed after 3.2:
- __AMGBackend__: The class AMGBackend is deprecated and has been replaced by AMGBiCGSTABBackend which gets some different template arguments
- __AMGTraits__: AMGTraits are deprecated, are to be replaced by LinearSolverTraits and restructured internally. As they were only used by the AMGBackend, we did not make the internal changes backwards-compatible
### Deprecated member functions, to be removed after 3.2:
Ned Coltman
committed
- __DiffusionCoefficient(various arguments)__: These coefficients are now defined in the volvars and stored in a container fit to the model. To access these values, use the unified ```c++ diffusionCoefficient(int phaseIdx, int compIIdx, int compJIdx) ```
- __EffectiveDiffusivity(various arguments)__: These values are now defined in the volvars and stored in a container fit to the model. To access these values, use the unified ```c++ effectiveDiffusionCoefficient(int phaseIdx, int compIIdx, int compJIdx) ```
### Deleted classes/files, property names, constants/enums
Everything that has been deprecated before release 3.1 has been removed.
Differences Between DuMu<sup>x</sup> 3.1 and DuMu<sup>x</sup> 3.0
=============================================
### Improvements and Enhancements
- __Examples__: Three extensively documented examples have been added which highlight interesting features and show how to apply DuMu<sup>x</sup> to interesting problems. They can be found in the new folder `examples`. To get an overview, point your browser to https://git.iws.uni-stuttgart.de/dumux-repositories/dumux/tree/master/examples.
- __Porousmediumflow__: Added a new porous medium model for the energy balance of a porous solid (general heat equation).
- __Multidomain__: It is now possible to use the facet coupling module together with the mpfa-o scheme in the bulk domain.
- __Box__: The box scheme works now on grids with prism / wedge elements in 3D.
- __Diffusive fluxes__: We revised the formulation of the diffusion laws to allow for changes between mass-averaged velocity reference systems and molar-averaged velocity reference systems. The standard formulation is now set to mass-averaged velocity reference systems.
- __GridManager__:
* Supports now reading unstructured grids and data from vtu/vtp files (ASCII, XML format) sequential.
For UGGrid and FoamGrid you can specify a grid in such a format in the input file:
`Grid.File = mygrid.vtu` / `Grid.File = mygrid.vtp`. The associated data is then available in the grid data object.
* Instead of always including all grid manager specializations you can now only include the specialization that you need.
For example, if you only use YaspGrid in your code, you only need to include `dumux/io/grid/gridmanager_yasp.hh`. The
convenience header `dumux/io/grid/gridmanager.hh` still includes all specializations.
* Added a `NetPBMReader` which allows to read simple raster images files (`*.pbm` and `*.pgm`). Can be used, e.g., with
`dune-subgrid` in order to create a grid from an image file.
- __Freeflow__: A second order approximation of the convective term of all Navier-Stokes based models is now available.
This can be enabled using the property `UpwindSchemeOrder`. This property defaults to a first order upwinding approximation,
which is the method used for all models in release 3.0. If this property is set to `2`, a second order flux limiter method will be used.
Various flux limiter functions have been implemented to maintain the monotonicity of this discretization. Per default the
`Minmod` flux limiter is used, but `Vanleer`, `Vanalbada`, `Superbee`, `Umist`, `Mclimiter`, and `Wahyd` based flux limiters
are also available. These can be specified using the input file entry `Flux.DifferencingScheme`. These methods are also
implemented for non-uniform structured grids (e.g. YaspGrid - TensorProductCoordinates). Per default, a scheme assuming a
uniform grid is used, but two other methods, `Li` and `Hou`, are both available for adaptations to non-uniform grids.
These can be specified using the input file entry `Flux.TVDApproach`.
- __RANS__: The called RANS model, defined in the properties system, will specify, via the model traits,
which RANS problem implementation should be used. In each problem file, the initial and boundary conditions can be
set using templated functions based on the model type. Examples of these functions exist in the RANS based tests.
No further preprocessor macros are required.
- __ShallowWater__: Thanks to Leopold Stadler we now have a shallow water equations solver / model. Have a look at freeflow/shallowwater and give it a try with the dam break test at test/freeflow/shallowwater. The are also some friction laws computing shear stresses (Manning, Nikuradse) to account for friction in a channel/river bed, thanks to Martin Utz.
- __Staggered__: Added a `StaggeredNewtonConvergenceWriter` for the staggered grid discretization scheme.
- __Solver__: There is a new abstract base class `PDESolver` that is a class that does linearize & assemble, solve and update.
The NewtonSolver now derives from this class (interface is unchanged). A new class `LinearPDESolver` simplifies solving linear problems
by reducing the code in the main file and streamlining the terminal output to look like the Newton output.
### Immediate interface changes not allowing/requiring a deprecation period
- `NewtonConvergenceWriter`'s first template argument has changed from `GridView` to `FVGridGeometry`. This allows to call the `resize()` method after a grid change without any arguments.
Here is an example how to instantiate the convergence writer:
```
using NewtonConvergenceWriter = Dumux::NewtonConvergenceWriter<FVGridGeometry, SolutionVector>;
auto convergenceWriter = std::make_shared<NewtonConvergenceWriter>(*fvGridGeometry);
```
- The interface of the abstract `TimeLoopBase` class has been extended by `virtual void advanceTimeStep()`, `virtual void setTimeStepSize(Scalar dt)`,
`virtual Scalar maxTimeStepSize()`, and `virtual bool finished()`, thus forcing the inheriting classes to implement those functions.
`TimeLoop` is no longer a template argument in `NewtonSolver`'s `solve()` method, thereby increasing
type safety and providing better compiler error messages.
- __RANS__: The base problems for all turbulence models e.g. `ZeroEqProblem` have been been renamed to one generic `RANSProblem`
### Deprecated properties, to be removed after 3.1:
- `FVGridGeometry` and `EnableFVGridGeometryCache` have been replaced by
`GridGeometry` and `EnableGridGeometryCache`.
Unfortunately, clang doesn't emit deprecation warnings if an old property name is
used. Consider employing gcc for detecting occurrences of the old name.
- `BaseFVGridGeometry` from `dumux/discretization`. Use `BaseGridGeometry` instead.
- `CakeGridCreator` and `SubgridGridCreator` from `dumux/io/grid`. Use the corresponding `...Manager` instead.
- `IntRange` from `dumux/common`. Use `Dune::IntegralRange` instead.
### Deprecated member functions, to be removed after 3.1:
- The convergence writer is no longer passed to `NewtonSolver`'s `solve()` method.
For outputting convergence data, please use `newtonSolver.attachConvergenceWriter(convWriter)` in `main.cc` (directly after instantiating the writer).
To stop the output, the writer can also be detached again using `newtonSolver.detachConvergenceWriter()`.
### Deleted classes/files, property names, constants/enums
- Deprecated classes and files for the 3.0 release listed below stay deprecated
for at least one more release cycle.
Differences Between DuMu<sup>x</sup> 2.12 and DuMu<sup>x</sup> 3.0
=============================================
- DuMu<sup>x</sup> 3.0 is a major version update. It is not backward compatible in all aspects to 2.12.
The following minor version updates will be, as before for the DuMu<sup>x</sup> 2-series, always backward compatible
to at least the last minor version update.
- The tutorial has been replaced by the new module `dumux-course` which is
accessible at https://git.iws.uni-stuttgart.de/dumux-repositories/dumux-course.
We recommend new users and also users experienced with DuMu<sup>x</sup> 2.X to clone
the course and have a look at the exercises in there.
- DuMu<sup>x</sup> 3.0 is based on Dune 2.6 and is expected to run with the current Dune master.
We will try to keep the compatibility with the Dune master
as long as it is technically feasible and our resources allow it.
- DuMu<sup>x</sup> 3.0 requires at least GCC 4.9 or Clang 3.5 in their C++-14 mode.
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
However, we suggest to use newer compiler versions, as we cannot test against all previous compiler versions.
- For employing corner-point grids by means of opm-grid, the OPM release 2018.10 has to be used.
## Improvements and Enhancements
### General
- __New style main files:__ 3.0 comes which a major overhaul of how the sequence of simulation steps is specified.
Until 2.12 there was the start.hh header including the free function `start` that contained a predefined sequence of
steps. Customization of the sequence was possible by many hooks implemented in classes used in this sequence. This
made it hard to follow the course of the program and hard to implement customization at points where this was not previously envisioned.
In contrast, in the new approach the sequence of simulation steps was linearized, meaning that each step is visible
in the program's main file. In the new main files, one can clearly see the io, initialization, assembly, solving, update, time loop, etc.,
of the program. Many parts of the simulation that were previously mandatory, i.e. simulations in 2.12 always contained a time loop,
are now optional (stationary simulations just don't need a time loop). The new style main files make it easier two follow the course
of the program, are easier to customize, and offer more flexibility concerning the customization of steps and components of a simulation.
All tests and examples in the dumux repository have been adapted to the new style main files.
- __Property system:__ The property system is now usable without preprocessor macros. To this end it was completely reimplemented using C++14 techniques and
variadic templates. The hierarchies can now be arbitrarily deep instead of being limited to 5 levels. The new implementation does not use
C++ inheritance. Properties and TypeTag now have to be properly qualified with the namespaces `Properties::`, `TTag::`. Types that share the
name with properties have to properly qualified with the `Dumux::` namespace. This update makes it hopefully more readable
and removes the "magic" part from the property system.
- __Runtime parameters:__ Runtime parameters are no longer accessed with preprocessor macros. They have been replaced by C++ function templates
`Dumux::getParam`, `Dumux::hasParam`, `Dumux::getParamFromGroup`. The `..FromGroup` version has been redesigned to allow the specification
of parameters for different models in one input file. The concept of a parameter group string was extended to make it possible to
use a single input file for complex multidomain simulation setups.
- __Restarting simulations:__ The old restart module was replaced by an implementation based on a VTK backend (other formats might be added later such as HDF5).
Restarted simulations can read solutions from vtk files. For parallel runs, there is currently the restriction that the number of processors has to be the same
as before the restart. Restarted simulations can read grids from vtk (currently only sequential, non-adaptive grids, support for parallel and adaptive
will be added in a future version).
- __Assembly__: The assembler can now assemble implicit and explicit Euler time discretizations. An interface for implementing analytical Jacobians was added.
The CCTpfa assembler has been significantly improved for complex models that spend a lot of time computing constitutive laws. Also the numerical
differentiation scheme was improved by altering the order in which derivatives are computed.
- __TypeTag templates:__ Implementers of code in DuMu<sup>x</sup> 3.0 are advised to avoid TypeTag as a template argument for class templates.
Many classes in the DuMu<sup>x</sup> core have been changed to have a small number of specific template arguments, including `GridGeometry`,
`TimeLoop`, `Newton`, `LinearSolver`, `SpatialParams`. This makes it possible to share objects of these types between models using
different TypeTags. This was not possible before as `Class<TypeTag1>` and `Class<TypeTag2>` are different types, even if they contain
exactly the same implementation code.
Furthermore, having TypeTag as a template argument leads to bad programming, and unnecessary dependencies that should be avoided in
every object-oriented code.
- __The grid geometry concept:__ In version 3.0, discretization methods use grid geometries which are wrappers or adapters around a `Dune::GridView`,
providing data structures and interfaces necessary to implement these discretization methods easily. In particular, the
abstraction of sub-control-volumes (scv) and sub-control-volume-faces (scvf) are now separate classes and the grid geometry provides means to iterate
over all scvs and scvfs of an element, using range-based-for loops.
- __The caching concept:__ Version 3.0 introduces a caching concept for the new grid geometry, the volume variables and the flux variables.
There are classes with a `Grid` prefix, that store data for the current grid view, and classes with the `Element` prefix that store data locally
for an element or element stencil. Depending on the caching concept used, data will be either stored completely in the `Grid` objects
(e.g. `GridGeometry`) and the `Element` objects (e.g. `ElementGeometry`) are mere accessor objects, or, data will be partly only cached locally.
Local caching uses less memory but might result in an increased runtime. Grid caching is memory intensive
but can provide a significant run-time speedup. Choose whatever concept fits your available resources,
the default being local caching.
- __Support__ for grid managers `dune-subgrid` (a meta grid selecting only certain elements from a host grid)
and `dune-spgrid` (a structured parallel grid manager, supporting periodic boundaries).
### Models, Physics and Methods
- __MPFA schemes:__ The new design of the DuMu<sup>x</sup> core facilitates the incorporation of new finite-volume schemes. In particular, the new core comes with
a framework for MPFA schemes, in which currently the only available scheme is the MPFA-O scheme. It can be used in conjunction with any DuMu<sup>x</sup> model and
also works on surface grids. More schemes will be added in the future.
- __Box-dfm:__ The `2pdfm` model from version 2.12 has been generalized such that it can be used on any DuMu<sup>x</sup> model and in both two and three dimensions.
- __Tracer transport__: A new model for tracer transport with a given flow field has been added. The model can be also used to implement sequentially
coupled simulations, or iterative solvers where flow and transport are decoupled / weakly coupled.
- __Mineralization__: An adapter model for mineralization has been added and can be used with all porousmediumflow models. A balance for the solid
volume fraction of precipitating, adsorbed, or absorbed substances is added to the existing equations.
- __Solution-dependent spatial params:__ A redesign of the spatial params interface allows now to define spatial parameters such as permeability
and porosity that depend on the solution. This makes it easier to implement mineralization models altering the solid structure of the porous medium.
- __Solid systems:__ DuMu<sup>x</sup> 3.0 introduces solid systems similar to fluid systems but for solid components. This allows a consistent
implementation of mineralization models including reactions, dissolution, precipitation and other processes altering the solid
phase of the porous medium.
- __Multidomain:__ DuMu<sup>x</sup> 3.0 introduces a new multidomain framework which does no longer depend on `dune-multidomain` and can be used for the coupling
of an arbitrary number of subdomains. The sub-domains can be regions in which different sets of equations are solved and/or which have different
dimensionalities. The implementation is such that any of the existing DuMu<sup>x</sup> models can be used in the subdomains, while the data and functionality
required for the coupling of the sub-domains is implemented in a `CouplingManger` class. Three different coupling concepts are available, for which
there are a number of available `CouplingManager` class implementations:
- _Boundary:_ coupling across sub-domain boundaries
- _Embedded:_ Coupling between a bulk domain and an embedded lower-dimensional sub-domain which has an independent grid
- _Facet:_ Coupling between a bulk domain and a codimension-one sub-domain, which is conforming with the element facets of the bulk domain
- __Free-flow models:__ The previous Navier-Stokes model using the box method has been replaced by one that employs a staggered grid discretization.
The new method does not require any stabilization techniques while those were necessary for the box method in order to avoid spurious oscillations.
The free-flow models in DuMu<sup>x</sup> 3.0 consider single phase flow with or without component/energy transport. So far, only regular Cartesian grids are supported
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
but local grid refinement will be added in a future release.
Several RANS models for turbulent flow have been added: k-omega, k-epsilon, low-Re-k-epsilon, one-eq, zero-eq. The RANS models might be subject to further (interface)
changes.
- __Thermal and chemical non-equilibrium:__ The possibility to consider thermal and/or chemical non-equilibrium of several types has been enabled for all
porous medium models.
- __Interface solver:__ For the two-phase flow model in conjunction with the box scheme, an interface solver can now be used to reconstruct the saturations
in the sub-control volumes adjacent to vertices that lie on material discontinuities. This allows a sharper representation of the saturation front evolving
in heterogeneous porous media.
- __Components:__ Components can now derive from different base classes, `Base`, `Liquid`, `Solid`, `Gas`, depending on which
phase states are implemented. This can be used to determine at compile time if a component supports a certain phase state.
- __Tabulation of fluid parameter laws:__ The tabulation of fluid parameter laws has been improved to only tabulate those functions actually used during the
simulation. To this end, the tabulation is done on the first call of a corresponding fluid parameter.
- __MPNC:__ The general m-phase n-component model has been adapted in structure to the other porous medium flow models.
- __Different wettability:__ The 2p models can now model materials with different wettability (hydrophobic, hydrophilic) in different parts of the domain.
- __Maxwell-Stefan-diffusion:__ Most models can now use Maxwell-Stefan diffusion for multi-component diffusion instead of Fickian diffusion.
There are also a few tests demonstrating how to use it.
## Immediate interface changes not allowing/requiring a deprecation period
- Many classes have been completely redesigned. See the numerous example applications included in 3.0 showcasing all new classes.
- The `GridCreator` has been replaced by the `GridManager`, which no longer uses a singleton for the grid object.
This makes it possible to create two grids of the exact same type. The `GridManager` also handles user data provided in grid files.
## Deprecated classes/files, to be removed after 3.0
- All classes of the sequential models are deprecated. The sequential models will be ported to the new structure
of porous medium models (formerly called implicit models). This way sequential and implicit model implementations
no longer differ and use the same numerical infrastructure.
- The `TimeManager` class is to be replaced by the class `TimeLoop`.
- The `VtkMultiWriter` class is to be replaced by the class `VtkOutputModule`.
- The file `start.hh` is replaced by new style main files.
## Deleted classes/files/functions... which have been deprecated in DuMu<sup>x</sup> 2.12
- Everything listed as deprecated below has been removed.
Differences Between DuMu<sup>x</sup> 2.11 and DuMu<sup>x</sup> 2.12
=============================================
* IMPORTANT NOTES:
- DuMu<sup>x</sup> 2.12 is expected to run based on Dune 2.4.1, 2.5, 2.6 and the Dune
master. We will try to keep the compatibility with the Dune master
as long as it is technically feasible and our resources allow it. If
you want to use DuMu<sup>x</sup> multidomain models, you have to stick with the
Dune 2.4 core and specific versions of other modules, see
[test/multidomain/README](test/multidomain/README) for details.
Also the geomechanics models require Dune 2.4 and PDELab 2.0.
- DuMu<sup>x</sup> 2.12 requires at least GCC 4.9 or Clang 3.5 in their C++-14 mode.
- For employing corner-point grids by means of opm-grid (former
dune-cornerpoint), the OPM releases 2017.04 or 2017.10 have to be used.
* IMPROVEMENTS and ENHANCEMENTS:
- Four new tutorial exercises have been added in the folder
[tutorial](tutorial). They can be built by executing
`make build_tutorials` in the build folder. Each exercise
comes with detailed instructions:
1. [Exercise 1](tutorial/ex1/README.md)
2. [Exercise 2](tutorial/ex2/README.md)
3. [Exercise 3](tutorial/ex3/README.md)
4. [Exercise 4](tutorial/ex4/README.md)
- Fixed bug in heatCapacity() of component air and replace
the use of a constant value in gasEnthalpy() by calling