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
62namespace Opm {
63template <class TypeTag>
64class FractureProblem;
65}
66
67namespace Opm::Properties {
68
69// Create a type tag for the problem
70// Create new type tags
71namespace TTag {
72struct FractureProblem { using InheritsFrom = std::tuple<DiscreteFractureModel>; };
73} // end namespace TTag
74
75// Set the grid type
76template<class TypeTag>
77struct Grid<TypeTag, TTag::FractureProblem>
78{ using type = Dune::ALUGrid</*dim=*/2, /*dimWorld=*/2, Dune::simplex, Dune::nonconforming>; };
79
80// Set the Vanguard property
81template<class TypeTag>
82struct Vanguard<TypeTag, TTag::FractureProblem> { using type = Opm::DgfVanguard<TypeTag>; };
83
84// Set the problem property
85template<class TypeTag>
86struct Problem<TypeTag, TTag::FractureProblem> { using type = Opm::FractureProblem<TypeTag>; };
87
88// Set the wetting phase
89template<class TypeTag>
90struct WettingPhase<TypeTag, TTag::FractureProblem>
91{
92private:
93 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
94
95public:
96 using type = Opm::LiquidPhase<Scalar, Opm::SimpleH2O<Scalar> >;
97};
98
99// Set the non-wetting phase
100template<class TypeTag>
101struct NonwettingPhase<TypeTag, TTag::FractureProblem>
102{
103private:
104 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
105
106public:
107 using type = Opm::LiquidPhase<Scalar, Opm::DNAPL<Scalar> >;
108};
109
110// Set the material Law
111template<class TypeTag>
112struct MaterialLaw<TypeTag, TTag::FractureProblem>
113{
114private:
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>;
129public:
130 using type = Opm::EffToAbsLaw<EffectiveLaw>;
131};
132
133// Enable the energy equation
134template<class TypeTag>
135struct EnableEnergy<TypeTag, TTag::FractureProblem> { static constexpr bool value = true; };
136
137// Set the thermal conduction law
138template<class TypeTag>
139struct ThermalConductionLaw<TypeTag, TTag::FractureProblem>
140{
141private:
142 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
143 using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
144
145public:
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
151template<class TypeTag>
152struct SolidEnergyLaw<TypeTag, TTag::FractureProblem>
153{ using type = Opm::ConstantSolidHeatCapLaw<GetPropType<TypeTag, Properties::Scalar>>; };
154
155// Disable gravity
156template<class TypeTag>
157struct EnableGravity<TypeTag, TTag::FractureProblem> { static constexpr bool value = false; };
158
159// For this problem, we use constraints to specify the left boundary
160template<class TypeTag>
161struct EnableConstraints<TypeTag, TTag::FractureProblem> { static constexpr bool value = true; };
162
163// Set the default value for the file name of the grid
164template<class TypeTag>
165struct GridFile<TypeTag, TTag::FractureProblem> { static constexpr auto value = "data/fracture.art.dgf"; };
166
167// Set the default value for the end time
168template<class TypeTag>
169struct 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
176template<class TypeTag>
177struct InitialTimeStepSize<TypeTag, TTag::FractureProblem>
178{
179 using type = GetPropType<TypeTag, Scalar>;
180 static constexpr type value = 100;
181};
182
183} // namespace Opm::Properties
184
185namespace Opm {
198template <class TypeTag>
199class 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
247public:
251 FractureProblem(Simulator& simulator)
252 : ParentType(simulator)
253 { }
254
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
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
602private:
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
const SolidEnergyLawParams & solidEnergyLawParams(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Return the parameters for the energy storage law of the rock.
Definition: fractureproblem.hh:461
const DimMatrix & intrinsicPermeability(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:363
Scalar fractureWidth(const Context &context, unsigned spaceIdx1, unsigned spaceIdx2, unsigned timeIdx) const
Returns the width of the fracture.
Definition: fractureproblem.hh:438
void initial(PrimaryVariables &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:570
Scalar fracturePorosity(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
The porosity inside the fractures.
Definition: fractureproblem.hh:394
void finishInit()
Definition: fractureproblem.hh:258
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 & fractureIntrinsicPermeability(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Intrinsic permeability of fractures.
Definition: fractureproblem.hh:374
const MaterialLawParams & materialLawParams(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:403
void endTimeStep()
Called directly after the time integration.
Definition: fractureproblem.hh:325
const ThermalConductionLawParams & thermalConductionLawParams(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:449
void source(RateVector &rate, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:594
const MaterialLawParams & fractureMaterialLawParams(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
The parameters for the material law inside the fractures.
Definition: fractureproblem.hh:414
Scalar temperature(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:347
void boundary(BoundaryRateVector &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:477
const FractureMapper & fractureMapper() const
Returns the object representating the fracture topology.
Definition: fractureproblem.hh:422
Scalar porosity(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition: fractureproblem.hh:383
Definition: fractureproblem.hh:72