All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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/heatconduction/Somerton.hpp>
39 #include <opm/material/constraintsolvers/MiscibleMultiPhaseComposition.hpp>
40 #include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
41 #include <opm/common/Valgrind.hpp>
42 #include <opm/common/Unused.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 Ewoms {
54 template <class TypeTag>
56 }
57 
58 namespace Ewoms {
59 namespace Properties {
60 
61 // create a new type tag for the cuvette steam injection problem
62 NEW_TYPE_TAG(CuvetteBaseProblem);
63 
64 // Set the grid type
65 SET_TYPE_PROP(CuvetteBaseProblem, Grid, Dune::YaspGrid<2>);
66 
67 // Set the problem property
68 SET_TYPE_PROP(CuvetteBaseProblem, Problem, Ewoms::CuvetteProblem<TypeTag>);
69 
70 // Set the fluid system
72  CuvetteBaseProblem, FluidSystem,
73  Opm::FluidSystems::H2OAirMesitylene<typename GET_PROP_TYPE(TypeTag, Scalar)>);
74 
75 // Enable gravity
76 SET_BOOL_PROP(CuvetteBaseProblem, EnableGravity, true);
77 
78 // Set the maximum time step
79 SET_SCALAR_PROP(CuvetteBaseProblem, MaxTimeStepSize, 600.);
80 
81 // Set the material Law
82 SET_PROP(CuvetteBaseProblem, MaterialLaw)
83 {
84 private:
85  typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
86  typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
87 
88  typedef Opm::ThreePhaseMaterialTraits<
89  Scalar,
90  /*wettingPhaseIdx=*/FluidSystem::waterPhaseIdx,
91  /*nonWettingPhaseIdx=*/FluidSystem::naplPhaseIdx,
92  /*gasPhaseIdx=*/FluidSystem::gasPhaseIdx> Traits;
93 
94 public:
95  typedef Opm::ThreePhaseParkerVanGenuchten<Traits> type;
96 };
97 
98 // Set the heat conduction law
99 SET_PROP(CuvetteBaseProblem, HeatConductionLaw)
100 {
101 private:
102  typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
103  typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
104 
105 public:
106  // define the material law parameterized by absolute saturations
107  typedef Opm::Somerton<FluidSystem, Scalar> type;
108 };
109 
110 // The default for the end time of the simulation
111 SET_SCALAR_PROP(CuvetteBaseProblem, EndTime, 180);
112 
113 // The default for the initial time step size of the simulation
114 SET_SCALAR_PROP(CuvetteBaseProblem, InitialTimeStepSize, 1);
115 
116 // The default DGF file to load
117 SET_STRING_PROP(CuvetteBaseProblem, GridFile, "./data/cuvette_11x4.dgf");
118 } // namespace Properties
119 } // namespace Ewoms
120 
121 namespace Ewoms {
149 template <class TypeTag>
150 class CuvetteProblem : public GET_PROP_TYPE(TypeTag, BaseProblem)
151 {
152  typedef typename GET_PROP_TYPE(TypeTag, BaseProblem) ParentType;
153 
154  typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
155  typedef typename GET_PROP_TYPE(TypeTag, GridView) GridView;
156  typedef typename GET_PROP_TYPE(TypeTag, MaterialLaw) MaterialLaw;
157  typedef typename GET_PROP_TYPE(TypeTag, MaterialLawParams) MaterialLawParams;
158  typedef typename GET_PROP_TYPE(TypeTag, HeatConductionLaw) HeatConductionLaw;
159  typedef typename GET_PROP_TYPE(TypeTag, HeatConductionLawParams) HeatConductionLawParams;
160  typedef typename GET_PROP_TYPE(TypeTag, EqVector) EqVector;
161  typedef typename GET_PROP_TYPE(TypeTag, PrimaryVariables) PrimaryVariables;
162  typedef typename GET_PROP_TYPE(TypeTag, RateVector) RateVector;
163  typedef typename GET_PROP_TYPE(TypeTag, BoundaryRateVector) BoundaryRateVector;
164  typedef typename GET_PROP_TYPE(TypeTag, Simulator) Simulator;
165  typedef typename GET_PROP_TYPE(TypeTag, Model) Model;
166  typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
167 
168  // copy some indices for convenience
169  typedef typename GET_PROP_TYPE(TypeTag, Indices) Indices;
170  enum { numPhases = FluidSystem::numPhases };
171  enum { numComponents = FluidSystem::numComponents };
172  enum { waterPhaseIdx = FluidSystem::waterPhaseIdx };
173  enum { naplPhaseIdx = FluidSystem::naplPhaseIdx };
174  enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
175  enum { H2OIdx = FluidSystem::H2OIdx };
176  enum { airIdx = FluidSystem::airIdx };
177  enum { NAPLIdx = FluidSystem::NAPLIdx };
178  enum { conti0EqIdx = Indices::conti0EqIdx };
179 
180  // Grid and world dimension
181  enum { dimWorld = GridView::dimensionworld };
182 
183  typedef typename GridView::ctype CoordScalar;
184  typedef Dune::FieldVector<CoordScalar, dimWorld> GlobalPosition;
185  typedef Dune::FieldMatrix<Scalar, dimWorld, dimWorld> DimMatrix;
186 
187 public:
192  : ParentType(simulator)
193  , eps_(1e-6)
194  { }
195 
199  void finishInit()
200  {
201  ParentType::finishInit();
202 
203  if (Opm::Valgrind::IsRunning())
204  FluidSystem::init(/*minT=*/283.15, /*maxT=*/500.0, /*nT=*/20,
205  /*minp=*/0.8e5, /*maxp=*/2e5, /*np=*/10);
206  else
207  FluidSystem::init(/*minT=*/283.15, /*maxT=*/500.0, /*nT=*/200,
208  /*minp=*/0.8e5, /*maxp=*/2e5, /*np=*/100);
209 
210  // intrinsic permeabilities
211  fineK_ = this->toDimMatrix_(6.28e-12);
212  coarseK_ = this->toDimMatrix_(9.14e-10);
213 
214  // porosities
215  finePorosity_ = 0.42;
216  coarsePorosity_ = 0.42;
217 
218  // parameters for the capillary pressure law
219 #if 1
220  // three-phase Parker -- van Genuchten law
221  fineMaterialParams_.setVgAlpha(0.0005);
222  coarseMaterialParams_.setVgAlpha(0.005);
223  fineMaterialParams_.setVgN(4.0);
224  coarseMaterialParams_.setVgN(4.0);
225 
226  coarseMaterialParams_.setkrRegardsSnr(true);
227  fineMaterialParams_.setkrRegardsSnr(true);
228 
229  // residual saturations
230  fineMaterialParams_.setSwr(0.1201);
231  fineMaterialParams_.setSwrx(0.1201);
232  fineMaterialParams_.setSnr(0.0701);
233  fineMaterialParams_.setSgr(0.0101);
234  coarseMaterialParams_.setSwr(0.1201);
235  coarseMaterialParams_.setSwrx(0.1201);
236  coarseMaterialParams_.setSnr(0.0701);
237  coarseMaterialParams_.setSgr(0.0101);
238 #else
239  // linear material law
240  fineMaterialParams_.setPcMinSat(gasPhaseIdx, 0);
241  fineMaterialParams_.setPcMaxSat(gasPhaseIdx, 0);
242  fineMaterialParams_.setPcMinSat(naplPhaseIdx, 0);
243  fineMaterialParams_.setPcMaxSat(naplPhaseIdx, -1000);
244  fineMaterialParams_.setPcMinSat(waterPhaseIdx, 0);
245  fineMaterialParams_.setPcMaxSat(waterPhaseIdx, -10000);
246 
247  coarseMaterialParams_.setPcMinSat(gasPhaseIdx, 0);
248  coarseMaterialParams_.setPcMaxSat(gasPhaseIdx, 0);
249  coarseMaterialParams_.setPcMinSat(naplPhaseIdx, 0);
250  coarseMaterialParams_.setPcMaxSat(naplPhaseIdx, -100);
251  coarseMaterialParams_.setPcMinSat(waterPhaseIdx, 0);
252  coarseMaterialParams_.setPcMaxSat(waterPhaseIdx, -1000);
253 
254  // residual saturations
255  fineMaterialParams_.setResidSat(waterPhaseIdx, 0.1201);
256  fineMaterialParams_.setResidSat(naplPhaseIdx, 0.0701);
257  fineMaterialParams_.setResidSat(gasPhaseIdx, 0.0101);
258 
259  coarseMaterialParams_.setResidSat(waterPhaseIdx, 0.1201);
260  coarseMaterialParams_.setResidSat(naplPhaseIdx, 0.0701);
261  coarseMaterialParams_.setResidSat(gasPhaseIdx, 0.0101);
262 #endif
263 
264  fineMaterialParams_.finalize();
265  coarseMaterialParams_.finalize();
266 
267  // initialize parameters for the heat conduction law
268  computeHeatCondParams_(heatCondParams_, finePorosity_);
269 
270  initInjectFluidState_();
271  }
272 
276 
284  { return true; }
285 
289  std::string name() const
290  { return std::string("cuvette_") + Model::name(); }
291 
295  void endTimeStep()
296  {
297 #ifndef NDEBUG
298  this->model().checkConservativeness();
299 
300  // Calculate storage terms
301  EqVector storage;
302  this->model().globalStorage(storage);
303 
304  // Write mass balance information for rank 0
305  if (this->gridView().comm().rank() == 0) {
306  std::cout << "Storage: " << storage << std::endl << std::flush;
307  }
308 #endif // NDEBUG
309  }
310 
312 
316 
321  template <class Context>
322  Scalar temperature(const Context& context OPM_UNUSED,
323  unsigned spaceIdx OPM_UNUSED,
324  unsigned timeIdx OPM_UNUSED) const
325  { return 293.15; /* [K] */ }
326 
330  template <class Context>
331  const DimMatrix& intrinsicPermeability(const Context& context, unsigned spaceIdx,
332  unsigned timeIdx) const
333  {
334  const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
335  if (isFineMaterial_(pos))
336  return fineK_;
337  return coarseK_;
338  }
339 
343  template <class Context>
344  Scalar porosity(const Context& context, unsigned spaceIdx, unsigned timeIdx) const
345  {
346  const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
347  if (isFineMaterial_(pos))
348  return finePorosity_;
349  else
350  return coarsePorosity_;
351  }
352 
356  template <class Context>
357  const MaterialLawParams& materialLawParams(const Context& context,
358  unsigned spaceIdx, unsigned timeIdx) const
359  {
360  const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
361  if (isFineMaterial_(pos))
362  return fineMaterialParams_;
363  else
364  return coarseMaterialParams_;
365  }
366 
370  template <class Context>
371  const HeatConductionLawParams &
372  heatConductionParams(const Context& context OPM_UNUSED,
373  unsigned spaceIdx OPM_UNUSED,
374  unsigned timeIdx OPM_UNUSED) const
375  { return heatCondParams_; }
376 
380  template <class Context>
381  Scalar heatCapacitySolid(const Context& context OPM_UNUSED,
382  unsigned spaceIdx OPM_UNUSED,
383  unsigned timeIdx OPM_UNUSED) const
384  {
385  return 850 // specific heat capacity [J / (kg K)]
386  * 2650; // density of sand [kg/m^3]
387  }
388 
390 
394 
399  template <class Context>
400  void boundary(BoundaryRateVector& values, const Context& context,
401  unsigned spaceIdx, unsigned timeIdx) const
402  {
403  const auto& pos = context.pos(spaceIdx, timeIdx);
404 
405  if (onRightBoundary_(pos)) {
406  Opm::CompositionalFluidState<Scalar, FluidSystem> fs;
407 
408  initialFluidState_(fs, context, spaceIdx, timeIdx);
409 
410  values.setFreeFlow(context, spaceIdx, timeIdx, fs);
411  values.setNoFlow();
412  }
413  else if (onLeftBoundary_(pos)) {
414  // injection
415  RateVector molarRate;
416 
417  // inject with the same composition as the gas phase of
418  // the injection fluid state
419  Scalar molarInjectionRate = 0.3435; // [mol/(m^2 s)]
420  for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
421  molarRate[conti0EqIdx + compIdx] =
422  -molarInjectionRate
423  * injectFluidState_.moleFraction(gasPhaseIdx, compIdx);
424 
425  // calculate the total mass injection rate [kg / (m^2 s)
426  Scalar massInjectionRate =
427  molarInjectionRate
428  * injectFluidState_.averageMolarMass(gasPhaseIdx);
429 
430  // set the boundary rate vector [J / (m^2 s)]
431  values.setMolarRate(molarRate);
432  values.setEnthalpyRate(-injectFluidState_.enthalpy(gasPhaseIdx) * massInjectionRate);
433  }
434  else
435  values.setNoFlow();
436  }
437 
439 
443 
448  template <class Context>
449  void initial(PrimaryVariables& values, const Context& context, unsigned spaceIdx,
450  unsigned timeIdx) const
451  {
452  Opm::CompositionalFluidState<Scalar, FluidSystem> fs;
453 
454  initialFluidState_(fs, context, spaceIdx, timeIdx);
455 
456  const auto& matParams = materialLawParams(context, spaceIdx, timeIdx);
457  values.assignMassConservative(fs, matParams, /*inEquilibrium=*/false);
458  }
459 
466  template <class Context>
467  void source(RateVector& rate,
468  const Context& context OPM_UNUSED,
469  unsigned spaceIdx OPM_UNUSED,
470  unsigned timeIdx OPM_UNUSED) const
471  { rate = Scalar(0.0); }
472 
474 
475 private:
476  bool onLeftBoundary_(const GlobalPosition& pos) const
477  { return pos[0] < eps_; }
478 
479  bool onRightBoundary_(const GlobalPosition& pos) const
480  { return pos[0] > this->boundingBoxMax()[0] - eps_; }
481 
482  bool onLowerBoundary_(const GlobalPosition& pos) const
483  { return pos[1] < eps_; }
484 
485  bool onUpperBoundary_(const GlobalPosition& pos) const
486  { return pos[1] > this->boundingBoxMax()[1] - eps_; }
487 
488  bool isContaminated_(const GlobalPosition& pos) const
489  {
490  return (0.20 <= pos[0]) && (pos[0] <= 0.80) && (0.4 <= pos[1])
491  && (pos[1] <= 0.65);
492  }
493 
494  bool isFineMaterial_(const GlobalPosition& pos) const
495  {
496  if (0.13 <= pos[0] && 1.20 >= pos[0] && 0.32 <= pos[1] && pos[1] <= 0.57)
497  return true;
498  else if (pos[1] <= 0.15 && 1.20 <= pos[0])
499  return true;
500  else
501  return false;
502  }
503 
504  template <class FluidState, class Context>
505  void initialFluidState_(FluidState& fs, const Context& context,
506  unsigned spaceIdx, unsigned timeIdx) const
507  {
508  const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
509 
510  fs.setTemperature(293.0 /*[K]*/);
511 
512  Scalar pw = 1e5;
513 
514  if (isContaminated_(pos)) {
515  fs.setSaturation(waterPhaseIdx, 0.12);
516  fs.setSaturation(naplPhaseIdx, 0.07);
517  fs.setSaturation(gasPhaseIdx, 1 - 0.12 - 0.07);
518 
519  // set the capillary pressures
520  const auto& matParams = materialLawParams(context, spaceIdx, timeIdx);
521  Scalar pc[numPhases];
522  MaterialLaw::capillaryPressures(pc, matParams, fs);
523  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
524  fs.setPressure(phaseIdx, pw + (pc[phaseIdx] - pc[waterPhaseIdx]));
525 
526  // compute the phase compositions
527  typedef Opm::MiscibleMultiPhaseComposition<Scalar, FluidSystem> MMPC;
528  typename FluidSystem::template ParameterCache<Scalar> paramCache;
529  MMPC::solve(fs, paramCache, /*setViscosity=*/true, /*setEnthalpy=*/true);
530  }
531  else {
532  fs.setSaturation(waterPhaseIdx, 0.12);
533  fs.setSaturation(gasPhaseIdx, 1 - fs.saturation(waterPhaseIdx));
534  fs.setSaturation(naplPhaseIdx, 0);
535 
536  // set the capillary pressures
537  const auto& matParams = materialLawParams(context, spaceIdx, timeIdx);
538  Scalar pc[numPhases];
539  MaterialLaw::capillaryPressures(pc, matParams, fs);
540  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
541  fs.setPressure(phaseIdx, pw + (pc[phaseIdx] - pc[waterPhaseIdx]));
542 
543  // compute the phase compositions
544  typedef Opm::MiscibleMultiPhaseComposition<Scalar, FluidSystem> MMPC;
545  typename FluidSystem::template ParameterCache<Scalar> paramCache;
546  MMPC::solve(fs, paramCache, /*setViscosity=*/true, /*setEnthalpy=*/true);
547 
548  // set the contaminant mole fractions to zero. this is a little bit hacky...
549  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
550  fs.setMoleFraction(phaseIdx, NAPLIdx, 0.0);
551 
552  if (phaseIdx == naplPhaseIdx)
553  continue;
554 
555  Scalar sumx = 0;
556  for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
557  sumx += fs.moleFraction(phaseIdx, compIdx);
558 
559  for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
560  fs.setMoleFraction(phaseIdx, compIdx,
561  fs.moleFraction(phaseIdx, compIdx) / sumx);
562  }
563  }
564  }
565 
566  void computeHeatCondParams_(HeatConductionLawParams& params, Scalar poro)
567  {
568  Scalar lambdaGranite = 2.8; // [W / (K m)]
569 
570  // create a Fluid state which has all phases present
571  Opm::ImmiscibleFluidState<Scalar, FluidSystem> fs;
572  fs.setTemperature(293.15);
573  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
574  fs.setPressure(phaseIdx, 1.0135e5);
575  }
576 
577  typename FluidSystem::template ParameterCache<Scalar> paramCache;
578  paramCache.updateAll(fs);
579  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
580  Scalar rho = FluidSystem::density(fs, paramCache, phaseIdx);
581  fs.setDensity(phaseIdx, rho);
582  }
583 
584  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
585  Scalar lambdaSaturated;
586  if (FluidSystem::isLiquid(phaseIdx)) {
587  Scalar lambdaFluid = FluidSystem::thermalConductivity(fs, paramCache, phaseIdx);
588  lambdaSaturated =
589  std::pow(lambdaGranite, (1 - poro))
590  +
591  std::pow(lambdaFluid, poro);
592  }
593  else
594  lambdaSaturated = std::pow(lambdaGranite, (1 - poro));
595 
596  params.setFullySaturatedLambda(phaseIdx, lambdaSaturated);
597  if (!FluidSystem::isLiquid(phaseIdx))
598  params.setVacuumLambda(lambdaSaturated);
599  }
600  }
601 
602  void initInjectFluidState_()
603  {
604  injectFluidState_.setTemperature(383.0); // [K]
605  injectFluidState_.setPressure(gasPhaseIdx, 1e5); // [Pa]
606  injectFluidState_.setSaturation(gasPhaseIdx, 1.0); // [-]
607 
608  Scalar xgH2O = 0.417;
609  injectFluidState_.setMoleFraction(gasPhaseIdx, H2OIdx, xgH2O); // [-]
610  injectFluidState_.setMoleFraction(gasPhaseIdx, airIdx, 1 - xgH2O); // [-]
611  injectFluidState_.setMoleFraction(gasPhaseIdx, NAPLIdx, 0.0); // [-]
612 
613  // set the specific enthalpy of the gas phase
614  typename FluidSystem::template ParameterCache<Scalar> paramCache;
615  paramCache.updatePhase(injectFluidState_, gasPhaseIdx);
616 
617  Scalar h = FluidSystem::enthalpy(injectFluidState_, paramCache, gasPhaseIdx);
618  injectFluidState_.setEnthalpy(gasPhaseIdx, h);
619  }
620 
621  DimMatrix fineK_;
622  DimMatrix coarseK_;
623 
624  Scalar finePorosity_;
625  Scalar coarsePorosity_;
626 
627  MaterialLawParams fineMaterialParams_;
628  MaterialLawParams coarseMaterialParams_;
629 
630  HeatConductionLawParams heatCondParams_;
631 
632  Opm::CompositionalFluidState<Scalar, FluidSystem> injectFluidState_;
633 
634  const Scalar eps_;
635 };
636 } // namespace Ewoms
637 
638 #endif
#define SET_BOOL_PROP(EffTypeTagName, PropTagName,...)
Set a property to a simple constant boolean value.
Definition: propertysystem.hh:361
Scalar heatCapacitySolid(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: cuvetteproblem.hh:381
CuvetteProblem(Simulator &simulator)
Definition: cuvetteproblem.hh:191
Scalar temperature(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: cuvetteproblem.hh:322
void endTimeStep()
Called by the simulator after each time integration.
Definition: cuvetteproblem.hh:295
const DimMatrix & intrinsicPermeability(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:331
#define NEW_TYPE_TAG(...)
Define a new type tag.
Definition: propertysystem.hh:169
void boundary(BoundaryRateVector &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Evaluate the boundary conditions for a boundary segment.
Definition: cuvetteproblem.hh:400
#define GET_PROP_TYPE(TypeTag, PropTagName)
Access the type attribute of a property for a type tag.
Definition: propertysystem.hh:486
void initial(PrimaryVariables &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Evaluate the initial value for a control volume.
Definition: cuvetteproblem.hh:449
Non-isothermal three-phase gas injection problem where a hot gas is injected into a unsaturated porou...
Definition: cuvetteproblem.hh:55
const MaterialLawParams & materialLawParams(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:357
void finishInit()
Called by the Ewoms::Simulator in order to initialize the problem.
Definition: cuvetteproblem.hh:199
#define SET_PROP(EffTypeTagName, PropTagName)
Set a property for a specific type tag.
Definition: propertysystem.hh:297
const HeatConductionLawParams & heatConductionParams(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: cuvetteproblem.hh:372
std::string name() const
The problem name.
Definition: cuvetteproblem.hh:289
Declares the properties required for the compositional multi-phase primary variable switching model...
Scalar porosity(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: cuvetteproblem.hh:344
bool shouldWriteRestartFile() const
Returns true if a restart file should be written to disk.
Definition: cuvetteproblem.hh:283
Manages the initializing and running of time dependent problems.
Definition: simulator.hh:75
void source(RateVector &rate, const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Evaluate the source term for all phases within a given sub-control-volume.
Definition: cuvetteproblem.hh:467
#define SET_TYPE_PROP(EffTypeTagName, PropTagName,...)
Set a property which defines a type.
Definition: propertysystem.hh:377
#define SET_STRING_PROP(EffTypeTagName, PropTagName,...)
Set a property to a simple constant string value.
Definition: propertysystem.hh:416
#define SET_SCALAR_PROP(EffTypeTagName, PropTagName,...)
Set a property to a simple constant scalar value.
Definition: propertysystem.hh:394