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 
53 namespace Opm {
54 template <class TypeTag>
55 class CuvetteProblem;
56 }
57 
58 namespace Opm::Properties {
59 
60 
61 // create a new type tag for the cuvette steam injection problem
62 namespace TTag {
64 }
65 
66 // Set the grid type
67 template<class TypeTag>
68 struct Grid<TypeTag, TTag::CuvetteBaseProblem> { using type = Dune::YaspGrid<2>; };
69 
70 // Set the problem property
71 template<class TypeTag>
72 struct Problem<TypeTag, TTag::CuvetteBaseProblem> { using type = Opm::CuvetteProblem<TypeTag>; };
73 
74 // Set the fluid system
75 template<class TypeTag>
76 struct FluidSystem<TypeTag, TTag::CuvetteBaseProblem>
77 { using type = Opm::H2OAirMesityleneFluidSystem<GetPropType<TypeTag, Properties::Scalar>>; };
78 
79 // Enable gravity
80 template<class TypeTag>
81 struct EnableGravity<TypeTag, TTag::CuvetteBaseProblem> { static constexpr bool value = true; };
82 
83 // Set the maximum time step
84 template<class TypeTag>
85 struct MaxTimeStepSize<TypeTag, TTag::CuvetteBaseProblem>
86 {
87  using type = GetPropType<TypeTag, Scalar>;
88  static constexpr type value = 600.;
89 };
90 
91 // Set the material Law
92 template<class TypeTag>
93 struct MaterialLaw<TypeTag, TTag::CuvetteBaseProblem>
94 {
95 private:
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 
105 public:
106  using type = Opm::ThreePhaseParkerVanGenuchten<Traits>;
107 };
108 
109 // set the energy storage law for the solid phase
110 template<class TypeTag>
111 struct SolidEnergyLaw<TypeTag, TTag::CuvetteBaseProblem>
112 { using type = Opm::ConstantSolidHeatCapLaw<GetPropType<TypeTag, Properties::Scalar>>; };
113 
114 // Set the thermal conduction law
115 template<class TypeTag>
116 struct ThermalConductionLaw<TypeTag, TTag::CuvetteBaseProblem>
117 {
118 private:
119  using Scalar = GetPropType<TypeTag, Properties::Scalar>;
120  using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
121 
122 public:
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
128 template<class TypeTag>
129 struct 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
136 template<class TypeTag>
137 struct 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
144 template<class TypeTag>
145 struct GridFile<TypeTag, TTag::CuvetteBaseProblem> { static constexpr auto value = "./data/cuvette_11x4.dgf"; };
146 
147 } // namespace Opm::Properties
148 
149 namespace Opm {
177 template <class TypeTag>
178 class 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 
215 public:
219  CuvetteProblem(Simulator& simulator)
220  : ParentType(simulator)
221  , eps_(1e-6)
222  { }
223 
227  void finishInit()
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 
328  void endTimeStep()
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 
496 private:
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
const DimMatrix & intrinsicPermeability(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:364
CuvetteProblem(Simulator &simulator)
Definition: cuvetteproblem.hh:219
void initial(PrimaryVariables &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:470
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
const MaterialLawParams & materialLawParams(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:390
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
const ThermalConductionLawParams & thermalConductionParams(const Context &, unsigned, unsigned) const
Definition: cuvetteproblem.hh:405
Definition: cuvetteproblem.hh:63