My Project
Loading...
Searching...
No Matches
co2ptflashproblem.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 OPM_CO2PTFLASH_PROBLEM_HH
29#define OPM_CO2PTFLASH_PROBLEM_HH
30
31#include <opm/common/Exceptions.hpp>
32
33#include <opm/material/components/SimpleCO2.hpp>
34#include <opm/material/components/C10.hpp>
35#include <opm/material/components/C1.hpp>
36#include <opm/material/fluidmatrixinteractions/RegularizedBrooksCorey.hpp>
37#include <opm/material/fluidmatrixinteractions/BrooksCorey.hpp>
38#include <opm/material/constraintsolvers/PTFlash.hpp>
39#include <opm/material/fluidsystems/GenericOilGasFluidSystem.hpp>
40#include <opm/material/common/Valgrind.hpp>
41#include <opm/models/immiscible/immisciblemodel.hh>
42#include <opm/models/discretization/ecfv/ecfvdiscretization.hh>
43#include <opm/models/ptflash/flashmodel.hh>
44#include <opm/models/io/structuredgridvanguard.hh>
45#include <opm/models/utils/propertysystem.hh>
46#include <opm/models/utils/start.hh>
47#include <opm/simulators/linalg/parallelistlbackend.hh>
48#include <opm/simulators/linalg/parallelbicgstabbackend.hh>
49#include <dune/grid/yaspgrid.hh>
50#include <dune/grid/io/file/dgfparser/dgfyasp.hh>
51#include <dune/common/version.hh>
52#include <dune/common/fvector.hh>
53#include <dune/common/fmatrix.hh>
54
55#include <sstream>
56#include <iostream>
57#include <string>
58
59namespace Opm {
60template <class TypeTag>
61class CO2PTProblem;
62} // namespace Opm */
63
64namespace Opm::Properties {
65
66namespace TTag {
68} // end namespace TTag
69
70template <class TypeTag, class MyTypeTag>
71struct Temperature { using type = UndefinedProperty; };
72template <class TypeTag, class MyTypeTag>
73struct SimulationName { using type = UndefinedProperty; };
74template <class TypeTag, class MyTypeTag>
75struct EpisodeLength { using type = UndefinedProperty;};
76
77template <class TypeTag, class MyTypeTag>
78struct Initialpressure { using type = UndefinedProperty;};
79
80template <class TypeTag, class MyTypeTag>
81struct NumComp { using type = UndefinedProperty; };
82
83template <class TypeTag>
84struct NumComp<TypeTag, TTag::CO2PTBaseProblem> {
85 static constexpr int value = 3;
86};
87
88// Set the grid type: --->2D
89template <class TypeTag>
90struct Grid<TypeTag, TTag::CO2PTBaseProblem> { using type = Dune::YaspGrid</*dim=*/2>; };
91
92// Set the problem property
93template <class TypeTag>
94struct Problem<TypeTag, TTag::CO2PTBaseProblem>
95{ using type = Opm::CO2PTProblem<TypeTag>; };
96
97// Set flash solver
98template <class TypeTag>
99struct FlashSolver<TypeTag, TTag::CO2PTBaseProblem> {
100private:
101 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
102 using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
103 using Evaluation = GetPropType<TypeTag, Properties::Evaluation>;
104
105public:
106 using type = Opm::PTFlash<Scalar, FluidSystem>;
107};
108
109// Set fluid configuration
110template <class TypeTag>
111struct FluidSystem<TypeTag, TTag::CO2PTBaseProblem>
112{
113private:
114 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
115 static constexpr int num_comp = getPropValue<TypeTag, Properties::NumComp>();
116
117public:
118 using type = Opm::GenericOilGasFluidSystem<Scalar, num_comp>;
119};
120
121// Set the material Law
122template <class TypeTag>
123struct MaterialLaw<TypeTag, TTag::CO2PTBaseProblem> {
124private:
125 using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
126 enum { oilPhaseIdx = FluidSystem::oilPhaseIdx };
127 enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
128
129 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
130 using Traits = Opm::TwoPhaseMaterialTraits<Scalar,
131 // /*wettingPhaseIdx=*/FluidSystem::waterPhaseIdx, // TODO
132 /*nonWettingPhaseIdx=*/FluidSystem::oilPhaseIdx,
133 /*gasPhaseIdx=*/FluidSystem::gasPhaseIdx>;
134
135 // define the material law which is parameterized by effective saturation
136 using EffMaterialLaw = Opm::NullMaterial<Traits>;
137 //using EffMaterialLaw = Opm::BrooksCorey<Traits>;
138
139public:
140 using type = EffMaterialLaw;
141};
142
143// Write the Newton convergence behavior to disk?
144template <class TypeTag>
145struct NewtonWriteConvergence<TypeTag, TTag::CO2PTBaseProblem> {
146static constexpr bool value = false; };
147
148// Enable gravity false
149template <class TypeTag>
150struct EnableGravity<TypeTag, TTag::CO2PTBaseProblem> { static constexpr bool value = false;
151};
152
153// set the defaults for the problem specific properties
154 template <class TypeTag>
155 struct Temperature<TypeTag, TTag::CO2PTBaseProblem> {
156 using type = GetPropType<TypeTag, Scalar>;
157 static constexpr type value = 423.25;//TODO
158 };
159
160template <class TypeTag>
161struct Initialpressure<TypeTag, TTag::CO2PTBaseProblem> {
162 using type = GetPropType<TypeTag, Scalar>;
163 static constexpr type value = 75.e5;
164};
165
166template <class TypeTag>
167struct SimulationName<TypeTag, TTag::CO2PTBaseProblem> {
168 static constexpr auto value = "co2_ptflash";
169};
170
171// The default for the end time of the simulation
172template <class TypeTag>
173struct EndTime<TypeTag, TTag::CO2PTBaseProblem> {
174 using type = GetPropType<TypeTag, Scalar>;
175 static constexpr type value = 60. * 60.;
176};
177
178// convergence control
179template <class TypeTag>
180struct InitialTimeStepSize<TypeTag, TTag::CO2PTBaseProblem> {
181 using type = GetPropType<TypeTag, Scalar>;
182 static constexpr type value = 0.1 * 60. * 60.;
183};
184
185template <class TypeTag>
186struct LinearSolverTolerance<TypeTag, TTag::CO2PTBaseProblem> {
187 using type = GetPropType<TypeTag, Scalar>;
188 static constexpr type value = 1e-3;
189};
190
191template <class TypeTag>
192struct LinearSolverAbsTolerance<TypeTag, TTag::CO2PTBaseProblem> {
193 using type = GetPropType<TypeTag, Scalar>;
194 static constexpr type value = 0.;
195};
196
197template <class TypeTag>
198struct NewtonTolerance<TypeTag, TTag::CO2PTBaseProblem> {
199 using type = GetPropType<TypeTag, Scalar>;
200 static constexpr type value = 1e-3;
201};
202
203template <class TypeTag>
204struct NewtonMaxIterations<TypeTag, TTag::CO2PTBaseProblem> {
205 static constexpr int value = 30;
206};
207
208template <class TypeTag>
209struct NewtonTargetIterations<TypeTag, TTag::CO2PTBaseProblem> {
210 using type = GetPropType<TypeTag, Scalar>;
211 static constexpr type value = 6;
212};
213
214// output
215template <class TypeTag>
216struct VtkWriteFilterVelocities<TypeTag, TTag::CO2PTBaseProblem> {
217 static constexpr bool value = true;
218};
219
220template <class TypeTag>
221struct VtkWritePotentialGradients<TypeTag, TTag::CO2PTBaseProblem> {
222 static constexpr bool value = true;
223};
224
225template <class TypeTag>
226struct VtkWriteTotalMassFractions<TypeTag, TTag::CO2PTBaseProblem> {
227 static constexpr bool value = true;
228};
229
230template <class TypeTag>
231struct VtkWriteTotalMoleFractions<TypeTag, TTag::CO2PTBaseProblem> {
232 static constexpr bool value = true;
233};
234
235template <class TypeTag>
236struct VtkWriteFugacityCoeffs<TypeTag, TTag::CO2PTBaseProblem> {
237 static constexpr bool value = true;
238};
239
240template <class TypeTag>
241struct VtkWriteLiquidMoleFractions<TypeTag, TTag::CO2PTBaseProblem> {
242 static constexpr bool value = true;
243};
244
245template <class TypeTag>
246struct VtkWriteEquilibriumConstants<TypeTag, TTag::CO2PTBaseProblem> {
247 static constexpr bool value = true;
248};
249
250// this is kinds of telling the report step length
251template <class TypeTag>
252struct EpisodeLength<TypeTag, TTag::CO2PTBaseProblem> {
253 using type = GetPropType<TypeTag, Scalar>;
254 static constexpr type value = 0.1 * 60. * 60.;
255};
256
257// mesh grid
258template <class TypeTag>
259struct Vanguard<TypeTag, TTag::CO2PTBaseProblem> {
260 using type = Opm::StructuredGridVanguard<TypeTag>;
261};
262
263//\Note: from the Julia code, the problem is a 1D problem with 3X1 cell.
264//\Note: DomainSizeX is 3.0 meters
265//\Note: DomainSizeY is 1.0 meters
266template <class TypeTag>
267struct DomainSizeX<TypeTag, TTag::CO2PTBaseProblem> {
268 using type = GetPropType<TypeTag, Scalar>;
269 static constexpr type value = 300; // meter
270};
271
272template <class TypeTag>
273struct DomainSizeY<TypeTag, TTag::CO2PTBaseProblem> {
274 using type = GetPropType<TypeTag, Scalar>;
275 static constexpr type value = 1.0;
276};
277
278// DomainSizeZ is not needed, while to keep structuredgridvanguard.hh compile
279template <class TypeTag>
280struct DomainSizeZ<TypeTag, TTag::CO2PTBaseProblem> {
281 using type = GetPropType<TypeTag, Scalar>;
282 static constexpr type value = 1.0;
283};
284
285template<class TypeTag>
286struct CellsX<TypeTag, TTag::CO2PTBaseProblem> { static constexpr unsigned value = 30; };
287template<class TypeTag>
288struct CellsY<TypeTag, TTag::CO2PTBaseProblem> { static constexpr unsigned value = 1; };
289// CellsZ is not needed, while to keep structuredgridvanguard.hh compile
290template<class TypeTag>
291struct CellsZ<TypeTag, TTag::CO2PTBaseProblem> { static constexpr unsigned value = 1; };
292
293template <class TypeTag>
294struct EnableEnergy<TypeTag, TTag::CO2PTBaseProblem> {
295 static constexpr bool value = false;
296};
297
298} // namespace Opm::Properties
299
300
301
302
303namespace Opm {
310template <class TypeTag>
311class CO2PTProblem : public GetPropType<TypeTag, Properties::BaseProblem>
312{
313 using ParentType = GetPropType<TypeTag, Properties::BaseProblem>;
314
315 using Scalar = GetPropType<TypeTag, Properties::Scalar>;
316 using Evaluation = GetPropType<TypeTag, Properties::Evaluation>;
317 using GridView = GetPropType<TypeTag, Properties::GridView>;
318 using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
319 enum { dim = GridView::dimension };
320 enum { dimWorld = GridView::dimensionworld };
321 using Indices = GetPropType<TypeTag, Properties::Indices>;
322 using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
323 using RateVector = GetPropType<TypeTag, Properties::RateVector>;
324 using BoundaryRateVector = GetPropType<TypeTag, Properties::BoundaryRateVector>;
325 using MaterialLaw = GetPropType<TypeTag, Properties::MaterialLaw>;
326 using Simulator = GetPropType<TypeTag, Properties::Simulator>;
327 using Model = GetPropType<TypeTag, Properties::Model>;
328 using MaterialLawParams = GetPropType<TypeTag, Properties::MaterialLawParams>;
329
330 using Toolbox = Opm::MathToolbox<Evaluation>;
331 using CoordScalar = typename GridView::ctype;
332
333 enum { numPhases = FluidSystem::numPhases };
334 enum { oilPhaseIdx = FluidSystem::oilPhaseIdx };
335 enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
336 enum { conti0EqIdx = Indices::conti0EqIdx };
337 enum { numComponents = getPropValue<TypeTag, Properties::NumComponents>() };
338 enum { enableEnergy = getPropValue<TypeTag, Properties::EnableEnergy>() };
339 enum { enableDiffusion = getPropValue<TypeTag, Properties::EnableDiffusion>() };
340 enum { enableGravity = getPropValue<TypeTag, Properties::EnableGravity>() };
341
342 using GlobalPosition = Dune::FieldVector<CoordScalar, dimWorld>;
343 using DimMatrix = Dune::FieldMatrix<Scalar, dimWorld, dimWorld>;
344 using DimVector = Dune::FieldVector<Scalar, dimWorld>;
345 using ComponentVector = Dune::FieldVector<Evaluation, numComponents>;
346 using FlashSolver = GetPropType<TypeTag, Properties::FlashSolver>;
347
348public:
349 using FluidState = Opm::CompositionalFluidState<Evaluation, FluidSystem, enableEnergy>;
353 explicit CO2PTProblem(Simulator& simulator)
354 : ParentType(simulator)
355 {
356 const Scalar epi_len = Parameters::get<TypeTag, Properties::EpisodeLength>();
357 simulator.setEpisodeLength(epi_len);
358 FluidSystem::init();
359 using CompParm = typename FluidSystem::ComponentParam;
360 using CO2 = Opm::SimpleCO2<Scalar>;
361 using C1 = Opm::C1<Scalar>;
362 using C10 = Opm::C10<Scalar>;
363 FluidSystem::addComponent(CompParm {CO2::name(), CO2::molarMass(), CO2::criticalTemperature(),
364 CO2::criticalPressure(), CO2::criticalVolume(), CO2::acentricFactor()});
365 FluidSystem::addComponent(CompParm {C1::name(), C1::molarMass(), C1::criticalTemperature(),
366 C1::criticalPressure(), C1::criticalVolume(), C1::acentricFactor()});
367 FluidSystem::addComponent(CompParm{C10::name(), C10::molarMass(), C10::criticalTemperature(),
368 C10::criticalPressure(), C10::criticalVolume(), C10::acentricFactor()});
369 // FluidSystem::add
370 }
371
372 void initPetrophysics()
373 {
374 temperature_ = Parameters::get<TypeTag, Properties::Temperature>();
375 K_ = this->toDimMatrix_(9.869232667160131e-14);
376
377 porosity_ = 0.1;
378 }
379
380 template <class Context>
381 const DimVector&
382 gravity([[maybe_unused]]const Context& context, [[maybe_unused]] unsigned spaceIdx, [[maybe_unused]] unsigned timeIdx) const
383 {
384 return gravity();
385 }
386
387 const DimVector& gravity() const
388 {
389 return gravity_;
390 }
391
396 {
397 ParentType::finishInit();
398 // initialize fixed parameters; temperature, permeability, porosity
399 initPetrophysics();
400 }
401
405 static void registerParameters()
406 {
407 ParentType::registerParameters();
408
409 Parameters::registerParam<TypeTag, Properties::Temperature>
410 ("The temperature [K] in the reservoir");
411 Parameters::registerParam<TypeTag, Properties::Initialpressure>
412 ("The initial pressure [Pa s] in the reservoir");
413 Parameters::registerParam<TypeTag, Properties::SimulationName>
414 ("The name of the simulation used for the output files");
415 Parameters::registerParam<TypeTag, Properties::EpisodeLength>
416 ("Time interval [s] for episode length");
417 }
418
422 std::string name() const
423 {
424 std::ostringstream oss;
425 oss << Parameters::get<TypeTag, Properties::SimulationName>();
426 return oss.str();
427 }
428
429 // This method must be overridden for the simulator to continue with
430 // a new episode. We just start a new episode with the same length as
431 // the old one.
432 void endEpisode()
433 {
434 Scalar epi_len = Parameters::get<TypeTag, Properties::EpisodeLength>();
435 this->simulator().startNextEpisode(epi_len);
436 }
437
438 // only write output when episodes change, aka. report steps, and
439 // include the initial timestep too
440 bool shouldWriteOutput()
441 {
442 return this->simulator().episodeWillBeOver() || (this->simulator().timeStepIndex() == -1);
443 }
444
445 // we don't care about doing restarts from every fifth timestep, it
446 // will just slow us down
447 bool shouldWriteRestartFile()
448 {
449 return false;
450 }
451
456 {
457 Scalar tol = this->model().newtonMethod().tolerance() * 1e5;
458 this->model().checkConservativeness(tol);
459
460 // Calculate storage terms
461 PrimaryVariables storageO, storageW;
462 this->model().globalPhaseStorage(storageO, oilPhaseIdx);
463
464 // Calculate storage terms
465 PrimaryVariables storageL, storageG;
466 this->model().globalPhaseStorage(storageL, /*phaseIdx=*/0);
467 this->model().globalPhaseStorage(storageG, /*phaseIdx=*/1);
468
469 // Write mass balance information for rank 0
470 // if (this->gridView().comm().rank() == 0) {
471 // std::cout << "Storage: liquid=[" << storageL << "]"
472 // << " gas=[" << storageG << "]\n" << std::flush;
473 // }
474 }
475
479 template <class Context>
480 void initial(PrimaryVariables& values, const Context& context, unsigned spaceIdx, unsigned timeIdx) const
481 {
482 Opm::CompositionalFluidState<Evaluation, FluidSystem> fs;
483 initialFluidState(fs, context, spaceIdx, timeIdx);
484 values.assignNaive(fs);
485 }
486
487 // Constant temperature
488 template <class Context>
489 Scalar temperature([[maybe_unused]] const Context& context, [[maybe_unused]] unsigned spaceIdx, [[maybe_unused]] unsigned timeIdx) const
490 {
491 return temperature_;
492 }
493
494
495 // Constant permeability
496 template <class Context>
497 const DimMatrix& intrinsicPermeability([[maybe_unused]] const Context& context,
498 [[maybe_unused]] unsigned spaceIdx,
499 [[maybe_unused]] unsigned timeIdx) const
500 {
501 return K_;
502 }
503
504 // Constant porosity
505 template <class Context>
506 Scalar porosity([[maybe_unused]] const Context& context, [[maybe_unused]] unsigned spaceIdx, [[maybe_unused]] unsigned timeIdx) const
507 {
508 int spatialIdx = context.globalSpaceIndex(spaceIdx, timeIdx);
509 int inj = 0;
510 int prod = Parameters::get<TypeTag, Properties::CellsX>() - 1;
511 if (spatialIdx == inj || spatialIdx == prod) {
512 return 1.0;
513 } else {
514 return porosity_;
515 }
516 }
517
521 template <class Context>
522 const MaterialLawParams& materialLawParams([[maybe_unused]] const Context& context,
523 [[maybe_unused]] unsigned spaceIdx,
524 [[maybe_unused]] unsigned timeIdx) const
525 {
526 return this->mat_;
527 }
528
529
530 // No flow (introduce fake wells instead)
531 template <class Context>
532 void boundary(BoundaryRateVector& values,
533 const Context& /*context*/,
534 unsigned /*spaceIdx*/,
535 unsigned /*timeIdx*/) const
536 { values.setNoFlow(); }
537
538 // No source terms
539 template <class Context>
540 void source(RateVector& source_rate,
541 [[maybe_unused]] const Context& context,
542 [[maybe_unused]] unsigned spaceIdx,
543 [[maybe_unused]] unsigned timeIdx) const
544 {
545 source_rate = Scalar(0.0);
546 }
547
548private:
549
553 template <class FluidState, class Context>
554 void initialFluidState(FluidState& fs, const Context& context, unsigned spaceIdx, unsigned timeIdx) const
555 {
556 // z0 = [0.5, 0.3, 0.2]
557 // zi = [0.99, 0.01-1e-3, 1e-3]
558 // p0 = 75e5
559 // T0 = 423.25
560 int inj = 0;
561 int prod = Parameters::get<TypeTag, Properties::CellsX>() - 1;
562 int spatialIdx = context.globalSpaceIndex(spaceIdx, timeIdx);
563 ComponentVector comp;
564 comp[0] = Evaluation::createVariable(0.5, 1);
565 comp[1] = Evaluation::createVariable(0.3, 2);
566 comp[2] = 1. - comp[0] - comp[1];
567 if (spatialIdx == inj) {
568 comp[0] = Evaluation::createVariable(0.99, 1);
569 comp[1] = Evaluation::createVariable(0.01 - 1e-3, 2);
570 comp[2] = 1. - comp[0] - comp[1];
571 }
572 ComponentVector sat;
573 sat[0] = 1.0;
574 sat[1] = 1.0 - sat[0];
575
576 Scalar p0 = Parameters::get<TypeTag, Properties::Initialpressure>();
577
578 //\Note, for an AD variable, if we multiply it with 2, the derivative will also be scalced with 2,
579 //\Note, so we should not do it.
580 if (spatialIdx == inj) {
581 p0 *= 2.0;
582 }
583 if (spatialIdx == prod) {
584 p0 *= 0.5;
585 }
586 Evaluation p_init = Evaluation::createVariable(p0, 0);
587
588 fs.setPressure(FluidSystem::oilPhaseIdx, p_init);
589 fs.setPressure(FluidSystem::gasPhaseIdx, p_init);
590
591 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
592 fs.setMoleFraction(FluidSystem::oilPhaseIdx, compIdx, comp[compIdx]);
593 fs.setMoleFraction(FluidSystem::gasPhaseIdx, compIdx, comp[compIdx]);
594 }
595
596 // It is used here only for calculate the z
597 fs.setSaturation(FluidSystem::oilPhaseIdx, sat[0]);
598 fs.setSaturation(FluidSystem::gasPhaseIdx, sat[1]);
599
600 fs.setTemperature(temperature_);
601
602 // ParameterCache paramCache;
603 {
604 typename FluidSystem::template ParameterCache<Evaluation> paramCache;
605 paramCache.updatePhase(fs, FluidSystem::oilPhaseIdx);
606 paramCache.updatePhase(fs, FluidSystem::gasPhaseIdx);
607 fs.setDensity(FluidSystem::oilPhaseIdx, FluidSystem::density(fs, paramCache, FluidSystem::oilPhaseIdx));
608 fs.setDensity(FluidSystem::gasPhaseIdx, FluidSystem::density(fs, paramCache, FluidSystem::gasPhaseIdx));
609 fs.setViscosity(FluidSystem::oilPhaseIdx, FluidSystem::viscosity(fs, paramCache, FluidSystem::oilPhaseIdx));
610 fs.setViscosity(FluidSystem::gasPhaseIdx, FluidSystem::viscosity(fs, paramCache, FluidSystem::gasPhaseIdx));
611 }
612
613 // Set initial K and L
614 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
615 const Evaluation Ktmp = fs.wilsonK_(compIdx);
616 fs.setKvalue(compIdx, Ktmp);
617 }
618
619 const Evaluation& Ltmp = -1.0;
620 fs.setLvalue(Ltmp);
621 }
622
623 DimMatrix K_;
624 Scalar porosity_;
625 Scalar temperature_;
626 MaterialLawParams mat_;
627 DimVector gravity_;
628};
629} // namespace Opm
630
631#endif
3 component simple testproblem with ["CO2", "C1", "C10"]
Definition co2ptflashproblem.hh:312
std::string name() const
Definition co2ptflashproblem.hh:422
const MaterialLawParams & materialLawParams(const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition co2ptflashproblem.hh:522
CO2PTProblem(Simulator &simulator)
Definition co2ptflashproblem.hh:353
void initial(PrimaryVariables &values, const Context &context, unsigned spaceIdx, unsigned timeIdx) const
Definition co2ptflashproblem.hh:480
static void registerParameters()
Definition co2ptflashproblem.hh:405
void endTimeStep()
Definition co2ptflashproblem.hh:455
void finishInit()
Definition co2ptflashproblem.hh:395
Definition co2ptflashproblem.hh:75
Definition co2ptflashproblem.hh:78
Definition co2ptflashproblem.hh:81
Definition co2injectionproblem.hh:92
Definition co2ptflashproblem.hh:67
Definition co2injectionproblem.hh:90