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); }