subgriddata.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-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_IO_GRID_PORENETWORK_SUBGRID_DATA_HH
#define DUMUX_IO_GRID_PORENETWORK_SUBGRID_DATA_HH
 
#include <vector>
#include <memory>
#include "griddata.hh"
 
namespace Dumux::PoreNetwork {
 
template<class HostGrid, class SubGrid>
class SubGridData
{
    static constexpr int dim = SubGrid::dimension;
    static constexpr int dimWorld = SubGrid::dimensionworld;
    using Intersection = typename SubGrid::LeafIntersection;
    using Element = typename SubGrid::template Codim<0>::Entity;
    using Vertex = typename SubGrid::template Codim<dim>::Entity;
    using GridView = typename SubGrid::LeafGridView;
    using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
    using SmallLocalIndex = typename IndexTraits<GridView>::SmallLocalIndex;
 
public:
    SubGridData(const SubGrid& subGrid,
                std::shared_ptr<const GridData<HostGrid>> hostGridData)
    : subGrid_(subGrid)
    , hostGridData_(hostGridData)
    {}
 
    const std::vector<double>& parameters(const Vertex& vertex) const
    { return hostGridData_->parameters(vertex.impl().hostEntity()); }
 
    const std::vector<double>& parameters(const Element& element) const
    { return hostGridData_->parameters(element.impl().hostEntity()); }
 
    auto getParameter(const Element& element, const std::string& param) const
    { return hostGridData_->getParameter(element.impl().hostEntity(), param); }
 
    auto getParameter(const Vertex& vertex, const std::string& param) const
    { return hostGridData_->getParameter(vertex.impl().hostEntity(), param); }
 
    template <class GridImp, class IntersectionImp>
    const Dune::DGFBoundaryParameter::type& parameters(const Dune::Intersection<GridImp, IntersectionImp>& intersection) const
    { return hostGridData_->parameters(intersection); }
 
    auto throatLabel(const Element& element) const
    { return hostGridData_->throatLabel(element.impl().hostEntity()); }
 
    int boundaryFaceMarkerAtPos(const GlobalPosition& pos) const
    { return hostGridData_->boundaryFaceMarkerAtPos(pos); }
 
    std::vector<SmallLocalIndex> getCoordinationNumbers() const
    {
        const auto gridView = subGrid_.leafGridView();
 
        std::vector<SmallLocalIndex>  coordinationNumbers(gridView.size(dim), 0);
 
        for (const auto &element : elements(gridView))
        {
            for (SmallLocalIndex vIdxLocal = 0; vIdxLocal < 2; ++vIdxLocal)
            {
                const auto vIdxGlobal = gridView.indexSet().subIndex(element, vIdxLocal, dim);
                coordinationNumbers[vIdxGlobal] += 1;
            }
        }
 
        if (std::any_of(coordinationNumbers.begin(), coordinationNumbers.end(), [](auto i){ return i == 0; }))
            DUNE_THROW(Dune::InvalidStateException, "One of the pores is not connected to another pore. SanitizeGrid will not help in this case. Check your grid file");
 
        return coordinationNumbers;
    }
 
    int parameterIndex(const std::string& paramName) const
    { return hostGridData_->parameterIndex(paramName); }
 
    const std::string& paramGroup() const
    { return hostGridData_->paramGroup(); }
 
    bool gridHasElementParameter(const std::string& param) const
    { return hostGridData_->gridHasElementParameter(param); }
 
    bool gridHasVertexParameter(const std::string& param) const
    { return hostGridData_->gridHasVertexParameter(param); }
 
    const std::vector<std::string>& vertexParameterNames() const
    { return hostGridData_->vertexParameterNames() ; }
 
    const std::vector<std::string>& elementParameterNames() const
    { return hostGridData_->elementParameterNames() ; }
 
private:
    const SubGrid& subGrid_;
    std::shared_ptr<const GridData<HostGrid>> hostGridData_;
};
 
} // end namespace Dumux::PoreNetwork
 
#endif