3.3.0
DUNE for Multi-{Phase, Component, Scale, Physics, ...} flow and transport in porous media
geomechanics/poroelastic/couplingmanager.hh
Go to the documentation of this file.
1// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2// vi: set et ts=4 sw=4 sts=4:
3/*****************************************************************************
4 * See the file COPYING for full copying permissions. *
5 * *
6 * This program is free software: you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License as published by *
8 * the Free Software Foundation, either version 3 of the License, or *
9 * (at your option) any later version. *
10 * *
11 * This program is distributed in the hope that it will be useful, *
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14 * GNU General Public License for more details. *
15 * *
16 * You should have received a copy of the GNU General Public License *
17 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
18 *****************************************************************************/
25#ifndef DUMUX_POROMECHANICS_COUPLING_MANAGER_HH
26#define DUMUX_POROMECHANICS_COUPLING_MANAGER_HH
27
28#include <algorithm>
29#include <type_traits>
30
35
36namespace Dumux {
37
51template< class MDTraits,
52 std::size_t PMFlowId = 0,
53 std::size_t PoroMechId = PMFlowId+1 >
54class PoroMechanicsCouplingManager : public virtual CouplingManager< MDTraits >
55{
57
58 // the sub-domain type tags
59 template<std::size_t id> using SubDomainTypeTag = typename MDTraits::template SubDomain<id>::TypeTag;
60
61 // further types specific to the sub-problems
62 template<std::size_t id> using Scalar = GetPropType<SubDomainTypeTag<id>, Properties::Scalar>;
63 template<std::size_t id> using Problem = GetPropType<SubDomainTypeTag<id>, Properties::Problem>;
64 template<std::size_t id> using LocalResidual = GetPropType<SubDomainTypeTag<id>, Properties::LocalResidual>;
65 template<std::size_t id> using GridVariables = GetPropType<SubDomainTypeTag<id>, Properties::GridVariables>;
66 template<std::size_t id> using PrimaryVariables = typename GridVariables<id>::PrimaryVariables;
67 template<std::size_t id> using GridVolumeVariables = typename GridVariables<id>::GridVolumeVariables;
68 template<std::size_t id> using ElementVolumeVariables = typename GridVolumeVariables<id>::LocalView;
69 template<std::size_t id> using VolumeVariables = typename GridVolumeVariables<id>::VolumeVariables;
70 template<std::size_t id> using GridGeometry = typename GridVariables<id>::GridGeometry;
71 template<std::size_t id> using FVElementGeometry = typename GridGeometry<id>::LocalView;
72 template<std::size_t id> using GridView = typename GridGeometry<id>::GridView;
73 template<std::size_t id> using GridIndexType = typename GridView<id>::IndexSet::IndexType;
74 template<std::size_t id> using Element = typename GridView<id>::template Codim<0>::Entity;
75 template<std::size_t id> using GlobalPosition = typename Element<id>::Geometry::GlobalCoordinate;
76
78 static_assert(std::is_same< GridView<PMFlowId>, GridView<PoroMechId> >::value,
79 "The grid types of the two sub-problems have to be equal!");
80
82 static_assert(GridGeometry<PoroMechId>::discMethod == DiscretizationMethod::box,
83 "Poro-mechanical problem must be discretized with the box scheme for this coupling manager!");
84
85 static_assert(GridGeometry<PMFlowId>::discMethod == DiscretizationMethod::cctpfa ||
86 GridGeometry<PMFlowId>::discMethod == DiscretizationMethod::ccmpfa,
87 "Porous medium flow problem must be discretized with a cell-centered scheme for this coupling manager!");
88
90 static_assert(!getPropValue<SubDomainTypeTag<PMFlowId>, Properties::EnableGridVolumeVariablesCache>(),
91 "Poromechanics framework does not yet work for enabled grid volume variables caching");
92
94 template<std::size_t id>
95 using CouplingIndexType = typename std::conditional< id == PMFlowId,
96 GridIndexType<PoroMechId>,
97 GridIndexType<PMFlowId> >::type;
98
104 struct PoroMechanicsCouplingContext
105 {
106 // We need unique ptrs because the local views have no default constructor
107 Element<PMFlowId> pmFlowElement;
108 std::unique_ptr< FVElementGeometry<PMFlowId> > pmFlowFvGeometry;
109 std::unique_ptr< ElementVolumeVariables<PMFlowId> > pmFlowElemVolVars;
110 };
111
112public:
113
114 // export the domain ids
115 static constexpr auto pmFlowId = Dune::index_constant<PMFlowId>();
116 static constexpr auto poroMechId = Dune::index_constant<PoroMechId>();
117
123 template<std::size_t i, std::size_t j = (i == PMFlowId) ? PoroMechId : PMFlowId>
124 using CouplingStencilType = typename std::conditional< i == PMFlowId,
125 std::vector< CouplingIndexType<i> >,
126 std::array< CouplingIndexType<i>, 1> >::type;
127
129 using SolutionVector = typename MDTraits::SolutionVector;
130
138 void init(std::shared_ptr< Problem<PMFlowId> > pmFlowProblem,
139 std::shared_ptr< Problem<PoroMechId> > poroMechanicalProblem,
140 const SolutionVector& curSol)
141 {
142 // set the sub problems
143 this->setSubProblem(pmFlowProblem, pmFlowId);
144 this->setSubProblem(poroMechanicalProblem, poroMechId);
145
146 // copy the solution vector
148 // set up the coupling map pmfow -> poromechanics
149 initializeCouplingMap_();
150 }
151
155 const CouplingStencilType<PMFlowId>& couplingStencil(Dune::index_constant<PMFlowId> pmFlowDomainId,
156 const Element<PMFlowId>& element,
157 Dune::index_constant<PoroMechId> poroMechDomainId) const
158 {
159 return pmFlowCouplingMap_[ this->problem(pmFlowId).gridGeometry().elementMapper().index(element) ];
160 }
161
165 const CouplingStencilType<PoroMechId> couplingStencil(Dune::index_constant<PoroMechId> poroMechDomainId,
166 const Element<PoroMechId>& element,
167 Dune::index_constant<PMFlowId> pmFlowDomainId) const
168 {
169 const auto eIdx = this->problem(pmFlowId).gridGeometry().elementMapper().index(element);
170 return CouplingStencilType<PoroMechId>{ {eIdx} };
171 }
172
175
180 template< class Assembler >
181 void bindCouplingContext(Dune::index_constant<PoroMechId> poroMechDomainId,
182 const Element<PoroMechId>& element,
183 const Assembler& assembler)
184 {
185 // first reset the context
186 poroMechCouplingContext_.pmFlowFvGeometry.reset(nullptr);
187 poroMechCouplingContext_.pmFlowElemVolVars.reset(nullptr);
188
189 // prepare the fvGeometry and the element volume variables
190 // these quantities will be used later to obtain the effective pressure
191 auto fvGeometry = localView( this->problem(pmFlowId).gridGeometry() );
192 auto elemVolVars = localView( assembler.gridVariables(Dune::index_constant<PMFlowId>()).curGridVolVars() );
193
194 fvGeometry.bindElement(element);
195 elemVolVars.bindElement(element, fvGeometry, this->curSol()[Dune::index_constant<PMFlowId>()]);
196
197 poroMechCouplingContext_.pmFlowElement = element;
198 poroMechCouplingContext_.pmFlowFvGeometry = std::make_unique< FVElementGeometry<PMFlowId> >(fvGeometry);
199 poroMechCouplingContext_.pmFlowElemVolVars = std::make_unique< ElementVolumeVariables<PMFlowId> >(elemVolVars);
200 }
201
207 template< class PoroMechLocalAssembler >
208 void updateCouplingContext(Dune::index_constant<PoroMechId> poroMechDomainId,
209 const PoroMechLocalAssembler& poroMechLocalAssembler,
210 Dune::index_constant<PMFlowId> pmFlowDomainId,
211 GridIndexType<PMFlowId> dofIdxGlobalJ,
212 const PrimaryVariables<PMFlowId>& priVarsJ,
213 unsigned int pvIdxJ)
214 {
215 // communicate the deflected pm flow domain primary variable
216 ParentType::updateCouplingContext(poroMechDomainId, poroMechLocalAssembler, pmFlowDomainId, dofIdxGlobalJ, priVarsJ, pvIdxJ);
217
218 // now, update the coupling context (i.e. elemVolVars)
219 const auto& element = poroMechCouplingContext_.pmFlowElement;
220 const auto& fvGeometry = *poroMechCouplingContext_.pmFlowFvGeometry;
221 poroMechCouplingContext_.pmFlowElemVolVars->bindElement(element, fvGeometry, this->curSol()[pmFlowDomainId]);
222 }
223
230 template< class PoroMechLocalAssembler >
231 void updateCouplingContext(Dune::index_constant<PoroMechId> poroMechDomainIdI,
232 const PoroMechLocalAssembler& poroMechLocalAssembler,
233 Dune::index_constant<PoroMechId> poroMechDomainIdJ,
234 GridIndexType<PoroMechId> dofIdxGlobalJ,
235 const PrimaryVariables<PoroMechId>& priVarsJ,
236 unsigned int pvIdxJ)
237 {
238 // communicate the deflected displacement
239 ParentType::updateCouplingContext(poroMechDomainIdI, poroMechLocalAssembler, poroMechDomainIdJ, dofIdxGlobalJ, priVarsJ, pvIdxJ);
240
241 // now, update the coupling context (i.e. elemVolVars)
242 (*poroMechCouplingContext_.pmFlowElemVolVars).bindElement(poroMechCouplingContext_.pmFlowElement,
243 *poroMechCouplingContext_.pmFlowFvGeometry,
244 this->curSol()[Dune::index_constant<PMFlowId>()]);
245 }
246
251 template< std::size_t j, class PMFlowLocalAssembler >
252 void updateCouplingContext(Dune::index_constant<PMFlowId> pmFlowDomainId,
253 const PMFlowLocalAssembler& pmFlowLocalAssembler,
254 Dune::index_constant<j> domainIdJ,
255 GridIndexType<j> dofIdxGlobalJ,
256 const PrimaryVariables<j>& priVarsJ,
257 unsigned int pvIdxJ)
258 {
259 // communicate the deflected displacement
260 ParentType::updateCouplingContext(pmFlowDomainId, pmFlowLocalAssembler, domainIdJ, dofIdxGlobalJ, priVarsJ, pvIdxJ);
261 }
262
265
271 template< class PMFlowLocalAssembler, class UpdatableFluxVarCache >
272 void updateCoupledVariables(Dune::index_constant<PMFlowId> pmFlowDomainId,
273 const PMFlowLocalAssembler& pmFlowLocalAssembler,
274 ElementVolumeVariables<PMFlowId>& elemVolVars,
275 UpdatableFluxVarCache& elemFluxVarsCache)
276 {
277 // update the element volume variables to obtain the updated porosity/permeability
278 elemVolVars.bind(pmFlowLocalAssembler.element(),
279 pmFlowLocalAssembler.fvGeometry(),
280 this->curSol()[pmFlowDomainId]);
281
282 // update the transmissibilities subject to the new permeabilities
283 elemFluxVarsCache.update(pmFlowLocalAssembler.element(),
284 pmFlowLocalAssembler.fvGeometry(),
285 elemVolVars);
286 }
287
293 template< class PoroMechLocalAssembler, class UpdatableFluxVarCache >
294 void updateCoupledVariables(Dune::index_constant<PoroMechId> poroMechDomainId,
295 const PoroMechLocalAssembler& poroMechLocalAssembler,
296 ElementVolumeVariables<PoroMechId>& elemVolVars,
297 UpdatableFluxVarCache& elemFluxVarsCache)
298 {
299 elemVolVars.bind(poroMechLocalAssembler.element(),
300 poroMechLocalAssembler.fvGeometry(),
301 this->curSol()[poroMechDomainId]);
302 }
303
310 template< class PMFlowLocalAssembler >
311 typename LocalResidual<PMFlowId>::ElementResidualVector
312 evalCouplingResidual(Dune::index_constant<PMFlowId> pmFlowDomainId,
313 const PMFlowLocalAssembler& pmFlowLocalAssembler,
314 Dune::index_constant<PoroMechId> poroMechDomainId,
315 GridIndexType<PoroMechId> dofIdxGlobalJ)
316 {
317 auto res = pmFlowLocalAssembler.localResidual().evalFluxAndSource(pmFlowLocalAssembler.element(),
318 pmFlowLocalAssembler.fvGeometry(),
319 pmFlowLocalAssembler.curElemVolVars(),
320 pmFlowLocalAssembler.elemFluxVarsCache(),
321 pmFlowLocalAssembler.elemBcTypes());
322
323 // If the residual instationary, evaluate storage
324 if (!pmFlowLocalAssembler.localResidual().isStationary())
325 res += pmFlowLocalAssembler.localResidual().evalStorage(pmFlowLocalAssembler.element(),
326 pmFlowLocalAssembler.fvGeometry(),
327 pmFlowLocalAssembler.prevElemVolVars(),
328 pmFlowLocalAssembler.curElemVolVars());
329
330 return res;
331 }
332
339 template< class PoroMechLocalAssembler >
340 typename LocalResidual<PoroMechId>::ElementResidualVector
341 evalCouplingResidual(Dune::index_constant<PoroMechId> poroMechDomainId,
342 const PoroMechLocalAssembler& poroMechLocalAssembler,
343 Dune::index_constant<PMFlowId> pmFlowDomainId,
344 GridIndexType<PMFlowId> dofIdxGlobalJ)
345 {
346 return poroMechLocalAssembler.localResidual().evalFluxAndSource(poroMechLocalAssembler.element(),
347 poroMechLocalAssembler.fvGeometry(),
348 poroMechLocalAssembler.curElemVolVars(),
349 poroMechLocalAssembler.elemFluxVarsCache(),
350 poroMechLocalAssembler.elemBcTypes());
351 }
352
354 const VolumeVariables<PMFlowId>& getPMFlowVolVars(const Element<PoroMechId>& element) const
355 {
357 const auto eIdx = this->problem(poroMechId).gridGeometry().elementMapper().index(element);
358 return (*poroMechCouplingContext_.pmFlowElemVolVars)[eIdx];
359 }
360
365 const SolutionVector& curSol() const
366 { return ParentType::curSol(); }
367
368private:
374 void initializeCouplingMap_()
375 {
376 // some references for convenience
377 const auto& pmFlowGridGeom = this->problem(pmFlowId).gridGeometry();
378 const auto& poroMechGridGeom = this->problem(poroMechId).gridGeometry();
379
380 // make sure the two grids are really the same. Note that if the two grids
381 // happen to have equal number of elements by chance, we don't detect this source of error.
382 if (pmFlowGridGeom.gridView().size(0) != poroMechGridGeom.gridView().size(0))
383 DUNE_THROW(Dune::InvalidStateException, "The two sub-problems are assumed to operate on the same mesh!");
384
385 pmFlowCouplingMap_.resize(pmFlowGridGeom.gridView().size(0));
386 static constexpr int dim = GridView<PMFlowId>::dimension;
387 for (const auto& element : elements(pmFlowGridGeom.gridView()))
388 {
389 const auto eIdx = pmFlowGridGeom.elementMapper().index(element);
390
391 // firstly, the element couples to the nodal dofs in itself
392 for (int i = 0; i < element.geometry().corners(); ++i)
393 pmFlowCouplingMap_[eIdx].push_back( poroMechGridGeom.vertexMapper().subIndex(element, i , dim) );
394
395 // the pm flow problem couples to the same elements as in its own stencil
396 // due to the dependency of the residual on all permeabilities in its stencil,
397 // which in turn depend on the mechanical deformations.
398 const auto& inverseConnectivity = pmFlowGridGeom.connectivityMap()[eIdx];
399 for (const auto& dataJ : inverseConnectivity)
400 for (int i = 0; i < element.geometry().corners(); ++i)
401 pmFlowCouplingMap_[dataJ.globalJ].push_back( poroMechGridGeom.vertexMapper().subIndex(element, i , dim) );
402 }
403
404 // make stencils unique
405 for (auto& stencil : pmFlowCouplingMap_)
406 {
407 std::sort(stencil.begin(), stencil.end());
408 stencil.erase(std::unique(stencil.begin(), stencil.end()), stencil.end());
409 }
410 }
411
412 // Container for storing the coupling element stencils for the pm flow domain
413 std::vector< CouplingStencilType<PMFlowId> > pmFlowCouplingMap_;
414
415 // the coupling context of the poromechanics domain
416 PoroMechanicsCouplingContext poroMechCouplingContext_;
417};
418
419} //end namespace Dumux
420
421#endif
Element solution classes and factory functions.
free functions for the evaluation of primary variable gradients inside elements.
GridCache::LocalView localView(const GridCache &gridCache)
Free function to get the local view of a grid cache object.
Definition: localview.hh:38
void updateCouplingContext(Dune::index_constant< i > domainI, const LocalAssemblerI &localAssemblerI, Dune::index_constant< j > domainJ, std::size_t dofIdxGlobalJ, const PrimaryVariables< j > &priVarsJ, int pvIdxJ)
updates all data and variables that are necessary to evaluate the residual of the element of domain i...
Definition: multidomain/couplingmanager.hh:152
Definition: adapt.hh:29
typename Properties::Detail::GetPropImpl< TypeTag, Property >::type::type GetPropType
get the type alias defined in the property (equivalent to old macro GET_PROP_TYPE(....
Definition: propertysystem.hh:149
Property to specify the type of scalar values.
Definition: common/properties.hh:43
Property to specify the type of a problem which has to be solved.
Definition: common/properties.hh:57
Definition: common/properties.hh:77
If disabled, the volume variables are not stored (reduces memory, but is slower)
Definition: common/properties.hh:110
The grid variables object managing variable data on the grid (volvars/fluxvars cache)
Definition: common/properties.hh:122
Definition: geomechanics/poroelastic/couplingmanager.hh:55
void bindCouplingContext(Dune::index_constant< PoroMechId > poroMechDomainId, const Element< PoroMechId > &element, const Assembler &assembler)
For the assembly of the element residual of an element of the poro-mechanics domain,...
Definition: geomechanics/poroelastic/couplingmanager.hh:181
typename std::conditional< i==PMFlowId, std::vector< CouplingIndexType< i > >, std::array< CouplingIndexType< i >, 1 > >::type CouplingStencilType
The types used for coupling stencils. An element of the poro-mechanical domain always only couples to...
Definition: geomechanics/poroelastic/couplingmanager.hh:126
void updateCoupledVariables(Dune::index_constant< PoroMechId > poroMechDomainId, const PoroMechLocalAssembler &poroMechLocalAssembler, ElementVolumeVariables< PoroMechId > &elemVolVars, UpdatableFluxVarCache &elemFluxVarsCache)
Update the poro-mechanics volume variables after the coupling context has been updated....
Definition: geomechanics/poroelastic/couplingmanager.hh:294
void updateCoupledVariables(Dune::index_constant< PMFlowId > pmFlowDomainId, const PMFlowLocalAssembler &pmFlowLocalAssembler, ElementVolumeVariables< PMFlowId > &elemVolVars, UpdatableFluxVarCache &elemFluxVarsCache)
Update the porous medium flow domain volume variables and flux variables cache after the coupling con...
Definition: geomechanics/poroelastic/couplingmanager.hh:272
const VolumeVariables< PMFlowId > & getPMFlowVolVars(const Element< PoroMechId > &element) const
Return the porous medium flow variables an element/scv of the poromech domain couples to.
Definition: geomechanics/poroelastic/couplingmanager.hh:354
void updateCouplingContext(Dune::index_constant< PMFlowId > pmFlowDomainId, const PMFlowLocalAssembler &pmFlowLocalAssembler, Dune::index_constant< j > domainIdJ, GridIndexType< j > dofIdxGlobalJ, const PrimaryVariables< j > &priVarsJ, unsigned int pvIdxJ)
We need this overload to avoid ambiguity. However, for the porous medium flow domain weonly have to u...
Definition: geomechanics/poroelastic/couplingmanager.hh:252
static constexpr auto pmFlowId
Definition: geomechanics/poroelastic/couplingmanager.hh:115
void updateCouplingContext(Dune::index_constant< PoroMechId > poroMechDomainIdI, const PoroMechLocalAssembler &poroMechLocalAssembler, Dune::index_constant< PoroMechId > poroMechDomainIdJ, GridIndexType< PoroMechId > dofIdxGlobalJ, const PrimaryVariables< PoroMechId > &priVarsJ, unsigned int pvIdxJ)
After deflection of the solution in the poromechanics domain during element residual assembly in that...
Definition: geomechanics/poroelastic/couplingmanager.hh:231
void updateCouplingContext(Dune::index_constant< PoroMechId > poroMechDomainId, const PoroMechLocalAssembler &poroMechLocalAssembler, Dune::index_constant< PMFlowId > pmFlowDomainId, GridIndexType< PMFlowId > dofIdxGlobalJ, const PrimaryVariables< PMFlowId > &priVarsJ, unsigned int pvIdxJ)
After deflection of the solution in the porous medium flow domain during element residual assembly in...
Definition: geomechanics/poroelastic/couplingmanager.hh:208
LocalResidual< PMFlowId >::ElementResidualVector evalCouplingResidual(Dune::index_constant< PMFlowId > pmFlowDomainId, const PMFlowLocalAssembler &pmFlowLocalAssembler, Dune::index_constant< PoroMechId > poroMechDomainId, GridIndexType< PoroMechId > dofIdxGlobalJ)
Evaluates the coupling element residual of the porous medium flow domain with respect to the poro-mec...
Definition: geomechanics/poroelastic/couplingmanager.hh:312
void init(std::shared_ptr< Problem< PMFlowId > > pmFlowProblem, std::shared_ptr< Problem< PoroMechId > > poroMechanicalProblem, const SolutionVector &curSol)
Initialize the coupling manager.
Definition: geomechanics/poroelastic/couplingmanager.hh:138
const SolutionVector & curSol() const
the solution vector of the coupled problem
Definition: geomechanics/poroelastic/couplingmanager.hh:365
const CouplingStencilType< PoroMechId > couplingStencil(Dune::index_constant< PoroMechId > poroMechDomainId, const Element< PoroMechId > &element, Dune::index_constant< PMFlowId > pmFlowDomainId) const
Return the coupling element stencil for a given poro-mechanical domain element.
Definition: geomechanics/poroelastic/couplingmanager.hh:165
typename MDTraits::SolutionVector SolutionVector
the type of the solution vector
Definition: geomechanics/poroelastic/couplingmanager.hh:129
LocalResidual< PoroMechId >::ElementResidualVector evalCouplingResidual(Dune::index_constant< PoroMechId > poroMechDomainId, const PoroMechLocalAssembler &poroMechLocalAssembler, Dune::index_constant< PMFlowId > pmFlowDomainId, GridIndexType< PMFlowId > dofIdxGlobalJ)
Evaluates the coupling element residual of the poromechanical domain with respect to the porous mediu...
Definition: geomechanics/poroelastic/couplingmanager.hh:341
static constexpr auto poroMechId
Definition: geomechanics/poroelastic/couplingmanager.hh:116
const CouplingStencilType< PMFlowId > & couplingStencil(Dune::index_constant< PMFlowId > pmFlowDomainId, const Element< PMFlowId > &element, Dune::index_constant< PoroMechId > poroMechDomainId) const
Return the coupling stencil for a given porous medium flow domain element.
Definition: geomechanics/poroelastic/couplingmanager.hh:155
Definition: multidomain/couplingmanager.hh:46
void updateCoupledVariables(Dune::index_constant< i > domainI, const LocalAssemblerI &localAssemblerI, UpdatableElementVolVars &elemVolVars, UpdatableFluxVarCache &elemFluxVarsCache)
update variables of domain i that depend on variables in domain j after the coupling context has been...
Definition: multidomain/couplingmanager.hh:177
void setSubProblem(std::shared_ptr< SubProblem > problem, Dune::index_constant< i > domainIdx)
set a pointer to one of the sub problems
Definition: multidomain/couplingmanager.hh:256
const Problem< i > & problem(Dune::index_constant< i > domainIdx) const
Return a reference to the sub problem.
Definition: multidomain/couplingmanager.hh:264
void bindCouplingContext(Dune::index_constant< i > domainI, const Element< i > &elementI, const Assembler &assembler)
prepares all data and variables that are necessary to evaluate the residual of the element of domain ...
Definition: multidomain/couplingmanager.hh:126
SolutionVector & curSol()
the solution vector of the coupled problem
Definition: multidomain/couplingmanager.hh:278
void updateSolution(const SolutionVector &curSol)
Updates the entire solution vector, e.g. before assembly or after grid adaption.
Definition: multidomain/couplingmanager.hh:186
Declares all properties used in Dumux.
The interface of the coupling manager for multi domain problems.