My Project
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 
40 #include <opm/models/discretefracture/discretefracturemodel.hh>
41 #include <opm/models/io/dgfvanguard.hh>
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/thermal/SomertonThermalConductionLaw.hpp>
49 #include <opm/material/thermal/ConstantSolidHeatCapLaw.hpp>
50 #include <opm/material/fluidsystems/TwoPhaseImmiscibleFluidSystem.hpp>
51 #include <opm/material/components/SimpleH2O.hpp>
52 #include <opm/material/components/Dnapl.hpp>
53 #include <opm/material/common/Unused.hpp>
54 
55 #include <dune/common/version.hh>
56 #include <dune/common/fmatrix.hh>
57 #include <dune/common/fvector.hh>
58 
59 #include <iostream>
60 #include <sstream>
61 #include <string>
62 
63 namespace Opm {
64 template <class TypeTag>
65 class FractureProblem;
66 }
67 
68 namespace Opm::Properties {
69 
70 // Create a type tag for the problem
71 // Create new type tags
72 namespace TTag {
73 struct FractureProblem { using InheritsFrom = std::tuple<DiscreteFractureModel>; };
74 } // end namespace TTag
75 
76 // Set the grid type
77 template<class TypeTag>
78 struct Grid<TypeTag, TTag::FractureProblem>
79 { using type = Dune::ALUGrid</*dim=*/2, /*dimWorld=*/2, Dune::simplex, Dune::nonconforming>; };
80 
81 // Set the Vanguard property
82 template<class TypeTag>
83 struct Vanguard<TypeTag, TTag::FractureProblem> { using type = Opm::DgfVanguard<TypeTag>; };
84 
85 // Set the problem property
86 template<class TypeTag>
87 struct Problem<TypeTag, TTag::FractureProblem> { using type = Opm::FractureProblem<TypeTag>; };
88 
89 // Set the wetting phase
90 template<class TypeTag>
91 struct WettingPhase<TypeTag, TTag::FractureProblem>
92 {
93 private:
94  using Scalar = GetPropType<TypeTag, Properties::Scalar>;
95 
96 public:
97  using type = Opm::LiquidPhase<Scalar, Opm::SimpleH2O<Scalar> >;
98 };
99 
100 // Set the non-wetting phase
101 template<class TypeTag>
102 struct NonwettingPhase<TypeTag, TTag::FractureProblem>
103 {
104 private:
105  using Scalar = GetPropType<TypeTag, Properties::Scalar>;
106 
107 public:
108  using type = Opm::LiquidPhase<Scalar, Opm::DNAPL<Scalar> >;
109 };
110 
111 // Set the material Law
112 template<class TypeTag>
113 struct MaterialLaw<TypeTag, TTag::FractureProblem>
114 {
115 private:
116  using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
117  enum { wettingPhaseIdx = FluidSystem::wettingPhaseIdx };
118  enum { nonWettingPhaseIdx = FluidSystem::nonWettingPhaseIdx };
119 
120  using Scalar = GetPropType<TypeTag, Properties::Scalar>;
121  using Traits = Opm::TwoPhaseMaterialTraits<Scalar,
122  /*wettingPhaseIdx=*/FluidSystem::wettingPhaseIdx,
123  /*nonWettingPhaseIdx=*/FluidSystem::nonWettingPhaseIdx>;
124 
125  // define the material law which is parameterized by effective
126  // saturations
127  using EffectiveLaw = Opm::RegularizedBrooksCorey<Traits>;
128  // using EffectiveLaw = RegularizedVanGenuchten<Traits>;
129  // using EffectiveLaw = LinearMaterial<Traits>;
130 public:
131  using type = Opm::EffToAbsLaw<EffectiveLaw>;
132 };
133 
134 // Enable the energy equation
135 template<class TypeTag>
136 struct EnableEnergy<TypeTag, TTag::FractureProblem> { static constexpr bool value = true; };
137 
138 // Set the thermal conduction law
139 template<class TypeTag>
140 struct ThermalConductionLaw<TypeTag, TTag::FractureProblem>
141 {
142 private:
143  using Scalar = GetPropType<TypeTag, Properties::Scalar>;
144  using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
145 
146 public:
147  // define the material law parameterized by absolute saturations
148  using type = Opm::SomertonThermalConductionLaw<FluidSystem, Scalar>;
149 };
150 
151 // set the energy storage law for the solid phase
152 template<class TypeTag>
153 struct SolidEnergyLaw<TypeTag, TTag::FractureProblem>
154 { using type = Opm::ConstantSolidHeatCapLaw<GetPropType<TypeTag, Properties::Scalar>>; };
155 
156 // Disable gravity
157 template<class TypeTag>
158 struct EnableGravity<TypeTag, TTag::FractureProblem> { static constexpr bool value = false; };
159 
160 // For this problem, we use constraints to specify the left boundary
161 template<class TypeTag>
162 struct EnableConstraints<TypeTag, TTag::FractureProblem> { static constexpr bool value = true; };
163 
164 // Set the default value for the file name of the grid
165 template<class TypeTag>
166 struct GridFile<TypeTag, TTag::FractureProblem> { static constexpr auto value = "data/fracture.art.dgf"; };
167 
168 // Set the default value for the end time
169 template<class TypeTag>
170 struct EndTime<TypeTag, TTag::FractureProblem>
171 {
172  using type = GetPropType<TypeTag, Scalar>;
173  static constexpr type value = 3e3;
174 };
175 
176 // Set the default value for the initial time step size
177 template<class TypeTag>
178 struct InitialTimeStepSize<TypeTag, TTag::FractureProblem>
179 {
180  using type = GetPropType<TypeTag, Scalar>;
181  static constexpr type value = 100;
182 };
183 
184 } // namespace Opm::Properties
185 
186 namespace Opm {
199 template <class TypeTag>
200 class FractureProblem : public GetPropType<TypeTag, Properties::BaseProblem>
201 {
202  using ParentType = GetPropType<TypeTag, Properties::BaseProblem>;
203  using GridView = GetPropType<TypeTag, Properties::GridView>;
204  using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
205  using WettingPhase = GetPropType<TypeTag, Properties::WettingPhase>;
206  using NonwettingPhase = GetPropType<TypeTag, Properties::NonwettingPhase>;
207  using Constraints = GetPropType<TypeTag, Properties::Constraints>;
208  using EqVector = GetPropType<TypeTag, Properties::EqVector>;
209  using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
210  using BoundaryRateVector = GetPropType<TypeTag, Properties::BoundaryRateVector>;
211  using RateVector = GetPropType<TypeTag, Properties::RateVector>;
212  using Simulator = GetPropType<TypeTag, Properties::Simulator>;
213  using Scalar = GetPropType<TypeTag, Properties::Scalar>;
214  using MaterialLaw = GetPropType<TypeTag, Properties::MaterialLaw>;
215  using MaterialLawParams = GetPropType<TypeTag, Properties::MaterialLawParams>;
216  using ThermalConductionLawParams = GetPropType<TypeTag, Properties::ThermalConductionLawParams>;
217  using SolidEnergyLawParams = GetPropType<TypeTag, Properties::SolidEnergyLawParams>;
218  using Model = GetPropType<TypeTag, Properties::Model>;
219 
220  enum {
221  // phase indices
222  wettingPhaseIdx = MaterialLaw::wettingPhaseIdx,
223  nonWettingPhaseIdx = MaterialLaw::nonWettingPhaseIdx,
224 
225  // number of phases
226  numPhases = FluidSystem::numPhases,
227 
228  // Grid and world dimension
229  dim = GridView::dimension,
230  dimWorld = GridView::dimensionworld
231  };
232 
233  using FluidState = Opm::ImmiscibleFluidState<Scalar, FluidSystem>;
234 
235  using GlobalPosition = Dune::FieldVector<Scalar, dimWorld>;
236  using DimMatrix = Dune::FieldMatrix<Scalar, dimWorld, dimWorld>;
237 
238  template <int dim>
239  struct FaceLayout
240  {
241  bool contains(Dune::GeometryType gt)
242  { return gt.dim() == dim - 1; }
243  };
244  using FaceMapper = Dune::MultipleCodimMultipleGeomTypeMapper<GridView>;
245 
246  using FractureMapper = Opm::FractureMapper<TypeTag>;
247 
248 public:
252  FractureProblem(Simulator& simulator)
253  : ParentType(simulator)
254  { }
255 
259  void finishInit()
260  {
261  ParentType::finishInit();
262 
263  eps_ = 3e-6;
264  temperature_ = 273.15 + 20; // -> 20°C
265 
266  matrixMaterialParams_.setResidualSaturation(wettingPhaseIdx, 0.0);
267  matrixMaterialParams_.setResidualSaturation(nonWettingPhaseIdx, 0.0);
268  fractureMaterialParams_.setResidualSaturation(wettingPhaseIdx, 0.0);
269  fractureMaterialParams_.setResidualSaturation(nonWettingPhaseIdx, 0.0);
270 
271 #if 0 // linear
272  matrixMaterialParams_.setEntryPC(0.0);
273  matrixMaterialParams_.setMaxPC(2000.0);
274  fractureMaterialParams_.setEntryPC(0.0);
275  fractureMaterialParams_.setMaxPC(1000.0);
276 #endif
277 
278 #if 1 // Brooks-Corey
279  matrixMaterialParams_.setEntryPressure(2000);
280  matrixMaterialParams_.setLambda(2.0);
281  matrixMaterialParams_.setPcLowSw(1e-1);
282  fractureMaterialParams_.setEntryPressure(1000);
283  fractureMaterialParams_.setLambda(2.0);
284  fractureMaterialParams_.setPcLowSw(5e-2);
285 #endif
286 
287 #if 0 // van Genuchten
288  matrixMaterialParams_.setVgAlpha(0.0037);
289  matrixMaterialParams_.setVgN(4.7);
290  fractureMaterialParams_.setVgAlpha(0.0025);
291  fractureMaterialParams_.setVgN(4.7);
292 #endif
293 
294  matrixMaterialParams_.finalize();
295  fractureMaterialParams_.finalize();
296 
297  matrixK_ = this->toDimMatrix_(1e-15); // m^2
298  fractureK_ = this->toDimMatrix_(1e5 * 1e-15); // m^2
299 
300  matrixPorosity_ = 0.10;
301  fracturePorosity_ = 0.25;
302  fractureWidth_ = 1e-3; // [m]
303 
304  // initialize the energy-related parameters
305  initEnergyParams_(thermalConductionParams_, matrixPorosity_);
306  }
307 
312 
316  std::string name() const
317  {
318  std::ostringstream oss;
319  oss << "fracture_" << Model::name();
320  return oss.str();
321  }
322 
326  void endTimeStep()
327  {
328 #ifndef NDEBUG
329  // checkConservativeness() does not include the effect of constraints, so we
330  // disable it for this problem...
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 
347  template <class Context>
348  Scalar temperature(const Context& context OPM_UNUSED,
349  unsigned spaceIdx OPM_UNUSED,
350  unsigned timeIdx OPM_UNUSED) const
351  { return temperature_; }
352 
353  // \}
354 
359 
363  template <class Context>
364  const DimMatrix& intrinsicPermeability(const Context& context OPM_UNUSED,
365  unsigned spaceIdx OPM_UNUSED,
366  unsigned timeIdx OPM_UNUSED) const
367  { return matrixK_; }
368 
374  template <class Context>
375  const DimMatrix& fractureIntrinsicPermeability(const Context& context OPM_UNUSED,
376  unsigned spaceIdx OPM_UNUSED,
377  unsigned timeIdx OPM_UNUSED) const
378  { return fractureK_; }
379 
383  template <class Context>
384  Scalar porosity(const Context& context OPM_UNUSED,
385  unsigned spaceIdx OPM_UNUSED,
386  unsigned timeIdx OPM_UNUSED) const
387  { return matrixPorosity_; }
388 
394  template <class Context>
395  Scalar fracturePorosity(const Context& context OPM_UNUSED,
396  unsigned spaceIdx OPM_UNUSED,
397  unsigned timeIdx OPM_UNUSED) const
398  { return fracturePorosity_; }
399 
403  template <class Context>
404  const MaterialLawParams& materialLawParams(const Context& context OPM_UNUSED,
405  unsigned spaceIdx OPM_UNUSED,
406  unsigned timeIdx OPM_UNUSED) const
407  { return matrixMaterialParams_; }
408 
414  template <class Context>
415  const MaterialLawParams& fractureMaterialLawParams(const Context& context OPM_UNUSED,
416  unsigned spaceIdx OPM_UNUSED,
417  unsigned timeIdx OPM_UNUSED) const
418  { return fractureMaterialParams_; }
419 
423  const FractureMapper& fractureMapper() const
424  { return this->simulator().vanguard().fractureMapper(); }
425 
438  template <class Context>
439  Scalar fractureWidth(const Context& context OPM_UNUSED,
440  unsigned spaceIdx1 OPM_UNUSED,
441  unsigned spaceIdx2 OPM_UNUSED,
442  unsigned timeIdx OPM_UNUSED) const
443  { return fractureWidth_; }
444 
448  template <class Context>
449  const ThermalConductionLawParams&
450  thermalConductionLawParams(const Context& context OPM_UNUSED,
451  unsigned spaceIdx OPM_UNUSED,
452  unsigned timeIdx OPM_UNUSED) const
453  { return thermalConductionParams_; }
454 
460  template <class Context>
461  const SolidEnergyLawParams&
462  solidEnergyLawParams(const Context& context OPM_UNUSED,
463  unsigned spaceIdx OPM_UNUSED,
464  unsigned timeIdx OPM_UNUSED) const
465  { return solidEnergyParams_; }
466 
467  // \}
468 
472  // \{
473 
477  template <class Context>
478  void boundary(BoundaryRateVector& values, const Context& context,
479  unsigned spaceIdx, unsigned timeIdx) const
480  {
481  const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
482 
483  if (onRightBoundary_(pos)) {
484  // on the right boundary, we impose a free-flow
485  // (i.e. Dirichlet) condition
486  FluidState fluidState;
487  fluidState.setTemperature(temperature_);
488 
489  fluidState.setSaturation(wettingPhaseIdx, 0.0);
490  fluidState.setSaturation(nonWettingPhaseIdx,
491  1.0 - fluidState.saturation(wettingPhaseIdx));
492 
493  fluidState.setPressure(wettingPhaseIdx, 1e5);
494  fluidState.setPressure(nonWettingPhaseIdx, fluidState.pressure(wettingPhaseIdx));
495 
496  typename FluidSystem::template ParameterCache<Scalar> paramCache;
497  paramCache.updateAll(fluidState);
498  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) {
499  fluidState.setDensity(phaseIdx,
500  FluidSystem::density(fluidState, paramCache, phaseIdx));
501  fluidState.setViscosity(phaseIdx,
502  FluidSystem::viscosity(fluidState, paramCache, phaseIdx));
503  }
504 
505  // set a free flow (i.e. Dirichlet) boundary
506  values.setFreeFlow(context, spaceIdx, timeIdx, fluidState);
507  }
508  else
509  // for the upper, lower and left boundaries, use a no-flow
510  // condition (i.e. a Neumann 0 condition)
511  values.setNoFlow();
512  }
513 
514  // \}
515 
519  // \{
520 
524  template <class Context>
525  void constraints(Constraints& constraints, const Context& context,
526  unsigned spaceIdx, unsigned timeIdx) const
527  {
528  const GlobalPosition& pos = context.pos(spaceIdx, timeIdx);
529 
530  if (!onLeftBoundary_(pos))
531  // only impose constraints adjacent to the left boundary
532  return;
533 
534  unsigned globalIdx = context.globalSpaceIndex(spaceIdx, timeIdx);
535  if (!fractureMapper().isFractureVertex(globalIdx)) {
536  // do not impose constraints if the finite volume does
537  // not contain fractures.
538  return;
539  }
540 
541  // if the current finite volume is on the left boundary
542  // and features a fracture, specify the fracture fluid
543  // state.
544  FluidState fractureFluidState;
545  fractureFluidState.setTemperature(temperature_ + 10.0);
546 
547  fractureFluidState.setSaturation(wettingPhaseIdx, 1.0);
548  fractureFluidState.setSaturation(nonWettingPhaseIdx,
549  1.0 - fractureFluidState.saturation(
550  wettingPhaseIdx));
551 
552  Scalar pCFracture[numPhases];
553  MaterialLaw::capillaryPressures(pCFracture, fractureMaterialParams_,
554  fractureFluidState);
555 
556  fractureFluidState.setPressure(wettingPhaseIdx, /*pressure=*/1.0e5);
557  fractureFluidState.setPressure(nonWettingPhaseIdx,
558  fractureFluidState.pressure(wettingPhaseIdx)
559  + (pCFracture[nonWettingPhaseIdx]
560  - pCFracture[wettingPhaseIdx]));
561 
562  constraints.setActive(true);
563  constraints.assignNaiveFromFracture(fractureFluidState,
564  matrixMaterialParams_);
565  }
566 
570  template <class Context>
571  void initial(PrimaryVariables& values,
572  const Context& context OPM_UNUSED,
573  unsigned spaceIdx OPM_UNUSED,
574  unsigned timeIdx OPM_UNUSED) const
575  {
576  FluidState fluidState;
577  fluidState.setTemperature(temperature_);
578  fluidState.setPressure(FluidSystem::wettingPhaseIdx, /*pressure=*/1e5);
579  fluidState.setPressure(nonWettingPhaseIdx, fluidState.pressure(wettingPhaseIdx));
580 
581  fluidState.setSaturation(wettingPhaseIdx, 0.0);
582  fluidState.setSaturation(nonWettingPhaseIdx,
583  1.0 - fluidState.saturation(wettingPhaseIdx));
584 
585  values.assignNaive(fluidState);
586  }
587 
594  template <class Context>
595  void source(RateVector& rate,
596  const Context& context OPM_UNUSED,
597  unsigned spaceIdx OPM_UNUSED,
598  unsigned timeIdx OPM_UNUSED) const
599  { rate = Scalar(0.0); }
600 
601  // \}
602 
603 private:
604  bool onLeftBoundary_(const GlobalPosition& pos) const
605  { return pos[0] < this->boundingBoxMin()[0] + eps_; }
606 
607  bool onRightBoundary_(const GlobalPosition& pos) const
608  { return pos[0] > this->boundingBoxMax()[0] - eps_; }
609 
610  bool onLowerBoundary_(const GlobalPosition& pos) const
611  { return pos[1] < this->boundingBoxMin()[1] + eps_; }
612 
613  bool onUpperBoundary_(const GlobalPosition& pos) const
614  { return pos[1] > this->boundingBoxMax()[1] - eps_; }
615 
616  void initEnergyParams_(ThermalConductionLawParams& params, Scalar poro)
617  {
618  // assume the volumetric heat capacity of granite
619  solidEnergyParams_.setSolidHeatCapacity(790.0 // specific heat capacity of granite [J / (kg K)]
620  * 2700.0); // density of granite [kg/m^3]
621  solidEnergyParams_.finalize();
622 
623  Scalar lambdaGranite = 2.8; // [W / (K m)]
624 
625  // create a Fluid state which has all phases present
626  Opm::ImmiscibleFluidState<Scalar, FluidSystem> fs;
627  fs.setTemperature(293.15);
628  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
629  fs.setPressure(phaseIdx, 1.0135e5);
630  }
631 
632  typename FluidSystem::template ParameterCache<Scalar> paramCache;
633  paramCache.updateAll(fs);
634  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
635  Scalar rho = FluidSystem::density(fs, paramCache, phaseIdx);
636  fs.setDensity(phaseIdx, rho);
637  }
638 
639  for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
640  Scalar lambdaSaturated;
641  if (FluidSystem::isLiquid(phaseIdx)) {
642  Scalar lambdaFluid = FluidSystem::thermalConductivity(fs, paramCache, phaseIdx);
643  lambdaSaturated =
644  std::pow(lambdaGranite, (1 - poro))
645  + std::pow(lambdaFluid, poro);
646  }
647  else
648  lambdaSaturated = std::pow(lambdaGranite, (1 - poro));
649 
650  params.setFullySaturatedLambda(phaseIdx, lambdaSaturated);
651  }
652 
653  Scalar lambdaVac = std::pow(lambdaGranite, (1 - poro));
654  params.setVacuumLambda(lambdaVac);
655  }
656 
657  DimMatrix matrixK_;
658  DimMatrix fractureK_;
659 
660  Scalar matrixPorosity_;
661  Scalar fracturePorosity_;
662 
663  Scalar fractureWidth_;
664 
665  MaterialLawParams fractureMaterialParams_;
666  MaterialLawParams matrixMaterialParams_;
667 
668  ThermalConductionLawParams thermalConductionParams_;
669  SolidEnergyLawParams solidEnergyParams_;
670 
671  Scalar temperature_;
672  Scalar eps_;
673 };
674 } // namespace Opm
675 
676 #endif // EWOMS_FRACTURE_PROBLEM_HH
Two-phase problem which involves fractures.
Definition: fractureproblem.hh:201
void initial(PrimaryVariables &values, const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:571
const MaterialLawParams & materialLawParams(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:404
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:415
Scalar temperature(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:348
const ThermalConductionLawParams & thermalConductionLawParams(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:450
void finishInit()
Definition: fractureproblem.hh:259
std::string name() const
Definition: fractureproblem.hh:316
FractureProblem(Simulator &simulator)
Definition: fractureproblem.hh:252
void constraints(Constraints &constraints, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:525
void source(RateVector &rate, const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:595
const DimMatrix & intrinsicPermeability(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:364
const DimMatrix & fractureIntrinsicPermeability(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Intrinsic permeability of fractures.
Definition: fractureproblem.hh:375
void endTimeStep()
Called directly after the time integration.
Definition: fractureproblem.hh:326
const SolidEnergyLawParams & solidEnergyLawParams(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Return the parameters for the energy storage law of the rock.
Definition: fractureproblem.hh:462
Scalar porosity(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
Definition: fractureproblem.hh:384
const FractureMapper & fractureMapper() const
Returns the object representating the fracture topology.
Definition: fractureproblem.hh:423
void boundary(BoundaryRateVector &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:478
Scalar fracturePorosity(const Context &context OPM_UNUSED, unsigned spaceIdx OPM_UNUSED, unsigned timeIdx OPM_UNUSED) const
The porosity inside the fractures.
Definition: fractureproblem.hh:395
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:439
Definition: fractureproblem.hh:73