///
/// Perform the prob scan.
///
/// \param scanner - the scanner to run the scan with
/// \param cId - the id of this combination on the command line
///
void GammaComboEngine::make1dProbScan(MethodProbScan *scanner, int cId)
{
// load start parameters
ParameterCache *pCache = new ParameterCache(arg);
loadStartParameters(scanner, pCache, cId);
scanner->initScan();
scanStrategy1d(scanner, pCache);
cout << "\nResults:" << endl;
cout << "========\n" << endl;
scanner->printLocalMinima();
scanner->calcCLintervals();
if (!arg->isAction("pluginbatch") && !arg->plotpluginonly) {
if ( arg->plotpulls ) scanner->plotPulls();
if ( arg->parevol ) {
ParameterEvolutionPlotter plotter(scanner);
plotter.plotParEvolution();
}
if ( isScanVarObservable(scanner->getCombiner(), arg->var[0]) ) {
ParameterEvolutionPlotter plotter(scanner);
plotter.plotObsScanCheck();
}
if (!arg->isAction("plugin")) {
scanner->saveScanner(m_fnamebuilder->getFileNameScanner(scanner));
pCache->cacheParameters(scanner,m_fnamebuilder->getFileNamePar(scanner));
}
}
}
///
/// Make an Asimov toy: set all observables set to truth values.
/// The truth values are loaded from a parameter file.
///
void GammaComboEngine::loadAsimovPoint(Combiner* c, int cId)
{
if ( arg->asimov[cId]==0 ) return;
cout << "\nAsimov point configuration:\n" << endl;
ParameterCache *pCache = new ParameterCache(arg);
TString asimovfile;
TString asimovfile2 = m_fnamebuilder->getFileNameAsimovPar(c);
TString asimovfile3 = m_fnamebuilder->getFileNameStartPar(c); // this gets the start parameter file of the Asimov combiner
asimovfile3.ReplaceAll(m_fnamebuilder->getAsimovCombinerNameAddition(arg->asimov[cId]),"");
TString asimovfile4 = m_fnamebuilder->getFileNamePar(c); // this gets the result parameter file of the Asimov combiner
asimovfile4.ReplaceAll(m_fnamebuilder->getAsimovCombinerNameAddition(arg->asimov[cId]),"");
bool filefound = false;
// try the file provided through --asimovfile
if ( arg->asimovfile.size()>cId && ! arg->asimovfile[cId].EqualTo("default") ) {
asimovfile = arg->loadParamsFile[cId];
filefound = FileExists(asimovfile);
}
// requested file not found, try default
if ( ! filefound ) {
asimovfile = asimovfile2;
filefound = FileExists(asimovfile);
}
// requested file not found, try the start parameter file of the corresponding non-Asimov combiner
if ( ! filefound ) {
asimovfile = asimovfile3;
filefound = FileExists(asimovfile);
}
// requested file not found, try the result parameter file of the corresponding non-Asimov combiner
if ( ! filefound ) {
asimovfile = asimovfile4;
filefound = FileExists(asimovfile);
}
// if no parameter file exits, we use point from the ParameterAbs class
if ( ! filefound ) {
cout << " No Asimov point parameter file found. Using start values configured in ParameterAbs class." << endl;
cout << " Point files are looked for in the following order:" << endl;
cout << " 1. --asimovfile" << endl;
cout << " 2. " << asimovfile2 << endl;
cout << " 3. " << asimovfile3 << endl;
cout << " 4. " << asimovfile4 << endl;
}
else {
cout << " Loading Asimov points from file: " << asimovfile << endl;
bool loaded = pCache->loadPoints(asimovfile);
if ( !loaded ) {
cout << " Error loading file. Exit." << endl;
exit(1);
}
cout << " Setting point number: " << arg->asimov[cId] << endl;
pCache->setPoint(c,arg->asimov[cId]-1);
}
setAsimovObservables(c);
}
///
/// Make a 2D prob scan.
/// - load start parameters
/// - perform scan
/// - save scanner and parameters
///
/// \param scanner - the scanner
/// \param cId - the id of this combination on the command line
///
void GammaComboEngine::make2dProbScan(MethodProbScan *scanner, int cId)
{
// load start parameters
ParameterCache *pCache = new ParameterCache(arg);
loadStartParameters(scanner, pCache, cId);
// scan
scanner->initScan();
scanStrategy2d(scanner,pCache);
cout << endl;
scanner->printLocalMinima();
// save
scanner->saveScanner(m_fnamebuilder->getFileNameScanner(scanner));
pCache->cacheParameters(scanner, m_fnamebuilder->getFileNamePar(scanner));
}
static Scalar density(const FluidState &fluidState,
const ParameterCache ¶mCache,
unsigned phaseIdx)
{
assert(0 <= phaseIdx && phaseIdx < numPhases);
static_assert(std::is_same<Evaluation, Scalar>::value,
"The SPE-5 fluid system is currently only implemented for the scalar case.");
return fluidState.averageMolarMass(phaseIdx)/paramCache.molarVolume(phaseIdx);
}
static Scalar update_(FluidState &fluidState,
ParameterCache ¶mCache,
Dune::FieldVector<Evaluation, numComponents> &x,
Dune::FieldVector<Evaluation, numComponents> &b,
int phaseIdx,
const Dune::FieldVector<Evaluation, numComponents> &targetFug)
{
typedef MathToolbox<Evaluation> Toolbox;
// store original composition and calculate relative error
Dune::FieldVector<Evaluation, numComponents> origComp;
Scalar relError = 0;
Evaluation sumDelta = Toolbox::createConstant(0.0);
Evaluation sumx = Toolbox::createConstant(0.0);
for (int i = 0; i < numComponents; ++i) {
origComp[i] = fluidState.moleFraction(phaseIdx, i);
relError = std::max(relError, std::abs(Toolbox::value(x[i])));
sumx += Toolbox::abs(fluidState.moleFraction(phaseIdx, i));
sumDelta += Toolbox::abs(x[i]);
}
// chop update to at most 20% change in composition
const Scalar maxDelta = 0.2;
if (sumDelta > maxDelta)
x /= (sumDelta/maxDelta);
// change composition
for (int i = 0; i < numComponents; ++i) {
Evaluation newx = origComp[i] - x[i];
// only allow negative mole fractions if the target fugacity is negative
if (targetFug[i] > 0)
newx = Toolbox::max(0.0, newx);
// only allow positive mole fractions if the target fugacity is positive
else if (targetFug[i] < 0)
newx = Toolbox::min(0.0, newx);
// if the target fugacity is zero, the mole fraction must also be zero
else
newx = 0;
fluidState.setMoleFraction(phaseIdx, i, newx);
}
paramCache.updateComposition(fluidState, phaseIdx);
return relError;
}
static void solveIdealMix_(FluidState &fluidState,
ParameterCache ¶mCache,
int phaseIdx,
const ComponentVector &fugacities)
{
for (int 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,
ParameterCache ¶mCache,
int phasePresence,
const MMPCAuxConstraint<Evaluation> *auxConstraints,
unsigned numAuxConstraints,
bool setViscosity,
bool setInternalEnergy)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
static_assert(std::is_same<typename FluidState::Scalar, Evaluation>::value,
"The scalar type of the fluid state must be 'Evaluation'");
#ifndef NDEBUG
// currently this solver can only handle fluid systems which
// assume ideal mixtures of all fluids. TODO: relax this
// (requires solving a non-linear system of equations, i.e. using
// newton method.)
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
assert(FluidSystem::isIdealMixture(phaseIdx));
}
#endif
// compute all fugacity coefficients
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
paramCache.updatePhase(fluidState, phaseIdx);
// since we assume ideal mixtures, the fugacity
// coefficients of the components cannot depend on
// composition, i.e. the parameters in the cache are valid
for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
Evaluation fugCoeff = FsToolbox::template toLhs<Evaluation>(
FluidSystem::fugacityCoefficient(fluidState, paramCache, phaseIdx, compIdx));
fluidState.setFugacityCoefficient(phaseIdx, compIdx, fugCoeff);
}
}
// create the linear system of equations which defines the
// mole fractions
static const int numEq = numComponents*numPhases;
Dune::FieldMatrix<Evaluation, numEq, numEq> M(Toolbox::createConstant(0.0));
Dune::FieldVector<Evaluation, numEq> x(Toolbox::createConstant(0.0));
Dune::FieldVector<Evaluation, numEq> b(Toolbox::createConstant(0.0));
// assemble the equations expressing the fact that the
// fugacities of each component are equal in all phases
for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
const Evaluation& entryCol1 =
fluidState.fugacityCoefficient(/*phaseIdx=*/0, compIdx)
*fluidState.pressure(/*phaseIdx=*/0);
unsigned col1Idx = compIdx;
for (unsigned phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx) {
unsigned rowIdx = (phaseIdx - 1)*numComponents + compIdx;
unsigned col2Idx = phaseIdx*numComponents + compIdx;
const Evaluation& entryCol2 =
fluidState.fugacityCoefficient(phaseIdx, compIdx)
*fluidState.pressure(phaseIdx);
M[rowIdx][col1Idx] = entryCol1;
M[rowIdx][col2Idx] = -entryCol2;
}
}
// assemble the equations expressing the assumption that the
// sum of all mole fractions in each phase must be 1 for the
// phases present.
unsigned presentPhases = 0;
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
if (!(phasePresence & (1 << phaseIdx)))
continue;
unsigned rowIdx = numComponents*(numPhases - 1) + presentPhases;
presentPhases += 1;
b[rowIdx] = Toolbox::createConstant(1.0);
for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
unsigned colIdx = phaseIdx*numComponents + compIdx;
M[rowIdx][colIdx] = Toolbox::createConstant(1.0);
}
}
assert(presentPhases + numAuxConstraints == numComponents);
// incorperate the auxiliary equations, i.e., the explicitly given mole fractions
for (unsigned auxEqIdx = 0; auxEqIdx < numAuxConstraints; ++auxEqIdx) {
unsigned rowIdx = numComponents*(numPhases - 1) + presentPhases + auxEqIdx;
b[rowIdx] = auxConstraints[auxEqIdx].value();
unsigned colIdx = auxConstraints[auxEqIdx].phaseIdx()*numComponents + auxConstraints[auxEqIdx].compIdx();
M[rowIdx][colIdx] = 1.0;
}
// solve for all mole fractions
try {
Dune::FMatrixPrecision<Scalar>::set_singular_limit(1e-50);
M.solve(x, b);
}
catch (const Dune::FMatrixError &e) {
OPM_THROW(NumericalProblem,
"Numerical problem in MiscibleMultiPhaseComposition::solve(): " << e.what() << "; M="<<M);
}
catch (...) {
throw;
}
// set all mole fractions and the additional quantities in
// the fluid state
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
unsigned rowIdx = phaseIdx*numComponents + compIdx;
fluidState.setMoleFraction(phaseIdx, compIdx, x[rowIdx]);
}
paramCache.updateComposition(fluidState, phaseIdx);
const Evaluation& rho = FluidSystem::density(fluidState, paramCache, phaseIdx);
fluidState.setDensity(phaseIdx, rho);
if (setViscosity) {
const Evaluation& mu = FluidSystem::viscosity(fluidState, paramCache, phaseIdx);
fluidState.setViscosity(phaseIdx, mu);
}
if (setInternalEnergy) {
const Evaluation& h = FluidSystem::enthalpy(fluidState, paramCache, phaseIdx);
fluidState.setEnthalpy(phaseIdx, h);
}
}
}
void checkFluidSystem()
{
std::cout << "Testing fluid system '" << Dune::className<FluidSystem>() << "'\n";
// make sure the fluid system provides the number of phases and
// the number of components
enum { numPhases = FluidSystem::numPhases };
enum { numComponents = FluidSystem::numComponents };
typedef HairSplittingFluidState<RhsEval, FluidSystem> FluidState;
FluidState fs;
fs.allowTemperature(true);
fs.allowPressure(true);
fs.allowComposition(true);
fs.restrictToPhase(-1);
// initialize memory the fluid state
fs.base().setTemperature(273.15 + 20.0);
for (int phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) {
fs.base().setPressure(phaseIdx, 1e5);
fs.base().setSaturation(phaseIdx, 1.0/numPhases);
for (int compIdx = 0; compIdx < numComponents; ++ compIdx) {
fs.base().setMoleFraction(phaseIdx, compIdx, 1.0/numComponents);
}
}
static_assert(std::is_same<typename FluidSystem::Scalar, Scalar>::value,
"The type used for floating point used by the fluid system must be the same"
" as the one passed to the checkFluidSystem() function");
// check whether the parameter cache adheres to the API
typedef typename FluidSystem::template ParameterCache<LhsEval> ParameterCache;
ParameterCache paramCache;
try { paramCache.updateAll(fs); } catch (...) {};
try { paramCache.updateAll(fs, /*except=*/ParameterCache::None); } catch (...) {};
try { paramCache.updateAll(fs, /*except=*/ParameterCache::Temperature | ParameterCache::Pressure | ParameterCache::Composition); } catch (...) {};
try { paramCache.updateAllPressures(fs); } catch (...) {};
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
fs.restrictToPhase(static_cast<int>(phaseIdx));
try { paramCache.updatePhase(fs, phaseIdx); } catch (...) {};
try { paramCache.updatePhase(fs, phaseIdx, /*except=*/ParameterCache::None); } catch (...) {};
try { paramCache.updatePhase(fs, phaseIdx, /*except=*/ParameterCache::Temperature | ParameterCache::Pressure | ParameterCache::Composition); } catch (...) {};
try { paramCache.updateTemperature(fs, phaseIdx); } catch (...) {};
try { paramCache.updatePressure(fs, phaseIdx); } catch (...) {};
try { paramCache.updateComposition(fs, phaseIdx); } catch (...) {};
try { paramCache.updateSingleMoleFraction(fs, phaseIdx, /*compIdx=*/0); } catch (...) {};
}
// some value to make sure the return values of the fluid system
// are convertible to scalars
LhsEval val = 0.0;
Scalar scalarVal = 0.0;
scalarVal = 2*scalarVal; // get rid of GCC warning (only occurs with paranoid warning flags)
val = 2*val; // get rid of GCC warning (only occurs with paranoid warning flags)
// actually check the fluid system API
try { FluidSystem::init(); } catch (...) {};
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) {
fs.restrictToPhase(static_cast<int>(phaseIdx));
fs.allowPressure(FluidSystem::isCompressible(phaseIdx));
fs.allowComposition(true);
fs.allowDensity(false);
try { auto tmpVal OPM_UNUSED = FluidSystem::density(fs, paramCache, phaseIdx); static_assert(std::is_same<decltype(tmpVal), RhsEval>::value, "The default return value must be the scalar used by the fluid state!"); } catch (...) {};
try { val = FluidSystem::template density<FluidState, LhsEval>(fs, paramCache, phaseIdx); } catch (...) {};
try { scalarVal = FluidSystem::template density<FluidState, Scalar>(fs, paramCache, phaseIdx); } catch (...) {};
fs.allowPressure(true);
fs.allowDensity(true);
try { auto tmpVal OPM_UNUSED = FluidSystem::viscosity(fs, paramCache, phaseIdx); static_assert(std::is_same<decltype(tmpVal), RhsEval>::value, "The default return value must be the scalar used by the fluid state!"); } catch (...) {};
try { auto tmpVal OPM_UNUSED = FluidSystem::enthalpy(fs, paramCache, phaseIdx); static_assert(std::is_same<decltype(tmpVal), RhsEval>::value, "The default return value must be the scalar used by the fluid state!"); } catch (...) {};
try { auto tmpVal OPM_UNUSED = FluidSystem::heatCapacity(fs, paramCache, phaseIdx); static_assert(std::is_same<decltype(tmpVal), RhsEval>::value, "The default return value must be the scalar used by the fluid state!"); } catch (...) {};
try { auto tmpVal OPM_UNUSED= FluidSystem::thermalConductivity(fs, paramCache, phaseIdx); static_assert(std::is_same<decltype(tmpVal), RhsEval>::value, "The default return value must be the scalar used by the fluid state!"); } catch (...) {};
try { val = FluidSystem::template viscosity<FluidState, LhsEval>(fs, paramCache, phaseIdx); } catch (...) {};
try { val = FluidSystem::template enthalpy<FluidState, LhsEval>(fs, paramCache, phaseIdx); } catch (...) {};
try { val = FluidSystem::template heatCapacity<FluidState, LhsEval>(fs, paramCache, phaseIdx); } catch (...) {};
try { val = FluidSystem::template thermalConductivity<FluidState, LhsEval>(fs, paramCache, phaseIdx); } catch (...) {};
try { scalarVal = FluidSystem::template viscosity<FluidState, Scalar>(fs, paramCache, phaseIdx); } catch (...) {};
try { scalarVal = FluidSystem::template enthalpy<FluidState, Scalar>(fs, paramCache, phaseIdx); } catch (...) {};
try { scalarVal = FluidSystem::template heatCapacity<FluidState, Scalar>(fs, paramCache, phaseIdx); } catch (...) {};
try { scalarVal = FluidSystem::template thermalConductivity<FluidState, Scalar>(fs, paramCache, phaseIdx); } catch (...) {};
for (unsigned compIdx = 0; compIdx < numComponents; ++ compIdx) {
fs.allowComposition(!FluidSystem::isIdealMixture(phaseIdx));
try { auto tmpVal OPM_UNUSED = FluidSystem::fugacityCoefficient(fs, paramCache, phaseIdx, compIdx); static_assert(std::is_same<decltype(tmpVal), RhsEval>::value, "The default return value must be the scalar used by the fluid state!"); } catch (...) {};
try { val = FluidSystem::template fugacityCoefficient<FluidState, LhsEval>(fs, paramCache, phaseIdx, compIdx); } catch (...) {};
try { scalarVal = FluidSystem::template fugacityCoefficient<FluidState, Scalar>(fs, paramCache, phaseIdx, compIdx); } catch (...) {};
fs.allowComposition(true);
try { auto tmpVal OPM_UNUSED = FluidSystem::diffusionCoefficient(fs, paramCache, phaseIdx, compIdx); static_assert(std::is_same<decltype(tmpVal), RhsEval>::value, "The default return value must be the scalar used by the fluid state!"); } catch (...) {};
try { val = FluidSystem::template diffusionCoefficient<FluidState, LhsEval>(fs, paramCache, phaseIdx, compIdx); } catch (...) {};
try { scalarVal = FluidSystem::template fugacityCoefficient<FluidState, Scalar>(fs, paramCache, phaseIdx, compIdx); } catch (...) {};
}
}
// test for phaseName(), isLiquid() and isIdealGas()
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) {
std::string name OPM_UNUSED = FluidSystem::phaseName(phaseIdx);
bool bVal = FluidSystem::isLiquid(phaseIdx);
bVal = FluidSystem::isIdealGas(phaseIdx);
bVal = !bVal; // get rid of GCC warning (only occurs with paranoid warning flags)
}
// test for molarMass() and componentName()
for (unsigned compIdx = 0; compIdx < numComponents; ++ compIdx) {
val = FluidSystem::molarMass(compIdx);
std::string name = FluidSystem::componentName(compIdx);
}
std::cout << "----------------------------------\n";
}
static void solve(FluidState &fluidState,
ParameterCache ¶mCache,
int 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 (int compIdx = 0; compIdx < numComponents; ++compIdx) {
fluidState.setFugacityCoefficient(refPhaseIdx,
compIdx,
FluidSystem::fugacityCoefficient(fluidState,
paramCache,
refPhaseIdx,
compIdx));
}
// compute all quantities for the non-reference phases
for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
if (phaseIdx == refPhaseIdx)
continue; // reference phase is already calculated
ComponentVector fugVec;
for (int compIdx = 0; compIdx < numComponents; ++compIdx) {
const auto& fug = fluidState.fugacity(refPhaseIdx, compIdx);
fugVec[compIdx] = FsToolbox::template toLhs<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,
ParameterCache ¶mCache,
int 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 (int 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 (int i = 0; i < FluidSystem::numComponents; ++i)
std::cout << fluidState.moleFraction(phaseIdx, i) << " ";
std::cout << "\n";
std::cout << FluidSystem::phaseName(phaseIdx) << "Phase phi: ";
for (int 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::NumericalIssue(e.what()); }
//std::cout << "original delta: " << x << "\n";
Valgrind::CheckDefined(x);
/*
std::cout << FluidSystem::phaseName(phaseIdx) << "Phase composition: ";
for (int 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::NumericalIssue,
"Calculating the " << FluidSystem::phaseName(phaseIdx)
<< "Phase composition failed. Initial {x} = {"
<< xInit
<< "}, {fug_t} = {" << targetFug << "}, p = " << fluidState.pressure(phaseIdx)
<< ", T = " << fluidState.temperature(phaseIdx));
}
static Scalar linearize_(Dune::FieldMatrix<Evaluation, numComponents, numComponents> &J,
Dune::FieldVector<Evaluation, numComponents> &defect,
FluidState &fluidState,
ParameterCache ¶mCache,
int phaseIdx,
const ComponentVector &targetFug)
{
typedef MathToolbox<Evaluation> Toolbox;
// reset jacobian
J = 0;
Scalar absError = 0;
// calculate the defect (deviation of the current fugacities
// from the target fugacities)
for (int i = 0; i < numComponents; ++ i) {
const Evaluation& phi = FluidSystem::fugacityCoefficient(fluidState,
paramCache,
phaseIdx,
i);
const Evaluation& f = phi*fluidState.pressure(phaseIdx)*fluidState.moleFraction(phaseIdx, i);
fluidState.setFugacityCoefficient(phaseIdx, i, phi);
defect[i] = targetFug[i] - f;
absError = std::max(absError, std::abs(Toolbox::value(defect[i])));
}
// assemble jacobian matrix of the constraints for the composition
static const Scalar eps = std::numeric_limits<Scalar>::epsilon()*1e6;
for (int i = 0; i < numComponents; ++ i) {
////////
// approximately calculate partial derivatives of the
// fugacity defect of all components in regard to the mole
// fraction of the i-th component. This is done via
// forward differences
// deviate the mole fraction of the i-th component
Evaluation xI = fluidState.moleFraction(phaseIdx, i);
fluidState.setMoleFraction(phaseIdx, i, xI + eps);
paramCache.updateSingleMoleFraction(fluidState, phaseIdx, i);
// compute new defect and derivative for all component
// fugacities
for (int j = 0; j < numComponents; ++j) {
// compute the j-th component's fugacity coefficient ...
const Evaluation& phi = FluidSystem::fugacityCoefficient(fluidState,
paramCache,
phaseIdx,
j);
// ... and its fugacity ...
const Evaluation& f =
phi *
fluidState.pressure(phaseIdx) *
fluidState.moleFraction(phaseIdx, j);
// as well as the defect for this fugacity
const Evaluation& defJPlusEps = targetFug[j] - f;
// use forward differences to calculate the defect's
// derivative
J[j][i] = (defJPlusEps - defect[j])/eps;
}
// reset composition to original value
fluidState.setMoleFraction(phaseIdx, i, xI);
paramCache.updateSingleMoleFraction(fluidState, phaseIdx, i);
// end forward differences
////////
}
return absError;
}