cuvetteproblem.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 This file is part of the Open Porous Media project (OPM).
5
6 OPM 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 2 of the License, or
9 (at your option) any later version.
10
11 OPM 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 OPM. If not, see <http://www.gnu.org/licenses/>.
18
19 Consult the COPYING file in the top-level source directory of this
20 module for the precise wording of the license and the list of
21 copyright holders.
22*/
28#ifndef EWOMS_CUVETTE_PROBLEM_HH
29#define EWOMS_CUVETTE_PROBLEM_HH
30
32
33#include <opm/material/fluidstates/CompositionalFluidState.hpp>
34#include <opm/material/fluidstates/ImmiscibleFluidState.hpp>
35#include <opm/material/fluidsystems/H2OAirMesityleneFluidSystem.hpp>
36#include <opm/material/fluidmatrixinteractions/ThreePhaseParkerVanGenuchten.hpp>
37#include <opm/material/fluidmatrixinteractions/LinearMaterial.hpp>
38#include <opm/material/thermal/ConstantSolidHeatCapLaw.hpp>
39#include <opm/material/thermal/SomertonThermalConductionLaw.hpp>
40#include <opm/material/constraintsolvers/MiscibleMultiPhaseComposition.hpp>
41#include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
42#include <opm/material/common/Valgrind.hpp>
43
44#include <dune/grid/yaspgrid.hh>
45#include <dune/grid/io/file/dgfparser/dgfyasp.hh>
46
47#include <dune/common/version.hh>
48#include <dune/common/fvector.hh>
49#include <dune/common/fmatrix.hh>
50
51#include <string>
52
53namespace Opm {
54template <class TypeTag>
55class CuvetteProblem;
56}
57
58namespace Opm::Properties {
59
60
61// create a new type tag for the cuvette steam injection problem
62namespace TTag {
64}
65
66// Set the grid type
67template<class TypeTag>
68struct Grid<TypeTag, TTag::CuvetteBaseProblem> { using type = Dune::YaspGrid<2>; };
69
70// Set the problem property
71template<class TypeTag>
72struct Problem<TypeTag, TTag::CuvetteBaseProblem> { using type = Opm::CuvetteProblem<TypeTag>; };
73
74// Set the fluid system
75template<class TypeTag>
76struct FluidSystem<TypeTag, TTag::CuvetteBaseProblem>
77{ using type = Opm::H2OAirMesityleneFluidSystem<GetPropType<TypeTag, Properties::Scalar>>; };
78
79// Set the material Law
80template<class TypeTag>
81struct MaterialLaw<TypeTag, TTag::CuvetteBaseProblem>
82{
83private:
86
87 using Traits = Opm::ThreePhaseMaterialTraits<
88 Scalar,
89 /*wettingPhaseIdx=*/FluidSystem::waterPhaseIdx,
90 /*nonWettingPhaseIdx=*/FluidSystem::naplPhaseIdx,
91 /*gasPhaseIdx=*/FluidSystem::gasPhaseIdx,
92 /* hysteresis */ false,
93 /* endpointscaling */ false>;
94
95public:
96 using type = Opm::ThreePhaseParkerVanGenuchten<Traits>;
97};
98
99// set the energy storage law for the solid phase
100template<class TypeTag>
101struct SolidEnergyLaw<TypeTag, TTag::CuvetteBaseProblem>
102{ using type = Opm::ConstantSolidHeatCapLaw<GetPropType<TypeTag, Properties::Scalar>>; };
103
104// Set the thermal conduction law
105template<class TypeTag>
106struct ThermalConductionLaw<TypeTag, TTag::CuvetteBaseProblem>
107{
108private:
111
112public:
113 // define the material law parameterized by absolute saturations
114 using type = Opm::SomertonThermalConductionLaw<FluidSystem, Scalar>;
115};
116
117} // namespace Opm::Properties
118
119namespace Opm {
147template <class TypeTag>
148class CuvetteProblem : public GetPropType<TypeTag, Properties::BaseProblem>
149{
151
156 using ThermalConductionLawParams = GetPropType<TypeTag, Properties::ThermalConductionLawParams>;
165
166 // copy some indices for convenience
168 enum { numPhases = FluidSystem::numPhases };
169 enum { numComponents = FluidSystem::numComponents };
170 enum { waterPhaseIdx = FluidSystem::waterPhaseIdx };
171 enum { naplPhaseIdx = FluidSystem::naplPhaseIdx };
172 enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
173 enum { H2OIdx = FluidSystem::H2OIdx };
174 enum { airIdx = FluidSystem::airIdx };
175 enum { NAPLIdx = FluidSystem::NAPLIdx };
176 enum { conti0EqIdx = Indices::conti0EqIdx };
177
178 // Grid and world dimension
179 enum { dimWorld = GridView::dimensionworld };
180
181 using CoordScalar = typename GridView::ctype;
182 using GlobalPosition = Dune::FieldVector<CoordScalar, dimWorld>;
183 using DimMatrix = Dune::FieldMatrix<Scalar, dimWorld, dimWorld>;
184
185public:
189 explicit CuvetteProblem(Simulator& simulator)
190 : ParentType(simulator)
191 , eps_(1e-6)
192 { }
193
198 {
199 ParentType::finishInit();
200
201 if (Opm::Valgrind::IsRunning())
202 FluidSystem::init(/*minT=*/283.15, /*maxT=*/500.0, /*nT=*/20,
203 /*minp=*/0.8e5, /*maxp=*/2e5, /*np=*/10);
204 else
205 FluidSystem::init(/*minT=*/283.15, /*maxT=*/500.0, /*nT=*/200,
206 /*minp=*/0.8e5, /*maxp=*/2e5, /*np=*/100);
207
208 // intrinsic permeabilities
209 fineK_ = this->toDimMatrix_(6.28e-12);
210 coarseK_ = this->toDimMatrix_(9.14e-10);
211
212 // porosities
213 finePorosity_ = 0.42;
214 coarsePorosity_ = 0.42;
215
216 // parameters for the capillary pressure law
217#if 1
218 // three-phase Parker -- van Genuchten law
219 fineMaterialParams_.setVgAlpha(0.0005);
220 coarseMaterialParams_.setVgAlpha(0.005);
221 fineMaterialParams_.setVgN(4.0);
222 coarseMaterialParams_.setVgN(4.0);
223
224 coarseMaterialParams_.setkrRegardsSnr(true);
225 fineMaterialParams_.setkrRegardsSnr(true);
226
227 // residual saturations
228 fineMaterialParams_.setSwr(0.1201);
229 fineMaterialParams_.setSwrx(0.1201);
230 fineMaterialParams_.setSnr(0.0701);
231 fineMaterialParams_.setSgr(0.0101);
232 coarseMaterialParams_.setSwr(0.1201);
233 coarseMaterialParams_.setSwrx(0.1201);
234 coarseMaterialParams_.setSnr(0.0701);
235 coarseMaterialParams_.setSgr(0.0101);
236#else
237 // linear material law
238 fineMaterialParams_.setPcMinSat(gasPhaseIdx, 0);
239 fineMaterialParams_.setPcMaxSat(gasPhaseIdx, 0);
240 fineMaterialParams_.setPcMinSat(naplPhaseIdx, 0);
241 fineMaterialParams_.setPcMaxSat(naplPhaseIdx, -1000);
242 fineMaterialParams_.setPcMinSat(waterPhaseIdx, 0);
243 fineMaterialParams_.setPcMaxSat(waterPhaseIdx, -10000);
244
245 coarseMaterialParams_.setPcMinSat(gasPhaseIdx, 0);
246 coarseMaterialParams_.setPcMaxSat(gasPhaseIdx, 0);
247 coarseMaterialParams_.setPcMinSat(naplPhaseIdx, 0);
248 coarseMaterialParams_.setPcMaxSat(naplPhaseIdx, -100);
249 coarseMaterialParams_.setPcMinSat(waterPhaseIdx, 0);
250 coarseMaterialParams_.setPcMaxSat(waterPhaseIdx, -1000);
251
252 // residual saturations
253 fineMaterialParams_.setResidSat(waterPhaseIdx, 0.1201);
254 fineMaterialParams_.setResidSat(naplPhaseIdx, 0.0701);
255 fineMaterialParams_.setResidSat(gasPhaseIdx, 0.0101);
256
257 coarseMaterialParams_.setResidSat(waterPhaseIdx, 0.1201);
258 coarseMaterialParams_.setResidSat(naplPhaseIdx, 0.0701);
259 coarseMaterialParams_.setResidSat(gasPhaseIdx, 0.0101);
260#endif
261
262 fineMaterialParams_.finalize();
263 coarseMaterialParams_.finalize();
264
265 // initialize parameters for the thermal conduction law
266 computeThermalCondParams_(thermalCondParams_, finePorosity_);
267
268 // assume constant volumetric heat capacity and granite
269 solidEnergyLawParams_.setSolidHeatCapacity(790.0 // specific heat capacity of granite [J / (kg K)]
270 * 2700.0); // density of granite [kg/m^3]
271 solidEnergyLawParams_.finalize();
272
273 initInjectFluidState_();
274 }
275
279 static void registerParameters()
280 {
281 ParentType::registerParameters();
282
283 Parameters::SetDefault<Parameters::GridFile>("./data/cuvette_11x4.dgf");
284 Parameters::SetDefault<Parameters::EndTime<Scalar>>(100.0);
285 Parameters::SetDefault<Parameters::InitialTimeStepSize<Scalar>>(1.0);
286 Parameters::SetDefault<Parameters::MaxTimeStepSize<Scalar>>(600.0);
287 Parameters::SetDefault<Parameters::EnableGravity>(true);
288 }
289
294
301 { return true; }
302
306 std::string name() const
307 { return std::string("cuvette_") + Model::name(); }
308
313 {
314#ifndef NDEBUG
315 this->model().checkConservativeness();
316
317 // Calculate storage terms
318 EqVector storage;
319 this->model().globalStorage(storage);
320
321 // Write mass balance information for rank 0
322 if (this->gridView().comm().rank() == 0) {
323 std::cout << "Storage: " << storage << std::endl << std::flush;
324 }
325#endif // NDEBUG
326 }
327
329
334
338 template <class Context>
339 Scalar temperature(const Context& /*context*/,
340 unsigned /*spaceIdx*/,
341 unsigned /*timeIdx*/) const
342 { return 293.15; /* [K] */ }
343
347 template <class Context>
348 const DimMatrix& intrinsicPermeability(const Context& context, unsigned spaceIdx,
349 unsigned timeIdx) const
350 {
351 const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
352 if (isFineMaterial_(pos))
353 return fineK_;
354 return coarseK_;
355 }
356
360 template <class Context>
361 Scalar porosity(const Context& context, unsigned spaceIdx, unsigned timeIdx) const
362 {
363 const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
364 if (isFineMaterial_(pos))
365 return finePorosity_;
366 else
367 return coarsePorosity_;
368 }
369
373 template <class Context>
374 const MaterialLawParams& materialLawParams(const Context& context,
375 unsigned spaceIdx, unsigned timeIdx) const
376 {
377 const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
378 if (isFineMaterial_(pos))
379 return fineMaterialParams_;
380 else
381 return coarseMaterialParams_;
382 }
383
387 template <class Context>
388 const ThermalConductionLawParams &
389 thermalConductionParams(const Context& /*context*/,
390 unsigned /*spaceIdx*/,
391 unsigned /*timeIdx*/) const
392 { return thermalCondParams_; }
393
395
400
404 template <class Context>
405 void boundary(BoundaryRateVector& values, const Context& context,
406 unsigned spaceIdx, unsigned timeIdx) const
407 {
408 const auto& pos = context.pos(spaceIdx, timeIdx);
409
410 if (onRightBoundary_(pos)) {
411 Opm::CompositionalFluidState<Scalar, FluidSystem> fs;
412
413 initialFluidState_(fs, context, spaceIdx, timeIdx);
414
415 values.setFreeFlow(context, spaceIdx, timeIdx, fs);
416 values.setNoFlow();
417 }
418 else if (onLeftBoundary_(pos)) {
419 // injection
420 RateVector molarRate;
421
422 // inject with the same composition as the gas phase of
423 // the injection fluid state
424 Scalar molarInjectionRate = 0.3435; // [mol/(m^2 s)]
425 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
426 molarRate[conti0EqIdx + compIdx] =
427 -molarInjectionRate
428 * injectFluidState_.moleFraction(gasPhaseIdx, compIdx);
429
430 // calculate the total mass injection rate [kg / (m^2 s)
431 Scalar massInjectionRate =
432 molarInjectionRate
433 * injectFluidState_.averageMolarMass(gasPhaseIdx);
434
435 // set the boundary rate vector [J / (m^2 s)]
436 values.setMolarRate(molarRate);
437 values.setEnthalpyRate(-injectFluidState_.enthalpy(gasPhaseIdx) * massInjectionRate);
438 }
439 else
440 values.setNoFlow();
441 }
442
444
449
453 template <class Context>
454 void initial(PrimaryVariables& values, const Context& context, unsigned spaceIdx,
455 unsigned timeIdx) const
456 {
457 Opm::CompositionalFluidState<Scalar, FluidSystem> fs;
458
459 initialFluidState_(fs, context, spaceIdx, timeIdx);
460
461 const auto& matParams = materialLawParams(context, spaceIdx, timeIdx);
462 values.assignMassConservative(fs, matParams, /*inEquilibrium=*/false);
463 }
464
471 template <class Context>
472 void source(RateVector& rate,
473 const Context& /*context*/,
474 unsigned /*spaceIdx*/,
475 unsigned /*timeIdx*/) const
476 { rate = Scalar(0.0); }
477
479
480private:
481 bool onLeftBoundary_(const GlobalPosition& pos) const
482 { return pos[0] < eps_; }
483
484 bool onRightBoundary_(const GlobalPosition& pos) const
485 { return pos[0] > this->boundingBoxMax()[0] - eps_; }
486
487 bool onLowerBoundary_(const GlobalPosition& pos) const
488 { return pos[1] < eps_; }
489
490 bool onUpperBoundary_(const GlobalPosition& pos) const
491 { return pos[1] > this->boundingBoxMax()[1] - eps_; }
492
493 bool isContaminated_(const GlobalPosition& pos) const
494 {
495 return (0.20 <= pos[0]) && (pos[0] <= 0.80) && (0.4 <= pos[1])
496 && (pos[1] <= 0.65);
497 }
498
499 bool isFineMaterial_(const GlobalPosition& pos) const
500 {
501 if (0.13 <= pos[0] && 1.20 >= pos[0] && 0.32 <= pos[1] && pos[1] <= 0.57)
502 return true;
503 else if (pos[1] <= 0.15 && 1.20 <= pos[0])
504 return true;
505 else
506 return false;
507 }
508
509 template <class FluidState, class Context>
510 void initialFluidState_(FluidState& fs, const Context& context,
511 unsigned spaceIdx, unsigned timeIdx) const
512 {
513 const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
514
515 fs.setTemperature(293.0 /*[K]*/);
516
517 Scalar pw = 1e5;
518
519 if (isContaminated_(pos)) {
520 fs.setSaturation(waterPhaseIdx, 0.12);
521 fs.setSaturation(naplPhaseIdx, 0.07);
522 fs.setSaturation(gasPhaseIdx, 1 - 0.12 - 0.07);
523
524 // set the capillary pressures
525 const auto& matParams = materialLawParams(context, spaceIdx, timeIdx);
526 Scalar pc[numPhases];
527 MaterialLaw::capillaryPressures(pc, matParams, fs);
528 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
529 fs.setPressure(phaseIdx, pw + (pc[phaseIdx] - pc[waterPhaseIdx]));
530
531 // compute the phase compositions
532 using MMPC = Opm::MiscibleMultiPhaseComposition<Scalar, FluidSystem>;
533 typename FluidSystem::template ParameterCache<Scalar> paramCache;
534 MMPC::solve(fs, paramCache, /*setViscosity=*/true, /*setEnthalpy=*/true);
535 }
536 else {
537 fs.setSaturation(waterPhaseIdx, 0.12);
538 fs.setSaturation(gasPhaseIdx, 1 - fs.saturation(waterPhaseIdx));
539 fs.setSaturation(naplPhaseIdx, 0);
540
541 // set the capillary pressures
542 const auto& matParams = materialLawParams(context, spaceIdx, timeIdx);
543 Scalar pc[numPhases];
544 MaterialLaw::capillaryPressures(pc, matParams, fs);
545 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
546 fs.setPressure(phaseIdx, pw + (pc[phaseIdx] - pc[waterPhaseIdx]));
547
548 // compute the phase compositions
549 using MMPC = Opm::MiscibleMultiPhaseComposition<Scalar, FluidSystem>;
550 typename FluidSystem::template ParameterCache<Scalar> paramCache;
551 MMPC::solve(fs, paramCache, /*setViscosity=*/true, /*setEnthalpy=*/true);
552
553 // set the contaminant mole fractions to zero. this is a little bit hacky...
554 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
555 fs.setMoleFraction(phaseIdx, NAPLIdx, 0.0);
556
557 if (phaseIdx == naplPhaseIdx)
558 continue;
559
560 Scalar sumx = 0;
561 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
562 sumx += fs.moleFraction(phaseIdx, compIdx);
563
564 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
565 fs.setMoleFraction(phaseIdx, compIdx,
566 fs.moleFraction(phaseIdx, compIdx) / sumx);
567 }
568 }
569 }
570
571 void computeThermalCondParams_(ThermalConductionLawParams& params, Scalar poro)
572 {
573 Scalar lambdaGranite = 2.8; // [W / (K m)]
574
575 // create a Fluid state which has all phases present
576 Opm::ImmiscibleFluidState<Scalar, FluidSystem> fs;
577 fs.setTemperature(293.15);
578 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
579 fs.setPressure(phaseIdx, 1.0135e5);
580 }
581
582 typename FluidSystem::template ParameterCache<Scalar> paramCache;
583 paramCache.updateAll(fs);
584 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
585 Scalar rho = FluidSystem::density(fs, paramCache, phaseIdx);
586 fs.setDensity(phaseIdx, rho);
587 }
588
589 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
590 Scalar lambdaSaturated;
591 if (FluidSystem::isLiquid(phaseIdx)) {
592 Scalar lambdaFluid = FluidSystem::thermalConductivity(fs, paramCache, phaseIdx);
593 lambdaSaturated =
594 std::pow(lambdaGranite, (1 - poro))
595 +
596 std::pow(lambdaFluid, poro);
597 }
598 else
599 lambdaSaturated = std::pow(lambdaGranite, (1 - poro));
600
601 params.setFullySaturatedLambda(phaseIdx, lambdaSaturated);
602 if (!FluidSystem::isLiquid(phaseIdx))
603 params.setVacuumLambda(lambdaSaturated);
604 }
605 }
606
607 void initInjectFluidState_()
608 {
609 injectFluidState_.setTemperature(383.0); // [K]
610 injectFluidState_.setPressure(gasPhaseIdx, 1e5); // [Pa]
611 injectFluidState_.setSaturation(gasPhaseIdx, 1.0); // [-]
612
613 Scalar xgH2O = 0.417;
614 injectFluidState_.setMoleFraction(gasPhaseIdx, H2OIdx, xgH2O); // [-]
615 injectFluidState_.setMoleFraction(gasPhaseIdx, airIdx, 1 - xgH2O); // [-]
616 injectFluidState_.setMoleFraction(gasPhaseIdx, NAPLIdx, 0.0); // [-]
617
618 // set the specific enthalpy of the gas phase
619 typename FluidSystem::template ParameterCache<Scalar> paramCache;
620 paramCache.updatePhase(injectFluidState_, gasPhaseIdx);
621
622 Scalar h = FluidSystem::enthalpy(injectFluidState_, paramCache, gasPhaseIdx);
623 injectFluidState_.setEnthalpy(gasPhaseIdx, h);
624 }
625
626 DimMatrix fineK_;
627 DimMatrix coarseK_;
628
629 Scalar finePorosity_;
630 Scalar coarsePorosity_;
631
632 MaterialLawParams fineMaterialParams_;
633 MaterialLawParams coarseMaterialParams_;
634
635 ThermalConductionLawParams thermalCondParams_;
636 SolidEnergyLawParams solidEnergyLawParams_;
637
638 Opm::CompositionalFluidState<Scalar, FluidSystem> injectFluidState_;
639
640 const Scalar eps_;
641};
642} // namespace Opm
643
644#endif
Non-isothermal three-phase gas injection problem where a hot gas is injected into a unsaturated porou...
Definition: cuvetteproblem.hh:149
Scalar temperature(const Context &, unsigned, unsigned) const
Definition: cuvetteproblem.hh:339
void boundary(BoundaryRateVector &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Evaluate the boundary conditions for a boundary segment.
Definition: cuvetteproblem.hh:405
static void registerParameters()
Definition: cuvetteproblem.hh:279
CuvetteProblem(Simulator &simulator)
Definition: cuvetteproblem.hh:189
const MaterialLawParams & materialLawParams(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:374
void initial(PrimaryVariables &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Evaluate the initial value for a control volume.
Definition: cuvetteproblem.hh:454
const DimMatrix & intrinsicPermeability(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:348
const ThermalConductionLawParams & thermalConductionParams(const Context &, unsigned, unsigned) const
Definition: cuvetteproblem.hh:389
Scalar porosity(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:361
void finishInit()
Called by the Opm::Simulator in order to initialize the problem.
Definition: cuvetteproblem.hh:197
std::string name() const
The problem name.
Definition: cuvetteproblem.hh:306
void endTimeStep()
Called by the simulator after each time integration.
Definition: cuvetteproblem.hh:312
bool shouldWriteRestartFile() const
Returns true if a restart file should be written to disk.
Definition: cuvetteproblem.hh:300
void source(RateVector &rate, const Context &, unsigned, unsigned) const
Evaluate the source term for all phases within a given sub-control-volume.
Definition: cuvetteproblem.hh:472
Definition: blackoilmodel.hh:79
Definition: blackoilbioeffectsmodules.hh:43
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:233
Declares the properties required for the compositional multi-phase primary variable switching model.
Opm::H2OAirMesityleneFluidSystem< GetPropType< TypeTag, Properties::Scalar > > type
Definition: cuvetteproblem.hh:77
The fluid systems including the information about the phases.
Definition: multiphasebaseproperties.hh:79
Dune::YaspGrid< 2 > type
Definition: cuvetteproblem.hh:68
The type of the DUNE grid.
Definition: basicproperties.hh:100
Opm::ThreePhaseParkerVanGenuchten< Traits > type
Definition: cuvetteproblem.hh:96
The material law which ought to be used (extracted from the spatial parameters)
Definition: multiphasebaseproperties.hh:55
The type of the problem.
Definition: fvbaseproperties.hh:81
Opm::ConstantSolidHeatCapLaw< GetPropType< TypeTag, Properties::Scalar > > type
Definition: cuvetteproblem.hh:102
The material law for the energy stored in the solid matrix.
Definition: multiphasebaseproperties.hh:63
Definition: cuvetteproblem.hh:63
Opm::SomertonThermalConductionLaw< FluidSystem, Scalar > type
Definition: cuvetteproblem.hh:114
The material law for thermal conduction.
Definition: multiphasebaseproperties.hh:71