All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
fractureproblem.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_FRACTURE_PROBLEM_HH
29 #define EWOMS_FRACTURE_PROBLEM_HH
30 
31 #if HAVE_DUNE_ALUGRID
32 // avoid reordering of macro elements, otherwise this problem won't work
33 #define DISABLE_ALUGRID_SFC_ORDERING 1
34 #include <dune/alugrid/grid.hh>
35 #include <dune/alugrid/dgf.hh>
36 #else
37 #error "dune-alugrid not found!"
38 #endif
39 
42 
43 #include <opm/material/fluidmatrixinteractions/RegularizedBrooksCorey.hpp>
44 #include <opm/material/fluidmatrixinteractions/RegularizedVanGenuchten.hpp>
45 #include <opm/material/fluidmatrixinteractions/LinearMaterial.hpp>
46 #include <opm/material/fluidmatrixinteractions/EffToAbsLaw.hpp>
47 #include <opm/material/fluidmatrixinteractions/MaterialTraits.hpp>
48 #include <opm/material/heatconduction/Somerton.hpp>
49 #include <opm/material/fluidsystems/TwoPhaseImmiscibleFluidSystem.hpp>
50 #include <opm/material/components/SimpleH2O.hpp>
51 #include <opm/material/components/Dnapl.hpp>
52 #include <opm/common/Unused.hpp>
53 
54 #include <dune/common/version.hh>
55 #include <dune/common/fmatrix.hh>
56 #include <dune/common/fvector.hh>
57 
58 #include <iostream>
59 #include <sstream>
60 #include <string>
61 
62 namespace Ewoms {
63 template <class TypeTag>
65 }
66 
67 namespace Ewoms {
68 namespace Properties {
69 // Create a type tag for the problem
71 
72 // Set the grid type
74  FractureProblem, Grid,
75  Dune::ALUGrid</*dim=*/2, /*dimWorld=*/2, Dune::simplex, Dune::nonconforming>);
76 
77 // Set the GridManager property
79 
80 // Set the problem property
82 
83 // Set the wetting phase
84 SET_PROP(FractureProblem, WettingPhase)
85 {
86 private:
87  typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
88 
89 public:
90  typedef Opm::LiquidPhase<Scalar, Opm::SimpleH2O<Scalar> > type;
91 };
92 
93 // Set the non-wetting phase
94 SET_PROP(FractureProblem, NonwettingPhase)
95 {
96 private:
97  typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
98 
99 public:
100  typedef Opm::LiquidPhase<Scalar, Opm::DNAPL<Scalar> > type;
101 };
102 
103 // Set the material Law
104 SET_PROP(FractureProblem, MaterialLaw)
105 {
106 private:
107  typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
108  enum { wettingPhaseIdx = FluidSystem::wettingPhaseIdx };
109  enum { nonWettingPhaseIdx = FluidSystem::nonWettingPhaseIdx };
110 
111  typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
112  typedef Opm::TwoPhaseMaterialTraits<Scalar,
113  /*wettingPhaseIdx=*/FluidSystem::wettingPhaseIdx,
114  /*nonWettingPhaseIdx=*/FluidSystem::nonWettingPhaseIdx>
115  Traits;
116 
117  // define the material law which is parameterized by effective
118  // saturations
119  typedef Opm::RegularizedBrooksCorey<Traits> EffectiveLaw;
120  // typedef RegularizedVanGenuchten<Traits> EffectiveLaw;
121  // typedef LinearMaterial<Traits> EffectiveLaw;
122 public:
123  typedef Opm::EffToAbsLaw<EffectiveLaw> type;
124 };
125 
126 // Enable the energy equation
127 SET_BOOL_PROP(FractureProblem, EnableEnergy, true);
128 
129 // Set the heat conduction law
130 SET_PROP(FractureProblem, HeatConductionLaw)
131 {
132 private:
133  typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
134  typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
135 
136 public:
137  // define the material law parameterized by absolute saturations
138  typedef Opm::Somerton<FluidSystem, Scalar> type;
139 };
140 
141 // Disable gravity
142 SET_BOOL_PROP(FractureProblem, EnableGravity, false);
143 
144 // For this problem, we use constraints to specify the left boundary
145 SET_BOOL_PROP(FractureProblem, EnableConstraints, true);
146 
147 // Set the default value for the file name of the grid
148 SET_STRING_PROP(FractureProblem, GridFile, "data/fracture.art.dgf");
149 
150 // Set the default value for the end time
151 SET_SCALAR_PROP(FractureProblem, EndTime, 3e3);
152 
153 // Set the default value for the initial time step size
154 SET_SCALAR_PROP(FractureProblem, InitialTimeStepSize, 100);
155 } // namespace Properties
156 } // namespace Ewoms
157 
158 namespace Ewoms {
171 template <class TypeTag>
172 class FractureProblem : public GET_PROP_TYPE(TypeTag, BaseProblem)
173 {
174  typedef typename GET_PROP_TYPE(TypeTag, BaseProblem) ParentType;
175  typedef typename GET_PROP_TYPE(TypeTag, GridView) GridView;
176  typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
177  typedef typename GET_PROP_TYPE(TypeTag, WettingPhase) WettingPhase;
178  typedef typename GET_PROP_TYPE(TypeTag, NonwettingPhase) NonwettingPhase;
179  typedef typename GET_PROP_TYPE(TypeTag, Constraints) Constraints;
180  typedef typename GET_PROP_TYPE(TypeTag, EqVector) EqVector;
181  typedef typename GET_PROP_TYPE(TypeTag, PrimaryVariables) PrimaryVariables;
182  typedef typename GET_PROP_TYPE(TypeTag, BoundaryRateVector) BoundaryRateVector;
183  typedef typename GET_PROP_TYPE(TypeTag, RateVector) RateVector;
184  typedef typename GET_PROP_TYPE(TypeTag, Simulator) Simulator;
185  typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
186  typedef typename GET_PROP_TYPE(TypeTag, MaterialLaw) MaterialLaw;
187  typedef typename GET_PROP_TYPE(TypeTag, MaterialLawParams) MaterialLawParams;
188  typedef typename GET_PROP_TYPE(TypeTag, HeatConductionLawParams) HeatConductionLawParams;
189  typedef typename GET_PROP_TYPE(TypeTag, Model) Model;
190 
191  enum {
192  // phase indices
193  wettingPhaseIdx = MaterialLaw::wettingPhaseIdx,
194  nonWettingPhaseIdx = MaterialLaw::nonWettingPhaseIdx,
195 
196  // number of phases
197  numPhases = FluidSystem::numPhases,
198 
199  // Grid and world dimension
200  dim = GridView::dimension,
201  dimWorld = GridView::dimensionworld
202  };
203 
204  typedef Opm::ImmiscibleFluidState<Scalar, FluidSystem> FluidState;
205 
206  typedef Dune::FieldVector<Scalar, dimWorld> GlobalPosition;
207  typedef Dune::FieldMatrix<Scalar, dimWorld, dimWorld> DimMatrix;
208 
209  template <int dim>
210  struct FaceLayout
211  {
212  bool contains(Dune::GeometryType gt)
213  { return gt.dim() == dim - 1; }
214  };
215  typedef Dune::MultipleCodimMultipleGeomTypeMapper<GridView, FaceLayout> FaceMapper;
216 
217  typedef Ewoms::FractureMapper<TypeTag> FractureMapper;
218 
219 public:
224  : ParentType(simulator)
225  { }
226 
230  void finishInit()
231  {
232  ParentType::finishInit();
233 
234  eps_ = 3e-6;
235  temperature_ = 273.15 + 20; // -> 20°C
236 
237  matrixMaterialParams_.setResidualSaturation(wettingPhaseIdx, 0.0);
238  matrixMaterialParams_.setResidualSaturation(nonWettingPhaseIdx, 0.0);
239  fractureMaterialParams_.setResidualSaturation(wettingPhaseIdx, 0.0);
240  fractureMaterialParams_.setResidualSaturation(nonWettingPhaseIdx, 0.0);
241 
242 #if 0 // linear
243  matrixMaterialParams_.setEntryPC(0.0);
244  matrixMaterialParams_.setMaxPC(2000.0);
245  fractureMaterialParams_.setEntryPC(0.0);
246  fractureMaterialParams_.setMaxPC(1000.0);
247 #endif
248 
249 #if 1 // Brooks-Corey
250  matrixMaterialParams_.setEntryPressure(2000);
251  matrixMaterialParams_.setLambda(2.0);
252  matrixMaterialParams_.setPcLowSw(1e-1);
253  fractureMaterialParams_.setEntryPressure(1000);
254  fractureMaterialParams_.setLambda(2.0);
255  fractureMaterialParams_.setPcLowSw(5e-2);
256 #endif
257 
258 #if 0 // van Genuchten
259  matrixMaterialParams_.setVgAlpha(0.0037);
260  matrixMaterialParams_.setVgN(4.7);
261  fractureMaterialParams_.setVgAlpha(0.0025);
262  fractureMaterialParams_.setVgN(4.7);
263 #endif
264 
265  matrixMaterialParams_.finalize();
266  fractureMaterialParams_.finalize();
267 
268  matrixK_ = this->toDimMatrix_(1e-15); // m^2
269  fractureK_ = this->toDimMatrix_(1e5 * 1e-15); // m^2
270 
271  matrixPorosity_ = 0.10;
272  fracturePorosity_ = 0.25;
273  fractureWidth_ = 1e-3; // [m]
274 
275  // parameters for the somerton law of heat conduction
276  computeHeatCondParams_(heatCondParams_, matrixPorosity_);
277  }
278 
282 
287  std::string name() const
288  {
289  std::ostringstream oss;
290  oss << "fracture_" << Model::name();
291  return oss.str();
292  }
293 
297  void endTimeStep()
298  {
299 #ifndef NDEBUG
300  // checkConservativeness() does not include the effect of constraints, so we
301  // disable it for this problem...
302  //this->model().checkConservativeness();
303 
304  // Calculate storage terms
305  EqVector storage;
306  this->model().globalStorage(storage);
307 
308  // Write mass balance information for rank 0
309  if (this->gridView().comm().rank() == 0) {
310  std::cout << "Storage: " << storage << std::endl << std::flush;
311  }
312 #endif // NDEBUG
313  }
314 
318  template <class Context>
319  Scalar temperature(const Context& context OPM_UNUSED,
320  unsigned spaceIdx OPM_UNUSED,
321  unsigned timeIdx OPM_UNUSED) const
322  { return temperature_; }
323 
324  // \}
325 
329 
334  template <class Context>
335  const DimMatrix& intrinsicPermeability(const Context& context OPM_UNUSED,
336  unsigned spaceIdx OPM_UNUSED,
337  unsigned timeIdx OPM_UNUSED) const
338  { return matrixK_; }
339 
345  template <class Context>
346  const DimMatrix& fractureIntrinsicPermeability(const Context& context OPM_UNUSED,
347  unsigned spaceIdx OPM_UNUSED,
348  unsigned timeIdx OPM_UNUSED) const
349  { return fractureK_; }
350 
354  template <class Context>
355  Scalar porosity(const Context& context OPM_UNUSED,
356  unsigned spaceIdx OPM_UNUSED,
357  unsigned timeIdx OPM_UNUSED) const
358  { return matrixPorosity_; }
359 
365  template <class Context>
366  Scalar fracturePorosity(const Context& context OPM_UNUSED,
367  unsigned spaceIdx OPM_UNUSED,
368  unsigned timeIdx OPM_UNUSED) const
369  { return fracturePorosity_; }
370 
374  template <class Context>
375  const MaterialLawParams& materialLawParams(const Context& context OPM_UNUSED,
376  unsigned spaceIdx OPM_UNUSED,
377  unsigned timeIdx OPM_UNUSED) const
378  { return matrixMaterialParams_; }
379 
385  template <class Context>
386  const MaterialLawParams& fractureMaterialLawParams(const Context& context OPM_UNUSED,
387  unsigned spaceIdx OPM_UNUSED,
388  unsigned timeIdx OPM_UNUSED) const
389  { return fractureMaterialParams_; }
390 
395  { return this->simulator().gridManager().fractureMapper(); }
396 
409  template <class Context>
410  Scalar fractureWidth(const Context& context OPM_UNUSED,
411  unsigned spaceIdx1 OPM_UNUSED,
412  unsigned spaceIdx2 OPM_UNUSED,
413  unsigned timeIdx OPM_UNUSED) const
414  { return fractureWidth_; }
415 
419  template <class Context>
420  const HeatConductionLawParams &
421  heatConductionParams(const Context& context OPM_UNUSED,
422  unsigned spaceIdx OPM_UNUSED,
423  unsigned timeIdx OPM_UNUSED) const
424  { return heatCondParams_; }
425 
431  template <class Context>
432  Scalar heatCapacitySolid(const Context& context OPM_UNUSED,
433  unsigned spaceIdx OPM_UNUSED,
434  unsigned timeIdx OPM_UNUSED) const
435  {
436  return 790 // specific heat capacity of granite [J / (kg K)]
437  * 2700; // density of granite [kg/m^3]
438  }
439 
440  // \}
441 
445  // \{
446 
450  template <class Context>
451  void boundary(BoundaryRateVector& values, const Context& context,
452  unsigned spaceIdx, unsigned timeIdx) const
453  {
454  const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
455 
456  if (onRightBoundary_(pos)) {
457  // on the right boundary, we impose a free-flow
458  // (i.e. Dirichlet) condition
459  FluidState fluidState;
460  fluidState.setTemperature(temperature_);
461 
462  fluidState.setSaturation(wettingPhaseIdx, 0.0);
463  fluidState.setSaturation(nonWettingPhaseIdx,
464  1.0 - fluidState.saturation(wettingPhaseIdx));
465 
466  fluidState.setPressure(wettingPhaseIdx, 1e5);
467  fluidState.setPressure(nonWettingPhaseIdx, fluidState.pressure(wettingPhaseIdx));
468 
469  // set a free flow (i.e. Dirichlet) boundary
470  values.setFreeFlow(context, spaceIdx, timeIdx, fluidState);
471  }
472  else
473  // for the upper, lower and left boundaries, use a no-flow
474  // condition (i.e. a Neumann 0 condition)
475  values.setNoFlow();
476  }
477 
478  // \}
479 
483  // \{
484 
488  template <class Context>
489  void constraints(Constraints& constraints, const Context& context,
490  unsigned spaceIdx, unsigned timeIdx) const
491  {
492  const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
493 
494  if (!onLeftBoundary_(pos))
495  // only impose constraints adjacent to the left boundary
496  return;
497 
498  unsigned globalIdx = context.globalSpaceIndex(spaceIdx, timeIdx);
499  if (!fractureMapper().isFractureVertex(globalIdx)) {
500  // do not impose constraints if the finite volume does
501  // not contain fractures.
502  return;
503  }
504 
505  // if the current finite volume is on the left boundary
506  // and features a fracture, specify the fracture fluid
507  // state.
508  FluidState fractureFluidState;
509  fractureFluidState.setTemperature(temperature_ + 10.0);
510 
511  fractureFluidState.setSaturation(wettingPhaseIdx, 1.0);
512  fractureFluidState.setSaturation(nonWettingPhaseIdx,
513  1.0 - fractureFluidState.saturation(
514  wettingPhaseIdx));
515 
516  Scalar pCFracture[numPhases];
517  MaterialLaw::capillaryPressures(pCFracture, fractureMaterialParams_,
518  fractureFluidState);
519 
520  fractureFluidState.setPressure(wettingPhaseIdx, /*pressure=*/1.0e5);
521  fractureFluidState.setPressure(nonWettingPhaseIdx,
522  fractureFluidState.pressure(wettingPhaseIdx)
523  + (pCFracture[nonWettingPhaseIdx]
524  - pCFracture[wettingPhaseIdx]));
525 
526  constraints.setActive(true);
527  constraints.assignNaiveFromFracture(fractureFluidState,
528  matrixMaterialParams_);
529  }
530 
534  template <class Context>
535  void initial(PrimaryVariables& values,
536  const Context& context OPM_UNUSED,
537  unsigned spaceIdx OPM_UNUSED,
538  unsigned timeIdx OPM_UNUSED) const
539  {
540  FluidState fluidState;
541  fluidState.setTemperature(temperature_);
542  fluidState.setPressure(FluidSystem::wettingPhaseIdx, /*pressure=*/1e5);
543  fluidState.setPressure(nonWettingPhaseIdx, fluidState.pressure(wettingPhaseIdx));
544 
545  fluidState.setSaturation(wettingPhaseIdx, 0.0);
546  fluidState.setSaturation(nonWettingPhaseIdx,
547  1.0 - fluidState.saturation(wettingPhaseIdx));
548 
549  values.assignNaive(fluidState);
550  }
551 
558  template <class Context>
559  void source(RateVector& rate,
560  const Context& context OPM_UNUSED,
561  unsigned spaceIdx OPM_UNUSED,
562  unsigned timeIdx OPM_UNUSED) const
563  { rate = Scalar(0.0); }
564 
565  // \}
566 
567 private:
568  bool onLeftBoundary_(const GlobalPosition& pos) const
569  { return pos[0] < this->boundingBoxMin()[0] + eps_; }
570 
571  bool onRightBoundary_(const GlobalPosition& pos) const
572  { return pos[0] > this->boundingBoxMax()[0] - eps_; }
573 
574  bool onLowerBoundary_(const GlobalPosition& pos) const
575  { return pos[1] < this->boundingBoxMin()[1] + eps_; }
576 
577  bool onUpperBoundary_(const GlobalPosition& pos) const
578  { return pos[1] > this->boundingBoxMax()[1] - eps_; }
579 
580  void computeHeatCondParams_(HeatConductionLawParams& params, Scalar poro)
581  {
582  Scalar lambdaGranite = 2.8; // [W / (K m)]
583 
584  // create a Fluid state which has all phases present
585  Opm::ImmiscibleFluidState<Scalar, FluidSystem> fs;
586  fs.setTemperature(293.15);
587  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
588  fs.setPressure(phaseIdx, 1.0135e5);
589  }
590 
591  typename FluidSystem::template ParameterCache<Scalar> paramCache;
592  paramCache.updateAll(fs);
593  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
594  Scalar rho = FluidSystem::density(fs, paramCache, phaseIdx);
595  fs.setDensity(phaseIdx, rho);
596  }
597 
598  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
599  Scalar lambdaSaturated;
600  if (FluidSystem::isLiquid(phaseIdx)) {
601  Scalar lambdaFluid = FluidSystem::thermalConductivity(fs, paramCache, phaseIdx);
602  lambdaSaturated =
603  std::pow(lambdaGranite, (1 - poro))
604  + std::pow(lambdaFluid, poro);
605  }
606  else
607  lambdaSaturated = std::pow(lambdaGranite, (1 - poro));
608 
609  params.setFullySaturatedLambda(phaseIdx, lambdaSaturated);
610  }
611 
612  Scalar lambdaVac = std::pow(lambdaGranite, (1 - poro));
613  params.setVacuumLambda(lambdaVac);
614  }
615 
616  DimMatrix matrixK_;
617  DimMatrix fractureK_;
618 
619  Scalar matrixPorosity_;
620  Scalar fracturePorosity_;
621 
622  Scalar fractureWidth_;
623 
624  MaterialLawParams fractureMaterialParams_;
625  MaterialLawParams matrixMaterialParams_;
626 
627  HeatConductionLawParams heatCondParams_;
628 
629  Scalar temperature_;
630  Scalar eps_;
631 };
632 } // namespace Ewoms
633 
634 #endif // EWOMS_FRACTURE_PROBLEM_HH
#define SET_BOOL_PROP(EffTypeTagName, PropTagName,...)
Set a property to a simple constant boolean value.
Definition: propertysystem.hh:361
void boundary(BoundaryRateVector &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Evaluate the boundary conditions for a boundary segment.
Definition: fractureproblem.hh:451
Stores the topology of fractures.
Definition: fracturemapper.hh:42
Scalar fracturePorosity(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
The porosity inside the fractures.
Definition: fractureproblem.hh:366
Two-phase problem which involves fractures.
Definition: fractureproblem.hh:64
void constraints(Constraints &constraints, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Evaluate the constraints for a control volume.
Definition: fractureproblem.hh:489
A fully-implicit multi-phase flow model which assumes immiscibility of the phases and is able to incl...
Definition: discretefracturemodel.hh:50
#define NEW_TYPE_TAG(...)
Define a new type tag.
Definition: propertysystem.hh:169
#define GET_PROP_TYPE(TypeTag, PropTagName)
Access the type attribute of a property for a type tag.
Definition: propertysystem.hh:486
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: fractureproblem.hh:559
void endTimeStep()
Called directly after the time integration.
Definition: fractureproblem.hh:297
const HeatConductionLawParams & heatConductionParams(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:421
void initial(PrimaryVariables &values, const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Evaluate the initial value for a control volume.
Definition: fractureproblem.hh:535
#define INHERITS_FROM(...)
Syntactic sugar for NEW_TYPE_TAG.
Definition: propertysystem.hh:230
FractureProblem(Simulator &simulator)
Definition: fractureproblem.hh:223
Scalar heatCapacitySolid(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:432
Scalar temperature(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:319
void finishInit()
Called by the Ewoms::Simulator in order to initialize the problem.
Definition: fractureproblem.hh:230
Scalar porosity(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:355
std::string name() const
The problem name.
Definition: fractureproblem.hh:287
Provides a grid manager which reads Dune Grid Format (DGF) files.
Definition: dgfgridmanager.hh:56
#define SET_PROP(EffTypeTagName, PropTagName)
Set a property for a specific type tag.
Definition: propertysystem.hh:297
const MaterialLawParams & fractureMaterialLawParams(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
The parameters for the material law inside the fractures.
Definition: fractureproblem.hh:386
const DimMatrix & fractureIntrinsicPermeability(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Intrinsic permeability of fractures.
Definition: fractureproblem.hh:346
const DimMatrix & intrinsicPermeability(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:335
Manages the initializing and running of time dependent problems.
Definition: simulator.hh:75
#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
A fully-implicit multi-phase flow model which assumes immiscibility of the phases and is able to incl...
const MaterialLawParams & materialLawParams(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:375
Provides a grid manager which reads Dune Grid Format (DGF) files.
Scalar fractureWidth(const Context &context OPM_UNUSED, unsigned spaceIdx1 OPM_UNUSED, unsigned spaceIdx2 OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Returns the width of the fracture.
Definition: fractureproblem.hh:410
#define SET_SCALAR_PROP(EffTypeTagName, PropTagName,...)
Set a property to a simple constant scalar value.
Definition: propertysystem.hh:394
const FractureMapper & fractureMapper() const
Returns the object representating the fracture topology.
Definition: fractureproblem.hh:394