evalsolution.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:
//
// SPDX-FileCopyrightText: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_DISCRETIZATION_EVAL_SOLUTION_HH
#define DUMUX_DISCRETIZATION_EVAL_SOLUTION_HH
 
#include <iterator>
#include <algorithm>
#include <type_traits>
#include <memory>
 
#include <dune/localfunctions/lagrange/pqkfactory.hh>
 
#include <dumux/common/typetraits/state.hh>
#include <dumux/common/typetraits/isvalid.hh>
#include <dumux/discretization/method.hh>
#include <dumux/discretization/cvfe/elementsolution.hh>
#include <dumux/discretization/cellcentered/elementsolution.hh>
 
namespace Dumux {
 
// some implementation details
namespace Detail {

template<class ElementSolution>
bool allStatesEqual(const ElementSolution& elemSol, std::true_type hasState)
{
    // determine if all states are the same at all vertices
    auto firstState = elemSol[0].state();
    for (std::size_t i = 1; i < elemSol.size(); ++i)
        if (elemSol[i].state() != firstState)
            return false;
 
    return true;
}

template<class ElementSolution>
bool allStatesEqual(const ElementSolution& elemSol, std::false_type hasState)
{
    return true;
}

template<class Geometry, class ElementSolution>
auto minDistVertexSol(const Geometry& geometry, const typename Geometry::GlobalCoordinate& globalPos,
                      const ElementSolution& elemSol)
{
    // calculate the distances from the evaluation point to the vertices
    std::vector<typename Geometry::ctype> distances(geometry.corners());
    for (int i = 0; i < geometry.corners(); ++i)
        distances[i] = (geometry.corner(i) - globalPos).two_norm2();
 
    // determine the minimum distance and corresponding vertex
    auto minDistanceIt = std::min_element(distances.begin(), distances.end());
    return elemSol[std::distance(distances.begin(), minDistanceIt)];
}

template<class Element, class GridGeometry, class ElementSolution>
auto minDistDofSol(const Element& element,
                   const GridGeometry& gridGeometry,
                   const typename Element::Geometry::LocalCoordinate& localPos,
                   const ElementSolution& elemSol)
{
    using DofHelper = GridGeometry::Cache::DofHelper;
    const auto& localCoeffs = gridGeometry.feCache().get(element.type()).localCoefficients();
    // calculate the distances from the evaluation point to the local positions of dofs
    std::vector<typename Element::Geometry::ctype> distances(localCoeffs.size());
    for (int idx = 0; idx < localCoeffs.size(); ++idx)
    {
        const auto& localDofPos = DofHelper::localDofPosition(element.type(), localCoeffs.localKey(idx));
        distances[idx] = (localPos - localDofPos).two_norm2();
    }
 
    // determine the minimum distance and corresponding vertex
    auto minDistanceIt = std::min_element(distances.begin(), distances.end());
    return elemSol[std::distance(distances.begin(), minDistanceIt)];
}

template<class Element, class GridGeometry, class CVFEElemSol>
typename CVFEElemSol::PrimaryVariables
evalCVFESolutionAtLocalPos(const Element& element,
                           const typename Element::Geometry& geometry,
                           const GridGeometry& gridGeometry,
                           const CVFEElemSol& elemSol,
                           const typename Element::Geometry::LocalCoordinate& localPos,
                           bool ignoreState = false)
{
    // determine if all states are the same at all vertices
    using HasState = decltype(isValid(Detail::hasState())(elemSol[0]));
    bool allStatesEqual = ignoreState || Detail::allStatesEqual(elemSol, HasState{});
 
    if (allStatesEqual)
    {
        // interpolate the solution
        const auto& localBasis = gridGeometry.feCache().get(geometry.type()).localBasis();
 
        // evaluate the shape functions at the scv center
        using ShapeValue = typename std::decay_t<decltype(localBasis)>::Traits::RangeType;
        std::vector<ShapeValue> shapeValues;
        localBasis.evaluateFunction(localPos, shapeValues);
 
        typename CVFEElemSol::PrimaryVariables result(0.0);
        for (int i = 0; i < shapeValues.size(); ++i)
        {
            auto value = elemSol[i];
            value *= shapeValues[i][0];
            result += value;
        }
 
        // set an arbitrary state if the model requires a state (models constexpr if)
        if constexpr (HasState{})
            if (!ignoreState)
                result.setState(elemSol[0].state());
 
        return result;
    }
    else
    {
        static bool warnedAboutUsingMinDist = false;
        if (!warnedAboutUsingMinDist)
        {
            std::cout << "Warning: Using nearest-neighbor interpolation in evalSolution"
            << "\nbecause not all states are equal and ignoreState is false!"
            << std::endl;
            warnedAboutUsingMinDist = true;
        }
 
        return Detail::minDistDofSol(element, gridGeometry, localPos, elemSol);
    }
}
 
} // end namespace Detail

template<class Element, class FVElementGeometry, class PrimaryVariables>
PrimaryVariables evalSolutionAtLocalPos(const Element& element,
                                        const typename Element::Geometry& geometry,
                                        const typename FVElementGeometry::GridGeometry& gridGeometry,
                                        const CVFEElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
                                        const typename Element::Geometry::LocalCoordinate& localPos,
                                        bool ignoreState = false)
{
    return Detail::evalCVFESolutionAtLocalPos(element, geometry, gridGeometry, elemSol, localPos, ignoreState);
}
 

template<class Element, class FVElementGeometry, class PrimaryVariables>
PrimaryVariables evalSolution(const Element& element,
                              const typename Element::Geometry& geometry,
                              const typename FVElementGeometry::GridGeometry& gridGeometry,
                              const CVFEElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
                              const typename Element::Geometry::GlobalCoordinate& globalPos,
                              bool ignoreState = false)
{
    const auto& localPos = geometry.local(globalPos);
    return evalSolutionAtLocalPos(element, geometry, gridGeometry, elemSol, localPos, ignoreState);
}

template<class Element, class FVElementGeometry, class PrimaryVariables>
PrimaryVariables evalSolution(const Element& element,
                              const typename Element::Geometry& geometry,
                              const CVFEElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
                              const typename Element::Geometry::GlobalCoordinate& globalPos,
                              bool ignoreState = false)
{
    static_assert(FVElementGeometry::GridGeometry::discMethod == DiscretizationMethods::box, "Only implemented for the Box method");
 
    // determine if all states are the same at all vertices
    using HasState = decltype(isValid(Detail::hasState())(elemSol[0]));
    bool allStatesEqual = ignoreState || Detail::allStatesEqual(elemSol, HasState{});
 
    if (allStatesEqual)
    {
        using CoordScalar = typename Element::Geometry::GlobalCoordinate::value_type;
        static constexpr int dim = Element::Geometry::mydimension;
 
        // The box scheme always uses linear Ansatz functions (real-valued also for complex-valued solutions)
        using FEFactory = Dune::PQkLocalFiniteElementFactory<CoordScalar, CoordScalar, dim, 1>;
        using FiniteElement = typename FEFactory::FiniteElementType;
        std::unique_ptr<FiniteElement> fe(FEFactory::create(geometry.type()));
        const auto& localBasis = fe->localBasis();
 
        // evaluate the shape functions at the scv center
        const auto localPos = geometry.local(globalPos);
        using ShapeValue = typename FiniteElement::Traits::LocalBasisType::Traits::RangeType;
        std::vector< ShapeValue > shapeValues;
        localBasis.evaluateFunction(localPos, shapeValues);
 
        PrimaryVariables result(0.0);
        for (int i = 0; i < geometry.corners(); ++i)
        {
            auto value = elemSol[i];
            value *= shapeValues[i][0];
            result += value;
        }
 
        // set an arbitrary state if the model requires a state (models constexpr if)
        if constexpr (HasState{})
            if (!ignoreState)
                result.setState(elemSol[0].state());
 
        return result;
    }
    else
    {
        static bool warnedAboutUsingMinDist = false;
        if (!warnedAboutUsingMinDist)
        {
            std::cout << "Warning: Using nearest-neighbor interpolation in evalSolution"
            << "\nbecause not all states are equal and ignoreState is false!"
            << std::endl;
            warnedAboutUsingMinDist = true;
        }
 
        return Detail::minDistVertexSol(geometry, globalPos, elemSol);
    }
}

template<class Element, class FVElementGeometry, class PrimaryVariables>
PrimaryVariables evalSolution(const Element& element,
                              const typename Element::Geometry& geometry,
                              const typename FVElementGeometry::GridGeometry& gridGeometry,
                              const CCElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
                              const typename Element::Geometry::GlobalCoordinate& globalPos,
                              bool ignoreState = false)
{
    return elemSol[0];
}

template<class Element, class FVElementGeometry, class PrimaryVariables>
PrimaryVariables evalSolutionAtLocalPos(const Element& element,
                                        const typename Element::Geometry& geometry,
                                        const typename FVElementGeometry::GridGeometry& gridGeometry,
                                        const CCElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
                                        const typename Element::Geometry::LocalCoordinate& localPos,
                                        bool ignoreState = false)
{
    return elemSol[0];
}
 

template< class Element, class FVElementGeometry, class PrimaryVariables>
PrimaryVariables evalSolution(const Element& element,
                              const typename Element::Geometry& geometry,
                              const CCElementSolution<FVElementGeometry, PrimaryVariables>& elemSol,
                              const typename Element::Geometry::GlobalCoordinate& globalPos,
                              bool ignoreState = false)
{
    return elemSol[0];
}
 
} // namespace Dumux
 
#endif