My Project
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
31#include <opm/models/pvs/pvsproperties.hh>
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// Enable gravity
80template<class TypeTag>
81struct EnableGravity<TypeTag, TTag::CuvetteBaseProblem> { static constexpr bool value = true; };
82
83// Set the maximum time step
84template<class TypeTag>
85struct MaxTimeStepSize<TypeTag, TTag::CuvetteBaseProblem>
86{
87 using type = GetPropType<TypeTag, Scalar>;
88 static constexpr type value = 600.;
89};
90
91// Set the material Law
92template<class TypeTag>
93struct MaterialLaw<TypeTag, TTag::CuvetteBaseProblem>
94{
95private:
96 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
97 using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
98
99 using Traits = Opm::ThreePhaseMaterialTraits<
100 Scalar,
101 /*wettingPhaseIdx=*/FluidSystem::waterPhaseIdx,
102 /*nonWettingPhaseIdx=*/FluidSystem::naplPhaseIdx,
103 /*gasPhaseIdx=*/FluidSystem::gasPhaseIdx>;
104
105public:
106 using type = Opm::ThreePhaseParkerVanGenuchten<Traits>;
107};
108
109// set the energy storage law for the solid phase
110template<class TypeTag>
111struct SolidEnergyLaw<TypeTag, TTag::CuvetteBaseProblem>
112{ using type = Opm::ConstantSolidHeatCapLaw<GetPropType<TypeTag, Properties::Scalar>>; };
113
114// Set the thermal conduction law
115template<class TypeTag>
116struct ThermalConductionLaw<TypeTag, TTag::CuvetteBaseProblem>
117{
118private:
119 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
120 using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
121
122public:
123 // define the material law parameterized by absolute saturations
124 using type = Opm::SomertonThermalConductionLaw<FluidSystem, Scalar>;
125};
126
127// The default for the end time of the simulation
128template<class TypeTag>
129struct EndTime<TypeTag, TTag::CuvetteBaseProblem>
130{
131 using type = GetPropType<TypeTag, Scalar>;
132 static constexpr type value = 180;
133};
134
135// The default for the initial time step size of the simulation
136template<class TypeTag>
137struct InitialTimeStepSize<TypeTag, TTag::CuvetteBaseProblem>
138{
139 using type = GetPropType<TypeTag, Scalar>;
140 static constexpr type value = 1;
141};
142
143// The default DGF file to load
144template<class TypeTag>
145struct GridFile<TypeTag, TTag::CuvetteBaseProblem> { static constexpr auto value = "./data/cuvette_11x4.dgf"; };
146
147} // namespace Opm::Properties
148
149namespace Opm {
177template <class TypeTag>
178class CuvetteProblem : public GetPropType<TypeTag, Properties::BaseProblem>
179{
180 using ParentType = GetPropType<TypeTag, Properties::BaseProblem>;
181
182 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
183 using GridView = GetPropType<TypeTag, Properties::GridView>;
184 using MaterialLaw = GetPropType<TypeTag, Properties::MaterialLaw>;
185 using MaterialLawParams = GetPropType<TypeTag, Properties::MaterialLawParams>;
186 using ThermalConductionLawParams = GetPropType<TypeTag, Properties::ThermalConductionLawParams>;
187 using SolidEnergyLawParams = GetPropType<TypeTag, Properties::SolidEnergyLawParams>;
188 using EqVector = GetPropType<TypeTag, Properties::EqVector>;
189 using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
190 using RateVector = GetPropType<TypeTag, Properties::RateVector>;
191 using BoundaryRateVector = GetPropType<TypeTag, Properties::BoundaryRateVector>;
192 using Simulator = GetPropType<TypeTag, Properties::Simulator>;
193 using Model = GetPropType<TypeTag, Properties::Model>;
194 using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
195
196 // copy some indices for convenience
197 using Indices = GetPropType<TypeTag, Properties::Indices>;
198 enum { numPhases = FluidSystem::numPhases };
199 enum { numComponents = FluidSystem::numComponents };
200 enum { waterPhaseIdx = FluidSystem::waterPhaseIdx };
201 enum { naplPhaseIdx = FluidSystem::naplPhaseIdx };
202 enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
203 enum { H2OIdx = FluidSystem::H2OIdx };
204 enum { airIdx = FluidSystem::airIdx };
205 enum { NAPLIdx = FluidSystem::NAPLIdx };
206 enum { conti0EqIdx = Indices::conti0EqIdx };
207
208 // Grid and world dimension
209 enum { dimWorld = GridView::dimensionworld };
210
211 using CoordScalar = typename GridView::ctype;
212 using GlobalPosition = Dune::FieldVector<CoordScalar, dimWorld>;
213 using DimMatrix = Dune::FieldMatrix<Scalar, dimWorld, dimWorld>;
214
215public:
219 CuvetteProblem(Simulator& simulator)
220 : ParentType(simulator)
221 , eps_(1e-6)
222 { }
223
228 {
229 ParentType::finishInit();
230
231 if (Opm::Valgrind::IsRunning())
232 FluidSystem::init(/*minT=*/283.15, /*maxT=*/500.0, /*nT=*/20,
233 /*minp=*/0.8e5, /*maxp=*/2e5, /*np=*/10);
234 else
235 FluidSystem::init(/*minT=*/283.15, /*maxT=*/500.0, /*nT=*/200,
236 /*minp=*/0.8e5, /*maxp=*/2e5, /*np=*/100);
237
238 // intrinsic permeabilities
239 fineK_ = this->toDimMatrix_(6.28e-12);
240 coarseK_ = this->toDimMatrix_(9.14e-10);
241
242 // porosities
243 finePorosity_ = 0.42;
244 coarsePorosity_ = 0.42;
245
246 // parameters for the capillary pressure law
247#if 1
248 // three-phase Parker -- van Genuchten law
249 fineMaterialParams_.setVgAlpha(0.0005);
250 coarseMaterialParams_.setVgAlpha(0.005);
251 fineMaterialParams_.setVgN(4.0);
252 coarseMaterialParams_.setVgN(4.0);
253
254 coarseMaterialParams_.setkrRegardsSnr(true);
255 fineMaterialParams_.setkrRegardsSnr(true);
256
257 // residual saturations
258 fineMaterialParams_.setSwr(0.1201);
259 fineMaterialParams_.setSwrx(0.1201);
260 fineMaterialParams_.setSnr(0.0701);
261 fineMaterialParams_.setSgr(0.0101);
262 coarseMaterialParams_.setSwr(0.1201);
263 coarseMaterialParams_.setSwrx(0.1201);
264 coarseMaterialParams_.setSnr(0.0701);
265 coarseMaterialParams_.setSgr(0.0101);
266#else
267 // linear material law
268 fineMaterialParams_.setPcMinSat(gasPhaseIdx, 0);
269 fineMaterialParams_.setPcMaxSat(gasPhaseIdx, 0);
270 fineMaterialParams_.setPcMinSat(naplPhaseIdx, 0);
271 fineMaterialParams_.setPcMaxSat(naplPhaseIdx, -1000);
272 fineMaterialParams_.setPcMinSat(waterPhaseIdx, 0);
273 fineMaterialParams_.setPcMaxSat(waterPhaseIdx, -10000);
274
275 coarseMaterialParams_.setPcMinSat(gasPhaseIdx, 0);
276 coarseMaterialParams_.setPcMaxSat(gasPhaseIdx, 0);
277 coarseMaterialParams_.setPcMinSat(naplPhaseIdx, 0);
278 coarseMaterialParams_.setPcMaxSat(naplPhaseIdx, -100);
279 coarseMaterialParams_.setPcMinSat(waterPhaseIdx, 0);
280 coarseMaterialParams_.setPcMaxSat(waterPhaseIdx, -1000);
281
282 // residual saturations
283 fineMaterialParams_.setResidSat(waterPhaseIdx, 0.1201);
284 fineMaterialParams_.setResidSat(naplPhaseIdx, 0.0701);
285 fineMaterialParams_.setResidSat(gasPhaseIdx, 0.0101);
286
287 coarseMaterialParams_.setResidSat(waterPhaseIdx, 0.1201);
288 coarseMaterialParams_.setResidSat(naplPhaseIdx, 0.0701);
289 coarseMaterialParams_.setResidSat(gasPhaseIdx, 0.0101);
290#endif
291
292 fineMaterialParams_.finalize();
293 coarseMaterialParams_.finalize();
294
295 // initialize parameters for the thermal conduction law
296 computeThermalCondParams_(thermalCondParams_, finePorosity_);
297
298 // assume constant volumetric heat capacity and granite
299 solidEnergyLawParams_.setSolidHeatCapacity(790.0 // specific heat capacity of granite [J / (kg K)]
300 * 2700.0); // density of granite [kg/m^3]
301 solidEnergyLawParams_.finalize();
302
303 initInjectFluidState_();
304 }
305
310
317 { return true; }
318
322 std::string name() const
323 { return std::string("cuvette_") + Model::name(); }
324
329 {
330#ifndef NDEBUG
331 this->model().checkConservativeness();
332
333 // Calculate storage terms
334 EqVector storage;
335 this->model().globalStorage(storage);
336
337 // Write mass balance information for rank 0
338 if (this->gridView().comm().rank() == 0) {
339 std::cout << "Storage: " << storage << std::endl << std::flush;
340 }
341#endif // NDEBUG
342 }
343
345
350
354 template <class Context>
355 Scalar temperature(const Context& /*context*/,
356 unsigned /*spaceIdx*/,
357 unsigned /*timeIdx*/) const
358 { return 293.15; /* [K] */ }
359
363 template <class Context>
364 const DimMatrix& intrinsicPermeability(const Context& context, unsigned spaceIdx,
365 unsigned timeIdx) const
366 {
367 const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
368 if (isFineMaterial_(pos))
369 return fineK_;
370 return coarseK_;
371 }
372
376 template <class Context>
377 Scalar porosity(const Context& context, unsigned spaceIdx, unsigned timeIdx) const
378 {
379 const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
380 if (isFineMaterial_(pos))
381 return finePorosity_;
382 else
383 return coarsePorosity_;
384 }
385
389 template <class Context>
390 const MaterialLawParams& materialLawParams(const Context& context,
391 unsigned spaceIdx, unsigned timeIdx) const
392 {
393 const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
394 if (isFineMaterial_(pos))
395 return fineMaterialParams_;
396 else
397 return coarseMaterialParams_;
398 }
399
403 template <class Context>
404 const ThermalConductionLawParams &
405 thermalConductionParams(const Context& /*context*/,
406 unsigned /*spaceIdx*/,
407 unsigned /*timeIdx*/) const
408 { return thermalCondParams_; }
409
411
416
420 template <class Context>
421 void boundary(BoundaryRateVector& values, const Context& context,
422 unsigned spaceIdx, unsigned timeIdx) const
423 {
424 const auto& pos = context.pos(spaceIdx, timeIdx);
425
426 if (onRightBoundary_(pos)) {
427 Opm::CompositionalFluidState<Scalar, FluidSystem> fs;
428
429 initialFluidState_(fs, context, spaceIdx, timeIdx);
430
431 values.setFreeFlow(context, spaceIdx, timeIdx, fs);
432 values.setNoFlow();
433 }
434 else if (onLeftBoundary_(pos)) {
435 // injection
436 RateVector molarRate;
437
438 // inject with the same composition as the gas phase of
439 // the injection fluid state
440 Scalar molarInjectionRate = 0.3435; // [mol/(m^2 s)]
441 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
442 molarRate[conti0EqIdx + compIdx] =
443 -molarInjectionRate
444 * injectFluidState_.moleFraction(gasPhaseIdx, compIdx);
445
446 // calculate the total mass injection rate [kg / (m^2 s)
447 Scalar massInjectionRate =
448 molarInjectionRate
449 * injectFluidState_.averageMolarMass(gasPhaseIdx);
450
451 // set the boundary rate vector [J / (m^2 s)]
452 values.setMolarRate(molarRate);
453 values.setEnthalpyRate(-injectFluidState_.enthalpy(gasPhaseIdx) * massInjectionRate);
454 }
455 else
456 values.setNoFlow();
457 }
458
460
465
469 template <class Context>
470 void initial(PrimaryVariables& values, const Context& context, unsigned spaceIdx,
471 unsigned timeIdx) const
472 {
473 Opm::CompositionalFluidState<Scalar, FluidSystem> fs;
474
475 initialFluidState_(fs, context, spaceIdx, timeIdx);
476
477 const auto& matParams = materialLawParams(context, spaceIdx, timeIdx);
478 values.assignMassConservative(fs, matParams, /*inEquilibrium=*/false);
479 }
480
487 template <class Context>
488 void source(RateVector& rate,
489 const Context& /*context*/,
490 unsigned /*spaceIdx*/,
491 unsigned /*timeIdx*/) const
492 { rate = Scalar(0.0); }
493
495
496private:
497 bool onLeftBoundary_(const GlobalPosition& pos) const
498 { return pos[0] < eps_; }
499
500 bool onRightBoundary_(const GlobalPosition& pos) const
501 { return pos[0] > this->boundingBoxMax()[0] - eps_; }
502
503 bool onLowerBoundary_(const GlobalPosition& pos) const
504 { return pos[1] < eps_; }
505
506 bool onUpperBoundary_(const GlobalPosition& pos) const
507 { return pos[1] > this->boundingBoxMax()[1] - eps_; }
508
509 bool isContaminated_(const GlobalPosition& pos) const
510 {
511 return (0.20 <= pos[0]) && (pos[0] <= 0.80) && (0.4 <= pos[1])
512 && (pos[1] <= 0.65);
513 }
514
515 bool isFineMaterial_(const GlobalPosition& pos) const
516 {
517 if (0.13 <= pos[0] && 1.20 >= pos[0] && 0.32 <= pos[1] && pos[1] <= 0.57)
518 return true;
519 else if (pos[1] <= 0.15 && 1.20 <= pos[0])
520 return true;
521 else
522 return false;
523 }
524
525 template <class FluidState, class Context>
526 void initialFluidState_(FluidState& fs, const Context& context,
527 unsigned spaceIdx, unsigned timeIdx) const
528 {
529 const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
530
531 fs.setTemperature(293.0 /*[K]*/);
532
533 Scalar pw = 1e5;
534
535 if (isContaminated_(pos)) {
536 fs.setSaturation(waterPhaseIdx, 0.12);
537 fs.setSaturation(naplPhaseIdx, 0.07);
538 fs.setSaturation(gasPhaseIdx, 1 - 0.12 - 0.07);
539
540 // set the capillary pressures
541 const auto& matParams = materialLawParams(context, spaceIdx, timeIdx);
542 Scalar pc[numPhases];
543 MaterialLaw::capillaryPressures(pc, matParams, fs);
544 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
545 fs.setPressure(phaseIdx, pw + (pc[phaseIdx] - pc[waterPhaseIdx]));
546
547 // compute the phase compositions
548 using MMPC = Opm::MiscibleMultiPhaseComposition<Scalar, FluidSystem>;
549 typename FluidSystem::template ParameterCache<Scalar> paramCache;
550 MMPC::solve(fs, paramCache, /*setViscosity=*/true, /*setEnthalpy=*/true);
551 }
552 else {
553 fs.setSaturation(waterPhaseIdx, 0.12);
554 fs.setSaturation(gasPhaseIdx, 1 - fs.saturation(waterPhaseIdx));
555 fs.setSaturation(naplPhaseIdx, 0);
556
557 // set the capillary pressures
558 const auto& matParams = materialLawParams(context, spaceIdx, timeIdx);
559 Scalar pc[numPhases];
560 MaterialLaw::capillaryPressures(pc, matParams, fs);
561 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
562 fs.setPressure(phaseIdx, pw + (pc[phaseIdx] - pc[waterPhaseIdx]));
563
564 // compute the phase compositions
565 using MMPC = Opm::MiscibleMultiPhaseComposition<Scalar, FluidSystem>;
566 typename FluidSystem::template ParameterCache<Scalar> paramCache;
567 MMPC::solve(fs, paramCache, /*setViscosity=*/true, /*setEnthalpy=*/true);
568
569 // set the contaminant mole fractions to zero. this is a little bit hacky...
570 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
571 fs.setMoleFraction(phaseIdx, NAPLIdx, 0.0);
572
573 if (phaseIdx == naplPhaseIdx)
574 continue;
575
576 Scalar sumx = 0;
577 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
578 sumx += fs.moleFraction(phaseIdx, compIdx);
579
580 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
581 fs.setMoleFraction(phaseIdx, compIdx,
582 fs.moleFraction(phaseIdx, compIdx) / sumx);
583 }
584 }
585 }
586
587 void computeThermalCondParams_(ThermalConductionLawParams& params, Scalar poro)
588 {
589 Scalar lambdaGranite = 2.8; // [W / (K m)]
590
591 // create a Fluid state which has all phases present
592 Opm::ImmiscibleFluidState<Scalar, FluidSystem> fs;
593 fs.setTemperature(293.15);
594 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
595 fs.setPressure(phaseIdx, 1.0135e5);
596 }
597
598 typename FluidSystem::template ParameterCache<Scalar> paramCache;
599 paramCache.updateAll(fs);
600 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
601 Scalar rho = FluidSystem::density(fs, paramCache, phaseIdx);
602 fs.setDensity(phaseIdx, rho);
603 }
604
605 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
606 Scalar lambdaSaturated;
607 if (FluidSystem::isLiquid(phaseIdx)) {
608 Scalar lambdaFluid = FluidSystem::thermalConductivity(fs, paramCache, phaseIdx);
609 lambdaSaturated =
610 std::pow(lambdaGranite, (1 - poro))
611 +
612 std::pow(lambdaFluid, poro);
613 }
614 else
615 lambdaSaturated = std::pow(lambdaGranite, (1 - poro));
616
617 params.setFullySaturatedLambda(phaseIdx, lambdaSaturated);
618 if (!FluidSystem::isLiquid(phaseIdx))
619 params.setVacuumLambda(lambdaSaturated);
620 }
621 }
622
623 void initInjectFluidState_()
624 {
625 injectFluidState_.setTemperature(383.0); // [K]
626 injectFluidState_.setPressure(gasPhaseIdx, 1e5); // [Pa]
627 injectFluidState_.setSaturation(gasPhaseIdx, 1.0); // [-]
628
629 Scalar xgH2O = 0.417;
630 injectFluidState_.setMoleFraction(gasPhaseIdx, H2OIdx, xgH2O); // [-]
631 injectFluidState_.setMoleFraction(gasPhaseIdx, airIdx, 1 - xgH2O); // [-]
632 injectFluidState_.setMoleFraction(gasPhaseIdx, NAPLIdx, 0.0); // [-]
633
634 // set the specific enthalpy of the gas phase
635 typename FluidSystem::template ParameterCache<Scalar> paramCache;
636 paramCache.updatePhase(injectFluidState_, gasPhaseIdx);
637
638 Scalar h = FluidSystem::enthalpy(injectFluidState_, paramCache, gasPhaseIdx);
639 injectFluidState_.setEnthalpy(gasPhaseIdx, h);
640 }
641
642 DimMatrix fineK_;
643 DimMatrix coarseK_;
644
645 Scalar finePorosity_;
646 Scalar coarsePorosity_;
647
648 MaterialLawParams fineMaterialParams_;
649 MaterialLawParams coarseMaterialParams_;
650
651 ThermalConductionLawParams thermalCondParams_;
652 SolidEnergyLawParams solidEnergyLawParams_;
653
654 Opm::CompositionalFluidState<Scalar, FluidSystem> injectFluidState_;
655
656 const Scalar eps_;
657};
658} // namespace Opm
659
660#endif
Non-isothermal three-phase gas injection problem where a hot gas is injected into a unsaturated porou...
Definition: cuvetteproblem.hh:179
Scalar temperature(const Context &, unsigned, unsigned) const
Definition: cuvetteproblem.hh:355
void boundary(BoundaryRateVector &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:421
CuvetteProblem(Simulator &simulator)
Definition: cuvetteproblem.hh:219
const MaterialLawParams & materialLawParams(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:390
void initial(PrimaryVariables &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:470
const DimMatrix & intrinsicPermeability(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:364
const ThermalConductionLawParams & thermalConductionParams(const Context &, unsigned, unsigned) const
Definition: cuvetteproblem.hh:405
Scalar porosity(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:377
void finishInit()
Definition: cuvetteproblem.hh:227
std::string name() const
Definition: cuvetteproblem.hh:322
void endTimeStep()
Definition: cuvetteproblem.hh:328
bool shouldWriteRestartFile() const
Definition: cuvetteproblem.hh:316
void source(RateVector &rate, const Context &, unsigned, unsigned) const
Definition: cuvetteproblem.hh:488
Definition: cuvetteproblem.hh:63