computefromreferencephase.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
 *   See the file COPYING for full copying permissions.                      *
 *                                                                           *
 *   This program is free software: you can redistribute it and/or modify    *
 *   it under the terms of the GNU General Public License as published by    *
 *   the Free Software Foundation, either version 3 of the License, or       *
 *   (at your option) any later version.                                     *
 *                                                                           *
 *   This program is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU General Public License for more details.                            *
 *                                                                           *
 *   You should have received a copy of the GNU General Public License       *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
 *****************************************************************************/
#ifndef DUMUX_COMPUTE_FROM_REFERENCE_PHASE_HH
#define DUMUX_COMPUTE_FROM_REFERENCE_PHASE_HH
 
#include <dumux/material/constraintsolvers/compositionfromfugacities.hh>
 
#include <dune/common/fvector.hh>
#include <dune/common/fmatrix.hh>
 
#include <dumux/common/exceptions.hh>
#include <dumux/common/valgrind.hh>
 
namespace Dumux {

template <class Scalar, class FluidSystem>
class ComputeFromReferencePhase
{
    enum { numPhases = FluidSystem::numPhases };
    enum { numComponents = FluidSystem::numComponents };
    using CompositionFromFugacities = Dumux::CompositionFromFugacities<Scalar, FluidSystem>;
    using ComponentVector = Dune::FieldVector<Scalar, numComponents>;
 
public:
    template <class FluidState, class ParameterCache>
    static void solve(FluidState &fluidState,
                      ParameterCache &paramCache,
                      int refPhaseIdx)
    {
        ComponentVector fugVec;
 
        // compute the density and enthalpy of the
        // reference phase
        paramCache.updatePhase(fluidState, refPhaseIdx);
        fluidState.setDensity(refPhaseIdx,
                              FluidSystem::density(fluidState,
                                                   paramCache,
                                                   refPhaseIdx));
        fluidState.setMolarDensity(refPhaseIdx,
                                   FluidSystem::molarDensity(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));
            fugVec[compIdx] = fluidState.fugacity(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
 
            CompositionFromFugacities::guessInitial(fluidState, paramCache, phaseIdx, fugVec);
            CompositionFromFugacities::solve(fluidState, paramCache, phaseIdx, fugVec);
        }
    }
};
 
} // end namespace Dumux
 
#endif