24#ifndef DUMUX_FVPRESSURECOMPOSITIONAL_HH
25#define DUMUX_FVPRESSURECOMPOSITIONAL_HH
28#include <dune/common/float_cmp.hh>
74 using TransportSolutionType =
typename GET_PROP_TYPE(TypeTag, TransportSolutionType);
77 using Indices =
typename GET_PROP_TYPE(TypeTag, ModelTraits)::Indices;
79 using FluidSystem =
typename GET_PROP_TYPE(TypeTag, FluidSystem);
80 using FluidState =
typename GET_PROP_TYPE(TypeTag, FluidState);
82 using MaterialLaw =
typename GET_PROP_TYPE(TypeTag, SpatialParams)::MaterialLaw;
88 dim = GridView::dimension, dimWorld = GridView::dimensionworld
92 pw = Indices::pressureW,
93 pn = Indices::pressureN
97 wPhaseIdx = Indices::wPhaseIdx, nPhaseIdx = Indices::nPhaseIdx,
98 wCompIdx = Indices::wCompIdx, nCompIdx = Indices::nCompIdx,
99 contiWEqIdx = Indices::contiWEqIdx, contiNEqIdx = Indices::contiNEqIdx
108 using Element =
typename GridView::Traits::template Codim<0>::Entity;
111 using GlobalPosition = Dune::FieldVector<Scalar, dimWorld>;
112 using PhaseVector = Dune::FieldVector<Scalar, numPhases>;
113 using ComponentVector = Dune::FieldVector<Scalar, numComponents>;
134 Scalar dt_estimate = 0.;
135 Dune::dinfo <<
"secant guess"<< std::endl;
141 if(Dune::FloatCmp::eq<Scalar>(
problem_.timeManager().time(),
problem_.timeManager().episodeStartTime())
142 &&
problem_.timeManager().episodeIndex() > 1)
143 problem_.timeManager().setTimeStepSize(dt_estimate*getParam<Scalar>(
"Impet.CFLFactor"));
147 problem_.pressureModel().assemble(
false); Dune::dinfo <<
"pressure calculation"<< std::endl;
171 template<
class MultiWriter>
174 using ScalarSolutionType =
typename GET_PROP(TypeTag, SolutionTypes)::ScalarSolution;
175 int size =
problem_.gridView().size(0);
176 ScalarSolutionType *pressureW = writer.allocateManagedBuffer(size);
177 ScalarSolutionType *pressureN = writer.allocateManagedBuffer(size);
178 ScalarSolutionType *totalConcentration1 = writer.allocateManagedBuffer (size);
179 ScalarSolutionType *totalConcentration2 = writer.allocateManagedBuffer (size);
180 ScalarSolutionType *pc = writer.allocateManagedBuffer(size);
181 ScalarSolutionType *saturationW = writer.allocateManagedBuffer(size);
182 ScalarSolutionType *densityWetting = writer.allocateManagedBuffer(size);
183 ScalarSolutionType *densityNonwetting = writer.allocateManagedBuffer(size);
184 ScalarSolutionType *mobilityW = writer.allocateManagedBuffer (size);
185 ScalarSolutionType *mobilityNW = writer.allocateManagedBuffer (size);
186 ScalarSolutionType *massfraction1W = writer.allocateManagedBuffer (size);
187 ScalarSolutionType *massfraction1NW = writer.allocateManagedBuffer (size);
189 ScalarSolutionType *volErr = writer.allocateManagedBuffer (size);
192 for (
int i = 0; i < size; i++)
195 CellData& cellData =
problem_.variables().cellData(i);
196 (*pressureW)[i] = cellData.pressure(wPhaseIdx);
197 (*pressureN)[i] = cellData.pressure(nPhaseIdx);
198 (*totalConcentration1)[i] = cellData.massConcentration(wCompIdx);
199 (*totalConcentration2)[i] = cellData.massConcentration(nCompIdx);
200 (*saturationW)[i] = cellData.saturation(wPhaseIdx);
204 (*pc)[i] = cellData.capillaryPressure();
205 (*densityWetting)[i] = cellData.density(wPhaseIdx);
206 (*densityNonwetting)[i] = cellData.density(nPhaseIdx);
207 (*mobilityW)[i] = cellData.mobility(wPhaseIdx);
208 (*mobilityNW)[i] = cellData.mobility(nPhaseIdx);
209 (*massfraction1W)[i] = cellData.massFraction(wPhaseIdx,wCompIdx);
210 (*massfraction1NW)[i] = cellData.massFraction(nPhaseIdx,wCompIdx);
211 (*volErr)[i] = cellData.volumeError();
214 writer.attachCellData(*pressureW,
"wetting pressure");
215 writer.attachCellData(*pressureN,
"nonwetting pressure");
216 writer.attachCellData(*saturationW,
"wetting saturation");
217 writer.attachCellData(*totalConcentration1,
"C^w from cellData");
218 writer.attachCellData(*totalConcentration2,
"C^n from cellData");
221 writer.attachCellData(*pc,
"capillary pressure");
222 writer.attachCellData(*densityWetting,
"wetting density");
223 writer.attachCellData(*densityNonwetting,
"nonwetting density");
224 writer.attachCellData(*mobilityW,
"mobility w_phase");
225 writer.attachCellData(*mobilityNW,
"mobility nw_phase");
226 std::ostringstream oss1, oss2;
227 oss1 <<
"mass fraction " << FluidSystem::componentName(0) <<
" in " << FluidSystem::phaseName(0) <<
"-phase";
228 writer.attachCellData(*massfraction1W, oss1.str());
229 oss2 <<
"mass fraction " << FluidSystem::componentName(0) <<
" in " << FluidSystem::phaseName(1) <<
"-phase";
230 writer.attachCellData(*massfraction1NW, oss2.str());
231 writer.attachCellData(*volErr,
"volume Error");
237 ScalarSolutionType *errorCorrPtr = writer.allocateManagedBuffer (size);
238 ScalarSolutionType *dv_dpPtr = writer.allocateManagedBuffer (size);
239 ScalarSolutionType *dV_dC1Ptr = writer.allocateManagedBuffer (size);
240 ScalarSolutionType *dV_dC2Ptr = writer.allocateManagedBuffer (size);
241 ScalarSolutionType *updEstimate1 = writer.allocateManagedBuffer (size);
242 ScalarSolutionType *updEstimate2 = writer.allocateManagedBuffer (size);
243 for (
int i = 0; i < size; i++)
245 CellData& cellData =
problem_.variables().cellData(i);
246 (*errorCorrPtr)[i] = cellData.errorCorrection();
247 (*dv_dpPtr)[i] = cellData.dv_dp();
248 (*dV_dC1Ptr)[i] = cellData.dv(wCompIdx);
249 (*dV_dC2Ptr)[i] = cellData.dv(nCompIdx);
253 writer.attachCellData(*errorCorrPtr,
"Error Correction");
254 writer.attachCellData(*dv_dpPtr,
"dv_dp");
255 writer.attachCellData(*dV_dC1Ptr,
"dV_dC1");
256 writer.attachCellData(*dV_dC2Ptr,
"dV_dC2");
257 writer.attachCellData(*updEstimate1,
"updEstimate comp 1");
258 writer.attachCellData(*updEstimate2,
"updEstimate comp 2");
264 ScalarSolutionType *pressurePV = writer.allocateManagedBuffer(size);
265 ScalarSolutionType *viscosityWetting = writer.allocateManagedBuffer(size);
266 ScalarSolutionType *viscosityNonwetting = writer.allocateManagedBuffer(size);
269 ScalarSolutionType *faceUpwindW = writer.allocateManagedBuffer(size);
270 ScalarSolutionType *faceUpwindN = writer.allocateManagedBuffer(size);
271 for (
int i = 0; i < size; i++)
273 CellData& cellData =
problem_.variables().cellData(i);
274 (*viscosityWetting)[i] = cellData.viscosity(wPhaseIdx);
275 (*viscosityNonwetting)[i] = cellData.viscosity(nPhaseIdx);
278 (*faceUpwindW)[i] = 0;
279 (*faceUpwindN)[i] = 0;
281 for(
int fIdx = 0; fIdx<cellData.fluxData().size(); fIdx++)
283 if(cellData.isUpwindCell(fIdx, contiWEqIdx))
284 (*faceUpwindW)[i] += pow(10,
static_cast<double>(3-fIdx));
285 if(cellData.isUpwindCell(fIdx, contiNEqIdx))
286 (*faceUpwindN)[i] += pow(10,
static_cast<double>(3-fIdx));
292 writer.attachCellData(*faceUpwindW,
"isUpwind w-phase");
293 writer.attachCellData(*faceUpwindN,
"isUpwind n-phase");
294 writer.attachCellData(*pressurePV,
"pressure (Primary Variable");
295 writer.attachCellData(*viscosityWetting,
"wetting viscosity");
296 writer.attachCellData(*viscosityNonwetting,
"nonwetting viscosity");
311 std::cout <<
"Writing debug for current time step\n";
315#if DUNE_MINIMAL_DEBUG_LEVEL <= 2
316 int size_ =
problem_.gridView().size(0);
321 Dune::BlockVector<Dune::FieldVector<double,1> > poro_(0.), perm_(0.);
322 poro_.resize(size_); perm_.resize(size_);
324 for (
const auto& element : elements(
problem_.gridView()))
327 int eIdxGlobal =
problem_.variables().index(element);
328 poro_[eIdxGlobal] =
problem_.spatialParams().porosity(element);
329 perm_[eIdxGlobal] =
problem_.spatialParams().intrinsicPermeability(element)[0][0];
340 Dune::BlockVector<Dune::FieldVector<double,1> > permY_(0.), permZ_(0.);
341 permY_.resize(size_); permZ_.resize(size_);
343 for (
const auto& element : elements(
problem_.gridView()))
346 int eIdxGlobal =
problem_.variables().index(element);
348 permY_[eIdxGlobal] =
problem_.spatialParams().intrinsicPermeability(element)[1][1];
350 permZ_[eIdxGlobal] =
problem_.spatialParams().intrinsicPermeability(element)[2][2];
388 DUNE_THROW(Dune::NotImplemented,
"Global Pressure type not supported!");
411 const Problem& problem()
const
417 Implementation &asImp_()
418 {
return *
static_cast<Implementation *
>(
this);}
421 const Implementation &asImp_()
const
422 {
return *
static_cast<const Implementation *
>(
this);}
434template<
class TypeTag>
438 ParentType::initialize();
442 Dune::dinfo <<
"first saturation guess"<<std::endl;
443 problem_.pressureModel().initialMaterialLaws(
false);
444 #if DUNE_MINIMAL_DEBUG_LEVEL <= 3
447 problem_.transportModel().update(0.,dummy, updateEstimate_,
false);
448 initializationOutput();
450 Dune::dinfo <<
"first pressure guess"<<std::endl;
451 problem_.pressureModel().assemble(
true);
452 problem_.pressureModel().solve();
453 #if DUNE_MINIMAL_DEBUG_LEVEL <= 3
454 initializationOutput(1e-6);
457 Dune::dinfo <<
"first guess for mass fractions"<<std::endl;
458 problem_.pressureModel().initialMaterialLaws(
true);
461 Dune::dinfo <<
"secant guess"<< std::endl;
462 Scalar dt_estimate = 0.;
463 problem_.transportModel().update(0., dt_estimate, updateEstimate_,
false);
465 dt_estimate = min ( problem_.timeManager().timeStepSize(), dt_estimate);
467 if (problem_.gridView().comm().size() > 1)
468 dt_estimate = problem_.gridView().comm().min(dt_estimate);
470 updateEstimate_ *= dt_estimate;
473 #if DUNE_MINIMAL_DEBUG_LEVEL <= 3
474 initializationOutput(2e-6);
477 Dune::dinfo <<
"second pressure guess"<<std::endl;
478 problem_.pressureModel().assemble(
false);
479 problem_.pressureModel().solve();
480 #if DUNE_MINIMAL_DEBUG_LEVEL <= 3
481 initializationOutput(3e-6);
485 problem_.pressureModel().initialMaterialLaws(
true);
490 Dune::BlockVector<Dune::FieldVector<Scalar, 1> > pressureOld(this->
pressure());
491 Dune::BlockVector<Dune::FieldVector<Scalar, 1> > pressureDiff;
492 Scalar pressureNorm = 1.;
495 while (pressureNorm > 1e-5 && numIter < 10)
499 problem_.transportModel().update(0., dt_dummy, updateEstimate_,
false); Dune::dinfo <<
"secant guess"<< std::endl;
500 updateEstimate_ *= dt_estimate;
506 problem_.pressureModel().assemble(
false); Dune::dinfo <<
"pressure guess number "<< numIter <<std::endl;
507 problem_.pressureModel().solve();
509 problem_.pressureModel().initialMaterialLaws(
true);
511 pressureDiff = pressureOld;
513 pressureNorm = pressureDiff.infinity_norm();
515 pressureNorm /= pressureOld.infinity_norm();
531template<
class TypeTag>
535 for (
const auto& element : elements(problem_.gridView()))
538 GlobalPosition globalPos = element.geometry().center();
541 int eIdxGlobal = problem_.variables().index(element);
544 Scalar temperature_ = problem_.temperatureAtPos(globalPos);
545 CellData& cellData = problem_.variables().cellData(eIdxGlobal);
547 FluidState& fluidState = cellData.manipulateFluidState();
554 typename Indices::BoundaryFormulation icFormulation;
555 problem_.initialFormulation(icFormulation, element);
560 Scalar exemplaryPressure = problem_.referencePressure(element);
564 sat_0 = problem_.initSat(element);
567 else if (icFormulation == Indices::concentration)
569 Scalar Z0 = problem_.initConcentration(element);
571 problem_.spatialParams().porosity(element), temperature_);
574 else if(compositional)
579 sat_0 = problem_.initSat(element);
583 pc = MaterialLaw::pc(problem_.spatialParams().materialLawParams(element),
590 switch (pressureType)
606 problem_.spatialParams().porosity(element), temperature_);
608 else if (icFormulation == Indices::concentration)
610 Scalar Z0 = problem_.initConcentration(element);
618 Scalar pc(cellData.capillaryPressure());
622 for(
int iter=0; iter < maxiter; iter++)
625 switch (pressureType)
645 problem_.spatialParams().porosity(element), problem_.temperatureAtPos(globalPos));
646 pc = MaterialLaw::pc(problem_.spatialParams().materialLawParams(element),
647 fluidState.saturation(wPhaseIdx));
651 if (abs(oldPc - pc) < 10.0)
654 pc = MaterialLaw::pc(problem_.spatialParams().materialLawParams(element),
655 fluidState.saturation(wPhaseIdx));
663 pressure, problem_.spatialParams().porosity(element), temperature_);
668 cellData.calculateMassConcentration(problem_.spatialParams().porosity(element));
670 problem_.transportModel().totalConcentration(wCompIdx,eIdxGlobal) = cellData.massConcentration(wCompIdx);
671 problem_.transportModel().totalConcentration(nCompIdx,eIdxGlobal) = cellData.massConcentration(nCompIdx);
674 cellData.setMobility(wPhaseIdx, MaterialLaw::krw(problem_.spatialParams().materialLawParams(element),
675 fluidState.saturation(wPhaseIdx))
676 / cellData.viscosity(wPhaseIdx));
677 cellData.setMobility(nPhaseIdx, MaterialLaw::krn(problem_.spatialParams().materialLawParams(element),
678 fluidState.saturation(wPhaseIdx))
679 / cellData.viscosity(nPhaseIdx));
685 for (
const auto& intersection :
intersections(problem_.gridView(), element))
688 += intersection.geometry().volume();
690 cellData.globalIdx() = eIdxGlobal;
693 cellData.dv_dp() = 0.;
694 cellData.dv(wPhaseIdx) = 0.;
695 cellData.dv(nPhaseIdx) = 0.;
710template<
class TypeTag>
713 Scalar maxError = 0.;
715 for (
const auto& element : elements(problem().gridView()))
717 int eIdxGlobal = problem().variables().index(element);
719 CellData& cellData = problem().variables().cellData(eIdxGlobal);
721 asImp_().updateMaterialLawsInElement(element, postTimeStep);
724 maxError = max(maxError, fabs(cellData.volumeError()));
726 if (problem_.gridView().comm().size() > 1)
727 maxError_ = problem_.gridView().comm().max(maxError_);
729 maxError_ = maxError/problem().timeManager().timeStepSize();
745template<
class TypeTag>
749 int eIdxGlobal = problem_.variables().index(element);
751 CellData& cellData = problem_.variables().cellData(eIdxGlobal);
754 Scalar temperature_ = cellData.temperature(wPhaseIdx);
757 FluidState updFluidState;
765 for(
int phaseIdx = 0; phaseIdx< numPhases; phaseIdx++)
766 pressure[phaseIdx] = cellData.pressure(phaseIdx);
769 ComponentVector mass(0.);
770 for(
int compIdx = 0; compIdx< numComponents; compIdx++)
771 mass[compIdx] = cellData.massConcentration(compIdx);
775 Scalar specificVolume(0.);
776 for(
int phaseIdx = 0; phaseIdx< numPhases; phaseIdx++)
777 specificVolume += cellData.phaseMassFraction(phaseIdx) / cellData.density(phaseIdx);
778 Scalar volalt = mass.one_norm() * specificVolume;
786 ComponentVector massIncrement(0.);
787 for(
int compIdx = 0; compIdx< numComponents; compIdx++)
789 massIncrement[compIdx] = updateEstimate_[compIdx][eIdxGlobal];
790 if(fabs(massIncrement[compIdx]) < 1e-8 * cellData.density(compIdx))
791 massIncrement[compIdx] = 1e-8* cellData.density(compIdx);
793 Scalar& incp = incp_;
800 PhaseVector p_(incp);
802 Scalar Z0 = mass[0] / mass.one_norm();
804 p_, problem_.spatialParams().porosity(element), temperature_);
807 for(
int phaseIdx = 0; phaseIdx< numPhases; phaseIdx++)
808 specificVolume += updFluidState.phaseMassFraction(phaseIdx) / updFluidState.density(phaseIdx);
809 Scalar dv_dp = ((mass.one_norm() * specificVolume) - volalt) /incp;
814 Dune::dinfo <<
"dv_dp larger 0 at Idx " << eIdxGlobal <<
" , try and invert secant"<< std::endl;
818 p_, problem_.spatialParams().porosity(element), temperature_);
821 for(
int phaseIdx = 0; phaseIdx< numPhases; phaseIdx++)
822 specificVolume += updFluidState.phaseMassFraction(phaseIdx) / updFluidState.density(phaseIdx);
823 dv_dp = ((mass.one_norm() * specificVolume) - volalt) /incp;
828 Dune::dwarn <<
"dv_dp still larger 0 after inverting secant at idx"<< eIdxGlobal<< std::endl;
831 p_, problem_.spatialParams().porosity(element), temperature_);
834 for(
int phaseIdx = 0; phaseIdx< numPhases; phaseIdx++)
835 specificVolume += cellData.phaseMassFraction(phaseIdx) / updFluidState.density(phaseIdx);
836 dv_dp = ((mass.one_norm() * specificVolume) - volalt) /incp;
839 std::cout <<
"dv_dp still larger 0 after both inverts at idx " << eIdxGlobal << std::endl;
840 dv_dp = cellData.dv_dp();
844 cellData.dv_dp()=dv_dp;
847 for (
int compIdx = 0; compIdx<numComponents; compIdx++)
849 mass[compIdx] += massIncrement[compIdx];
850 Z0 = mass[0] / mass.one_norm();
853 pressure, problem_.spatialParams().porosity(element), temperature_);
856 for(
int phaseIdx = 0; phaseIdx< numPhases; phaseIdx++)
857 specificVolume += updFluidState.phaseMassFraction(phaseIdx) / updFluidState.density(phaseIdx);
859 cellData.dv(compIdx) = ((mass.one_norm() * specificVolume) - volalt) / massIncrement[compIdx];
860 mass[compIdx] -= massIncrement[compIdx];
865 if (isnan(cellData.dv(compIdx)) || isinf(cellData.dv(compIdx)) )
867 DUNE_THROW(Dune::MathError,
"NAN/inf of dV_dm. If that happens in first timestep, try smaller firstDt!");
870 cellData.volumeDerivativesAvailable(
true);
#define GET_PROP_VALUE(TypeTag, PropTagName)
Definition: propertysystemmacros.hh:282
#define GET_PROP(TypeTag, PropTagName)
Definition: propertysystemmacros.hh:281
#define GET_PROP_TYPE(TypeTag, PropTagName)
Definition: propertysystemmacros.hh:283
Define some often used mathematical functions.
Simplifies writing multi-file VTK datasets.
Determines the pressures and saturations of all fluid phases given the total mass of all components.
Dune::IteratorRange< typename MultiDomainGlue< DomainGridView, TargetGridView, DomainMapper, TargetMapper >::Intersections::const_iterator > intersections(const MultiDomainGlue< DomainGridView, TargetGridView, DomainMapper, TargetMapper > &glue)
Range generator to iterate with range-based for loops over all intersections as follows: for (const a...
Definition: glue.hh:62
make the local view function available whenever we use the grid geometry
Definition: adapt.hh:29
Property tag EnableCapillarity
Returns whether capillarity is regarded.
Definition: porousmediumflow/2p2c/sequential/properties.hh:60
Property tag NumComponents
Number of components in the system.
Definition: porousmediumflow/sequential/properties.hh:70
Property tag NumPhases
Number of phases in the system.
Definition: porousmediumflow/sequential/properties.hh:69
Property tag PressureModel
The type of the discretization of a pressure model.
Definition: porousmediumflow/sequential/properties.hh:65
std::string saturation(int phaseIdx) noexcept
I/O name of saturation for multiphase systems.
Definition: name.hh:43
std::string pressure(int phaseIdx) noexcept
I/O name of pressure for multiphase systems.
Definition: name.hh:34
void resize(const Vector &v, std::size_t size)
Definition: test_isvalid.cc:26
Simplifies writing multi-file VTK datasets.
Definition: vtkmultiwriter.hh:61
Flash calculation routines for compositional sequential models.
Definition: compositionalflash.hh:51
static void saturationFlash2p2c(FluidState &fluidState, const Scalar &saturation, const PhaseVector &phasePressure, const Scalar &porosity, const Scalar &temperature)
2p2c flash for constant p & T if the saturation instead of concentration (feed mass fraction) is know...
Definition: compositionalflash.hh:224
static void concentrationFlash2p2c(FluidState &fluidState, const Scalar &Z0, const PhaseVector &phasePressure, const Scalar &porosity, const Scalar &temperature)
2p2c Flash for constant p & T if concentration (feed mass fraction) is given.
Definition: compositionalflash.hh:92
The finite volume model for the solution of the compositional pressure equation.
Definition: fvpressurecompositional.hh:67
Scalar incp_
Increment for the volume derivative w.r.t pressure.
Definition: fvpressurecompositional.hh:399
void volumeDerivatives(const GlobalPosition &, const Element &ep)
Partial derivatives of the volumes w.r.t. changes in total concentration and pressure.
Definition: fvpressurecompositional.hh:746
Scalar ErrorTermLowerBound_
Handling of error term: lower bound for error dampening.
Definition: fvpressurecompositional.hh:401
void initializationOutput(double pseudoTS=0.)
Write additional debug info in a special writer.
Definition: fvpressurecompositional.hh:309
Scalar maxError_
Maximum volume error of all cells.
Definition: fvpressurecompositional.hh:398
void addOutputVtkFields(MultiWriter &writer)
Write data files.
Definition: fvpressurecompositional.hh:172
void updateMaterialLaws(bool postTimeStep=false)
Updates secondary variables.
Definition: fvpressurecompositional.hh:711
Problem & problem_
Definition: fvpressurecompositional.hh:393
FVPressureCompositional(Problem &problem)
Constructs a FVPressureCompositional object.
Definition: fvpressurecompositional.hh:374
Scalar ErrorTermFactor_
Handling of error term: relaxation factor.
Definition: fvpressurecompositional.hh:400
static constexpr int pressureType
gives kind of pressure used ( , , )
Definition: fvpressurecompositional.hh:404
Scalar ErrorTermUpperBound_
Definition: fvpressurecompositional.hh:402
void initialMaterialLaws(bool compositional)
initializes the fluid distribution and hereby the variables container
Definition: fvpressurecompositional.hh:532
VtkMultiWriter< GridView > initializationOutputWriter_
output for the initialization procedure
Definition: fvpressurecompositional.hh:396
void update()
Compositional pressure solution routine: update estimate for secants, assemble, solve.
Definition: fvpressurecompositional.hh:131
TransportSolutionType updateEstimate_
Update estimate for changes in volume for the pressure equation.
Definition: fvpressurecompositional.hh:392
The finite volume base class for the solution of a pressure equation.
Definition: sequential/cellcentered/pressure.hh:48
void initialize()
Initialize pressure model.
Definition: sequential/cellcentered/pressure.hh:212
PressureSolution & pressure()
Returns the vector containing the pressure solution.
Definition: sequential/cellcentered/pressure.hh:119
Defines the properties required for the sequential 2p2c models.
Finite Volume Diffusion Model.