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