void createSurfaceGasFluidSystem(FluidState& gasFluidState) { static const int gasPhaseIdx = FluidSystem::gasPhaseIdx; // temperature gasFluidState.setTemperature(273.15 + 20); // gas pressure gasFluidState.setPressure(gasPhaseIdx, 1e5); // gas saturation gasFluidState.setSaturation(gasPhaseIdx, 1.0); // gas composition: mostly methane, a bit of propane gasFluidState.setMoleFraction(gasPhaseIdx, FluidSystem::H2OIdx, 0.0); gasFluidState.setMoleFraction(gasPhaseIdx, FluidSystem::C1Idx, 0.94); gasFluidState.setMoleFraction(gasPhaseIdx, FluidSystem::C3Idx, 0.06); gasFluidState.setMoleFraction(gasPhaseIdx, FluidSystem::C6Idx, 0.00); gasFluidState.setMoleFraction(gasPhaseIdx, FluidSystem::C10Idx, 0.00); gasFluidState.setMoleFraction(gasPhaseIdx, FluidSystem::C15Idx, 0.00); gasFluidState.setMoleFraction(gasPhaseIdx, FluidSystem::C20Idx, 0.00); // gas density typename FluidSystem::template ParameterCache<typename FluidState::Scalar> paramCache; paramCache.updatePhase(gasFluidState, gasPhaseIdx); gasFluidState.setDensity(gasPhaseIdx, FluidSystem::density(gasFluidState, paramCache, gasPhaseIdx)); }
static void solveIdealMix_(FluidState &fluidState, typename FluidSystem::template ParameterCache<typename FluidState::Scalar>& paramCache, unsigned phaseIdx, const ComponentVector &fugacities) { for (unsigned i = 0; i < numComponents; ++ i) { const Evaluation& phi = FluidSystem::fugacityCoefficient(fluidState, paramCache, phaseIdx, i); const Evaluation& gamma = phi * fluidState.pressure(phaseIdx); Valgrind::CheckDefined(phi); Valgrind::CheckDefined(gamma); Valgrind::CheckDefined(fugacities[i]); fluidState.setFugacityCoefficient(phaseIdx, i, phi); fluidState.setMoleFraction(phaseIdx, i, fugacities[i]/gamma); }; paramCache.updatePhase(fluidState, phaseIdx); const Evaluation& rho = FluidSystem::density(fluidState, paramCache, phaseIdx); fluidState.setDensity(phaseIdx, rho); return; }
static void solve(FluidState& fluidState, typename FluidSystem::template ParameterCache<typename FluidState::Scalar>& paramCache, unsigned refPhaseIdx, bool setViscosity, bool setEnthalpy) { typedef MathToolbox<typename FluidState::Scalar> FsToolbox; // compute the density and enthalpy of the // reference phase paramCache.updatePhase(fluidState, refPhaseIdx); fluidState.setDensity(refPhaseIdx, FluidSystem::density(fluidState, paramCache, refPhaseIdx)); if (setEnthalpy) fluidState.setEnthalpy(refPhaseIdx, FluidSystem::enthalpy(fluidState, paramCache, refPhaseIdx)); if (setViscosity) fluidState.setViscosity(refPhaseIdx, FluidSystem::viscosity(fluidState, paramCache, refPhaseIdx)); // compute the fugacities of all components in the reference phase for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) { fluidState.setFugacityCoefficient(refPhaseIdx, compIdx, FluidSystem::fugacityCoefficient(fluidState, paramCache, refPhaseIdx, compIdx)); } // compute all quantities for the non-reference phases for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) { if (phaseIdx == refPhaseIdx) continue; // reference phase is already calculated ComponentVector fugVec; for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) { const auto& fug = fluidState.fugacity(refPhaseIdx, compIdx); fugVec[compIdx] = FsToolbox::template decay<Evaluation>(fug); } CompositionFromFugacities::solve(fluidState, paramCache, phaseIdx, fugVec); if (setViscosity) fluidState.setViscosity(phaseIdx, FluidSystem::viscosity(fluidState, paramCache, phaseIdx)); if (setEnthalpy) fluidState.setEnthalpy(phaseIdx, FluidSystem::enthalpy(fluidState, paramCache, phaseIdx)); } }
static void solve(FluidState &fluidState, typename FluidSystem::template ParameterCache<typename FluidState::Scalar>& paramCache, unsigned phaseIdx, const ComponentVector &targetFug) { typedef MathToolbox<Evaluation> Toolbox; // use a much more efficient method in case the phase is an // ideal mixture if (FluidSystem::isIdealMixture(phaseIdx)) { solveIdealMix_(fluidState, paramCache, phaseIdx, targetFug); return; } //Dune::FMatrixPrecision<Scalar>::set_singular_limit(1e-25); // save initial composition in case something goes wrong Dune::FieldVector<Evaluation, numComponents> xInit; for (unsigned i = 0; i < numComponents; ++i) { xInit[i] = fluidState.moleFraction(phaseIdx, i); } ///////////////////////// // Newton method ///////////////////////// // Jacobian matrix Dune::FieldMatrix<Evaluation, numComponents, numComponents> J; // solution, i.e. phase composition Dune::FieldVector<Evaluation, numComponents> x; // right hand side Dune::FieldVector<Evaluation, numComponents> b; paramCache.updatePhase(fluidState, phaseIdx); // maximum number of iterations const int nMax = 25; for (int nIdx = 0; nIdx < nMax; ++nIdx) { // calculate Jacobian matrix and right hand side linearize_(J, b, fluidState, paramCache, phaseIdx, targetFug); Valgrind::CheckDefined(J); Valgrind::CheckDefined(b); /* std::cout << FluidSystem::phaseName(phaseIdx) << "Phase composition: "; for (unsigned i = 0; i < FluidSystem::numComponents; ++i) std::cout << fluidState.moleFraction(phaseIdx, i) << " "; std::cout << "\n"; std::cout << FluidSystem::phaseName(phaseIdx) << "Phase phi: "; for (unsigned i = 0; i < FluidSystem::numComponents; ++i) std::cout << fluidState.fugacityCoefficient(phaseIdx, i) << " "; std::cout << "\n"; */ // Solve J*x = b x = Toolbox::createConstant(0.0); try { J.solve(x, b); } catch (Dune::FMatrixError e) { throw Opm::NumericalProblem(e.what()); } //std::cout << "original delta: " << x << "\n"; Valgrind::CheckDefined(x); /* std::cout << FluidSystem::phaseName(phaseIdx) << "Phase composition: "; for (unsigned i = 0; i < FluidSystem::numComponents; ++i) std::cout << fluidState.moleFraction(phaseIdx, i) << " "; std::cout << "\n"; std::cout << "J: " << J << "\n"; std::cout << "rho: " << fluidState.density(phaseIdx) << "\n"; std::cout << "delta: " << x << "\n"; std::cout << "defect: " << b << "\n"; std::cout << "J: " << J << "\n"; std::cout << "---------------------------\n"; */ // update the fluid composition. b is also used to store // the defect for the next iteration. Scalar relError = update_(fluidState, paramCache, x, b, phaseIdx, targetFug); if (relError < 1e-9) { const Evaluation& rho = FluidSystem::density(fluidState, paramCache, phaseIdx); fluidState.setDensity(phaseIdx, rho); //std::cout << "num iterations: " << nIdx << "\n"; return; } } OPM_THROW(Opm::NumericalProblem, "Calculating the " << FluidSystem::phaseName(phaseIdx) << "Phase composition failed. Initial {x} = {" << xInit << "}, {fug_t} = {" << targetFug << "}, p = " << fluidState.pressure(phaseIdx) << ", T = " << fluidState.temperature(phaseIdx)); }