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