int main()
{
typedef double Scalar;
typedef Opm::FluidSystems::H2ON2<Scalar, false> FluidSystem;
typedef Opm::CompositionalFluidState<Scalar, FluidSystem> CompositionalFluidState;
enum { numPhases = FluidSystem::numPhases };
enum { numComponents = FluidSystem::numComponents };
enum { lPhaseIdx = FluidSystem::lPhaseIdx };
enum { gPhaseIdx = FluidSystem::gPhaseIdx };
enum { H2OIdx = FluidSystem::H2OIdx };
enum { N2Idx = FluidSystem::N2Idx };
typedef Opm::TwoPhaseMaterialTraits<Scalar, lPhaseIdx, gPhaseIdx> MaterialTraits;
typedef Opm::RegularizedBrooksCorey<MaterialTraits> EffMaterialLaw;
typedef Opm::EffToAbsLaw<EffMaterialLaw> MaterialLaw;
typedef MaterialLaw::Params MaterialLawParams;
Scalar T = 273.15 + 25;
// initialize the tables of the fluid system
Scalar Tmin = T - 1.0;
Scalar Tmax = T + 1.0;
int nT = 3;
Scalar pmin = 0.0;
Scalar pmax = 1.25 * 2e6;
int np = 100;
FluidSystem::init(Tmin, Tmax, nT, pmin, pmax, np);
// set the parameters for the capillary pressure law
MaterialLawParams matParams;
matParams.setResidualSaturation(MaterialLaw::wPhaseIdx, 0.0);
matParams.setResidualSaturation(MaterialLaw::nPhaseIdx, 0.0);
matParams.setEntryPressure(0);
matParams.setLambda(2.0);
matParams.finalize();
CompositionalFluidState fsRef;
// create an fluid state which is consistent
// set the fluid temperatures
fsRef.setTemperature(T);
////////////////
// only liquid
////////////////
std::cout << "testing single-phase liquid\n";
// set liquid saturation
fsRef.setSaturation(lPhaseIdx, 1.0);
// set pressure of the liquid phase
fsRef.setPressure(lPhaseIdx, 2e5);
// set the liquid composition to pure water
fsRef.setMoleFraction(lPhaseIdx, N2Idx, 0.0);
fsRef.setMoleFraction(lPhaseIdx, H2OIdx, 1.0 - fsRef.moleFraction(lPhaseIdx, N2Idx));
// "complete" the fluid state
completeReferenceFluidState<Scalar, FluidSystem, MaterialLaw>(fsRef, matParams, lPhaseIdx);
// check the flash calculation
checkNcpFlash<Scalar, FluidSystem, MaterialLaw>(fsRef, matParams);
////////////////
// only gas
////////////////
std::cout << "testing single-phase gas\n";
// set gas saturation
fsRef.setSaturation(gPhaseIdx, 1.0);
// set pressure of the gas phase
fsRef.setPressure(gPhaseIdx, 1e6);
// set the gas composition to 99.9% nitrogen and 0.1% water
fsRef.setMoleFraction(gPhaseIdx, N2Idx, 0.999);
fsRef.setMoleFraction(gPhaseIdx, H2OIdx, 0.001);
// "complete" the fluid state
completeReferenceFluidState<Scalar, FluidSystem, MaterialLaw>(fsRef, matParams, gPhaseIdx);
// check the flash calculation
checkNcpFlash<Scalar, FluidSystem, MaterialLaw>(fsRef, matParams);
////////////////
// both phases
////////////////
std::cout << "testing two-phase\n";
// set saturations
fsRef.setSaturation(lPhaseIdx, 0.5);
fsRef.setSaturation(gPhaseIdx, 0.5);
// set pressures
fsRef.setPressure(lPhaseIdx, 1e6);
fsRef.setPressure(gPhaseIdx, 1e6);
FluidSystem::ParameterCache paramCache;
typedef Opm::MiscibleMultiPhaseComposition<Scalar, FluidSystem> MiscibleMultiPhaseComposition;
MiscibleMultiPhaseComposition::solve(fsRef, paramCache,
/*setViscosity=*/false,
/*setEnthalpy=*/false);
// check the flash calculation
checkNcpFlash<Scalar, FluidSystem, MaterialLaw>(fsRef, matParams);
////////////////
// with capillary pressure
////////////////
MaterialLawParams matParams2;
matParams2.setResidualSaturation(MaterialLaw::wPhaseIdx, 0.0);
matParams2.setResidualSaturation(MaterialLaw::nPhaseIdx, 0.0);
matParams2.setEntryPressure(1e3);
matParams2.setLambda(2.0);
matParams2.finalize();
// set gas saturation
fsRef.setSaturation(gPhaseIdx, 0.5);
fsRef.setSaturation(lPhaseIdx, 0.5);
// set pressure of the liquid phase
fsRef.setPressure(lPhaseIdx, 1e6);
// calulate the capillary pressure
typedef Dune::FieldVector<Scalar, numPhases> PhaseVector;
PhaseVector pC;
MaterialLaw::capillaryPressures(pC, matParams2, fsRef);
fsRef.setPressure(gPhaseIdx,
fsRef.pressure(lPhaseIdx)
+ (pC[gPhaseIdx] - pC[lPhaseIdx]));
typedef Opm::MiscibleMultiPhaseComposition<Scalar, FluidSystem> MiscibleMultiPhaseComposition;
MiscibleMultiPhaseComposition::solve(fsRef, paramCache,
/*setViscosity=*/false,
/*setEnthalpy=*/false);
// check the flash calculation
checkNcpFlash<Scalar, FluidSystem, MaterialLaw>(fsRef, matParams2);
return 0;
}
void BlackoilCo2PVT::computeState(BlackoilCo2PVT::SubState& ss, double zBrine, double zCO2, double pressure) const
{
CompositionalFluidState state;
state.setTemperature(temperature_);
state.setPressure(wPhase, pressure);
state.setPressure(nPhase, pressure);
double massH20 = surfaceDensities_[Oil]*zBrine;
double massCO2 = surfaceDensities_[Gas]*zCO2;
// A priori, assume presence of both phases
brineCo2_.computeEquilibrium(state);
ss.density[wPhase] = state.density(wPhase);
ss.density[nPhase] = state.density(nPhase);
ss.massfrac[wPhase][nComp] = state.massFraction(wPhase, nComp);
ss.massfrac[nPhase][wComp] = state.massFraction(nPhase, wComp);
ss.massfrac[wPhase][wComp] = 1.0 - ss.massfrac[wPhase][nComp];
ss.massfrac[nPhase][nComp] = 1.0 - ss.massfrac[nPhase][wComp];
double detX = ss.massfrac[wPhase][wComp]*ss.massfrac[nPhase][nComp]-ss.massfrac[wPhase][nComp]*ss.massfrac[nPhase][wComp];
ss.phaseVolume[wPhase] = (massH20*ss.massfrac[nPhase][nComp] - massCO2*ss.massfrac[nPhase][wComp])/(ss.density[wPhase]*detX);
ss.phaseVolume[nPhase] = (massCO2*ss.massfrac[wPhase][wComp] - massH20*ss.massfrac[wPhase][nComp])/(ss.density[nPhase]*detX);
// Determine number of phase
if (ss.phaseVolume[wPhase] > 0.0 && ss.phaseVolume[nPhase] > 0.0) { // Both phases
ss.saturation = ss.phaseVolume[wPhase]/(ss.phaseVolume[wPhase]+ss.phaseVolume[nPhase]);
state.setSaturation(wPhase, ss.saturation);
state.setSaturation(nPhase, 1.0 - ss.saturation);
}
else if (ss.phaseVolume[wPhase] <= 0.0) { // Wetting phase only
ss.saturation = 0.0;
// Gas phase:
ss.massfrac[nPhase][nComp] = massCO2/(massCO2+massH20);
ss.massfrac[nPhase][wComp] = 1.0 - ss.massfrac[nPhase][nComp];
double M1 = FluidSystem::molarMass(wComp);
double M2 = FluidSystem::molarMass(nComp);
double avgMolarMass = M1*M2/(M2 + ss.massfrac[nPhase][nComp]*(M1 - M2));
state.setMoleFraction(nPhase, nComp, ss.massfrac[nPhase][nComp]*avgMolarMass/M2);
state.setMoleFraction(nPhase, wComp, ss.massfrac[nPhase][wComp]*avgMolarMass/M1);
ss.density[nPhase] = brineCo2_.phaseDensity(nPhase, state.temperature(nPhase), state.pressure(nPhase), state);
state.setDensity(nPhase, ss.density[nPhase]);
ss.phaseVolume[nPhase] = (massH20+massCO2)/ss.density[nPhase];
state.setSaturation(nPhase, 1.0 - ss.saturation);
// Virtual properties of non-existing liquid phase:
brineCo2_.computeEquilibrium(state, nPhase);
ss.massfrac[wPhase][wComp] = state.massFraction(wPhase, wComp);
ss.massfrac[wPhase][nComp] = state.massFraction(wPhase, nComp);
ss.density[wPhase] = state.density(wPhase);
ss.phaseVolume[wPhase] = 0.0;
state.setSaturation(wPhase, ss.saturation);
}
else if (ss.phaseVolume[nPhase] <= 0.0) { // Non-wetting phase only
ss.saturation = 1.0;
// Liquid phase:
ss.massfrac[wPhase][wComp] = massH20/(massCO2+massH20);
ss.massfrac[wPhase][nComp] = 1.0 - ss.massfrac[wPhase][wComp];
double M1 = FluidSystem::molarMass(wComp);
double M2 = FluidSystem::molarMass(nComp);
double avgMolarMass = M1*M2/(M2 + ss.massfrac[wPhase][nComp]*(M1 - M2));
state.setMoleFraction(wPhase, nComp, ss.massfrac[wPhase][nComp]*avgMolarMass/M2);
state.setMoleFraction(wPhase, wComp, ss.massfrac[wPhase][wComp]*avgMolarMass/M1);
ss.density[wPhase] = brineCo2_.phaseDensity(wPhase, state.temperature(wPhase), state.pressure(wPhase), state);
state.setDensity(wPhase, ss.density[wPhase]);
ss.phaseVolume[wPhase] = (massH20+massCO2)/ss.density[wPhase];
state.setSaturation(wPhase, ss.saturation);
// Virtual properties of non-existing gas phase:
brineCo2_.computeEquilibrium(state, wPhase);
ss.massfrac[nPhase][nComp] = state.massFraction(nPhase, nComp);
ss.massfrac[nPhase][wComp] = state.massFraction(nPhase, wComp);
ss.density[nPhase] = state.density(nPhase);
ss.phaseVolume[nPhase] = 0.0;
state.setSaturation(nPhase, 1.0 - ss.saturation);
}
ss.phaseViscosity[wPhase] = brineCo2_.phaseViscosity(wPhase, temperature_, pressure, state);
ss.phaseViscosity[nPhase] = brineCo2_.phaseViscosity(nPhase, temperature_, pressure, state);
}
void BlackoilCo2PVT::computeState(BlackoilCo2PVT::SubState& ss, double zBrine, double zCO2, double pressure) const
{
CompositionalFluidState fluidState;
fluidState.setTemperature(temperature_);
fluidState.setPressure(wPhase, pressure);
fluidState.setPressure(nPhase, pressure);
double massH20 = surfaceDensities_[Oil]*zBrine;
double massCO2 = surfaceDensities_[Gas]*zCO2;
// A priori, assume presence of both phases
FluidSystem::ParameterCache<double> paramCache;
typedef Opm::MiscibleMultiPhaseComposition</*Scalar=*/double, FluidSystem> MMPC;
MMPC::solve(fluidState, paramCache, /*setViscosity=*/false, /*setEnthalpy=*/false);
ss.density[wPhase] = fluidState.density(wPhase);
ss.density[nPhase] = fluidState.density(nPhase);
ss.massfrac[wPhase][nComp] = fluidState.massFraction(wPhase, nComp);
ss.massfrac[nPhase][wComp] = fluidState.massFraction(nPhase, wComp);
ss.massfrac[wPhase][wComp] = 1.0 - ss.massfrac[wPhase][nComp];
ss.massfrac[nPhase][nComp] = 1.0 - ss.massfrac[nPhase][wComp];
double detX = ss.massfrac[wPhase][wComp]*ss.massfrac[nPhase][nComp]-ss.massfrac[wPhase][nComp]*ss.massfrac[nPhase][wComp];
ss.phaseVolume[wPhase] = (massH20*ss.massfrac[nPhase][nComp] - massCO2*ss.massfrac[nPhase][wComp])/(ss.density[wPhase]*detX);
ss.phaseVolume[nPhase] = (massCO2*ss.massfrac[wPhase][wComp] - massH20*ss.massfrac[wPhase][nComp])/(ss.density[nPhase]*detX);
// Determine number of phase
if (ss.phaseVolume[wPhase] > 0.0 && ss.phaseVolume[nPhase] > 0.0) { // Both phases
ss.saturation = ss.phaseVolume[wPhase]/(ss.phaseVolume[wPhase]+ss.phaseVolume[nPhase]);
fluidState.setSaturation(wPhase, ss.saturation);
fluidState.setSaturation(nPhase, 1.0 - ss.saturation);
}
else if (ss.phaseVolume[wPhase] <= 0.0) { // Wetting phase only
ss.saturation = 0.0;
// Gas phase:
ss.massfrac[nPhase][nComp] = massCO2/(massCO2+massH20);
ss.massfrac[nPhase][wComp] = 1.0 - ss.massfrac[nPhase][nComp];
double M1 = FluidSystem::molarMass(wComp);
double M2 = FluidSystem::molarMass(nComp);
double avgMolarMass = M1*M2/(M2 + ss.massfrac[nPhase][nComp]*(M1 - M2));
fluidState.setMoleFraction(nPhase, nComp, ss.massfrac[nPhase][nComp]*avgMolarMass/M2);
fluidState.setMoleFraction(nPhase, wComp, ss.massfrac[nPhase][wComp]*avgMolarMass/M1);
ss.density[nPhase] = brineCo2_.density(fluidState, paramCache, nPhase);
fluidState.setDensity(nPhase, ss.density[nPhase]);
ss.phaseVolume[nPhase] = (massH20+massCO2)/ss.density[nPhase];
fluidState.setSaturation(nPhase, 1.0 - ss.saturation);
// Virtual properties of non-existing liquid phase:
paramCache.updatePhase(fluidState, /*phaseIdx=*/nPhase);
typedef Opm::ComputeFromReferencePhase</*Scalar=*/double, FluidSystem> CFRP;
CFRP::solve(fluidState,
paramCache,
/*refPhaseIdx=*/nPhase,
/*setViscosity=*/false,
/*setEnthalpy=*/false);
ss.massfrac[wPhase][wComp] = fluidState.massFraction(wPhase, wComp);
ss.massfrac[wPhase][nComp] = fluidState.massFraction(wPhase, nComp);
ss.density[wPhase] = fluidState.density(wPhase);
ss.phaseVolume[wPhase] = 0.0;
fluidState.setSaturation(wPhase, ss.saturation);
}
else if (ss.phaseVolume[nPhase] <= 0.0) { // Non-wetting phase only
ss.saturation = 1.0;
// Liquid phase:
ss.massfrac[wPhase][wComp] = massH20/(massCO2+massH20);
ss.massfrac[wPhase][nComp] = 1.0 - ss.massfrac[wPhase][wComp];
double M1 = FluidSystem::molarMass(wComp);
double M2 = FluidSystem::molarMass(nComp);
double avgMolarMass = M1*M2/(M2 + ss.massfrac[wPhase][nComp]*(M1 - M2));
fluidState.setMoleFraction(wPhase, nComp, ss.massfrac[wPhase][nComp]*avgMolarMass/M2);
fluidState.setMoleFraction(wPhase, wComp, ss.massfrac[wPhase][wComp]*avgMolarMass/M1);
ss.density[wPhase] = brineCo2_.density(fluidState, paramCache, wPhase);
fluidState.setDensity(wPhase, ss.density[wPhase]);
ss.phaseVolume[wPhase] = (massH20+massCO2)/ss.density[wPhase];
fluidState.setSaturation(wPhase, ss.saturation);
// Virtual properties of non-existing gas phase:
paramCache.updatePhase(fluidState, /*phaseIdx=*/nPhase);
typedef ComputeFromReferencePhase</*Scalar=*/double, FluidSystem> CFRP;
CFRP::solve(fluidState,
paramCache,
/*refPhaseIdx=*/wPhase,
/*setViscosity=*/false,
/*setEnthalpy=*/false);
ss.massfrac[nPhase][nComp] = fluidState.massFraction(nPhase, nComp);
ss.massfrac[nPhase][wComp] = fluidState.massFraction(nPhase, wComp);
ss.density[nPhase] = fluidState.density(nPhase);
ss.phaseVolume[nPhase] = 0.0;
fluidState.setSaturation(nPhase, 1.0 - ss.saturation);
}
ss.phaseViscosity[wPhase] = brineCo2_.viscosity(fluidState, paramCache, wPhase);
ss.phaseViscosity[nPhase] = brineCo2_.viscosity(fluidState, paramCache, nPhase);
}
