common/problem.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_COMMON_DEFAULT_PROBLEM_HH
#define DUMUX_COMMON_DEFAULT_PROBLEM_HH
 
#include <memory>
 
#include <dumux/common/properties.hh>
#include <dumux/common/parameters.hh>
#include <dumux/common/boundarytypes_.hh>
#include <dumux/common/numeqvector.hh>
 
#include <dumux/assembly/boundaryfluxintegral.hh>
#include <dumux/discretization/concepts.hh>
#include <dumux/common/pointsources.hh>
 
namespace Dumux::Experimental {

template<class TypeTag>
class Problem
{
    using Implementation = GetPropType<TypeTag, Properties::Problem>;
 
    using GridDiscretization = GetPropType<TypeTag, Properties::GridGeometry>;
    using ElementDiscretization = typename GridDiscretization::LocalView;
    using GridView = typename GridDiscretization::GridView;
    using Element = typename GridView::template Codim<0>::Entity;
    using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
 
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
    using NumEqVector = Dumux::NumEqVector<GetPropType<TypeTag, Properties::PrimaryVariables>>;
    using BoundaryTypes = Dumux::Experimental::BoundaryTypes<PrimaryVariables::size()>;
 
public:
    struct Traits
    {
        using Scalar = Problem::Scalar;
        using PrimaryVariables = Problem::PrimaryVariables;
        using NumEqVector = Problem::NumEqVector;
    };

    Problem(std::shared_ptr<const GridDiscretization> gridDiscretization, const std::string& paramGroup = "")
    : gridDiscretization_(gridDiscretization)
    , paramGroup_(paramGroup)
    {
        // set a default name for the problem
        problemName_ = getParamFromGroup<std::string>(paramGroup, "Problem.Name", "sim");
    }

    const std::string& name() const
    {
        return problemName_;
    }

    void setName(const std::string& newName)
    {
        problemName_ = newName;
    }

    // \{

    BoundaryTypes boundaryTypes(const ElementDiscretization& elemDisc,
                                const typename ElementDiscretization::BoundaryFace& boundaryFace) const
    {
        // forward it to the method which only takes the global coordinate
        return asImp_().boundaryTypesAtPos(boundaryFace.center());
    }

    BoundaryTypes boundaryTypesAtPos(const GlobalPosition &globalPos) const
    {
        return BoundaryTypes{};
    }

    template<class ResidualVector, class ElementVariables, class BoundaryTypes>
    void addFEBoundaryFluxIntegral(ResidualVector& residual,
                                   const ElementDiscretization& elemDisc,
                                   const ElementVariables& elemVars,
                                   const typename ElementDiscretization::BoundaryFace& boundaryFace,
                                   const BoundaryTypes& bcTypes) const
    {
        Dumux::Experimental::addFEBoundaryFluxIntegral(residual, asImp_(), elemDisc, elemVars, boundaryFace, bcTypes);
    }

    template<class ResidualVector, class ElementVariables, class SubControlVolumeFace, class BoundaryTypes>
    void addFVBoundaryFluxIntegral(ResidualVector& residual,
                                   const ElementDiscretization& elemDisc,
                                   const ElementVariables& elemVars,
                                   const SubControlVolumeFace& scvf,
                                   const BoundaryTypes& bcTypes) const
    {
        Dumux::Experimental::addFVBoundaryFluxIntegral(residual, asImp_(), elemDisc, elemVars, scvf, bcTypes);
    }
 

    template<class ElementVariables, class FaceIpData>
    NumEqVector boundaryFlux(const ElementDiscretization& elemDisc,
                             const ElementVariables& elemVars,
                             const FaceIpData& faceIpData) const
    {
        // forward it to the interface with only the global position
        return asImp_().boundaryFluxAtPos(faceIpData.global());
    }

    NumEqVector boundaryFluxAtPos(const GlobalPosition& globalPos) const
    {
        return NumEqVector(0.0);
    }

    template<class ElementVariables, class IpData>
    NumEqVector source(const ElementDiscretization& elemDisc,
                       const ElementVariables& elemVars,
                       const IpData& ipData) const
    {
        return asImp_().sourceAtPos(ipData.global());
    }

    NumEqVector sourceAtPos(const GlobalPosition &globalPos) const
    {
        return NumEqVector(0.0);
    }

    template<class MatrixBlock, class Variables, class IpData>
    void addSourceDerivatives(MatrixBlock& block,
                              const Element& element,
                              const ElementDiscretization& elemDisc,
                              const Variables& volVars,
                              const IpData& ipData) const {}

    EmptyPointSources pointSources() const
    { return {}; }

    [[deprecated("Use gridDiscretization() instead")]]
    const GridDiscretization& gridGeometry() const
    { return *gridDiscretization_; }

    const GridDiscretization& gridDiscretization() const
    { return *gridDiscretization_; }

    const std::string& paramGroup() const
    { return paramGroup_; }
 
protected:
    Implementation &asImp_()
    { return *static_cast<Implementation *>(this); }

    const Implementation &asImp_() const
    { return *static_cast<const Implementation *>(this); }
 
private:
    std::shared_ptr<const GridDiscretization> gridDiscretization_;

    std::string paramGroup_;

    std::string problemName_;
};
 
} // end namespace Dumux::Experimental
 
#endif