diff --git a/dumux/multidomain/facet/box/couplingmapper.hh b/dumux/multidomain/facet/box/couplingmapper.hh
index b186d662df63c3330741aa7588dd9db26faaa689..e36ed779786a845e43fcc248bd33cd160bda1409 100644
--- a/dumux/multidomain/facet/box/couplingmapper.hh
+++ b/dumux/multidomain/facet/box/couplingmapper.hh
@@ -69,16 +69,16 @@ public:
*
* \param bulkFvGridGeometry The finite-volume grid geometry of the bulk grid
* \param lowDimFvGridGeometry The finite-volume grid geometry of the lower-dimensional grid
- * \param gridManager Class that contains the embedments and allows obtaining entity insertion indices
+ * \param embeddings Class that contains the embedments among the grids and entity insertion indices
*/
- template< class GridManager >
+ template< class Embeddings >
void update(const BulkFVG& bulkFvGridGeometry,
const LowDimFVG& lowDimFvGridGeometry,
- const GridManager& gridManager)
+ std::shared_ptr<const Embeddings> embeddings)
{
// forward to update function with instantiated vertex adapter
- using GridAdapter = CodimOneGridAdapter<GridManager, bulkGridId, facetGridId>;
- update(bulkFvGridGeometry, lowDimFvGridGeometry, gridManager, GridAdapter{gridManager});
+ using GridAdapter = CodimOneGridAdapter<Embeddings, bulkGridId, facetGridId>;
+ update(bulkFvGridGeometry, lowDimFvGridGeometry, embeddings, GridAdapter(embeddings));
}
/*!
* \brief Update coupling maps. This is the standard
@@ -86,20 +86,20 @@ public:
*
* \param bulkFvGridGeometry The finite-volume grid geometry of the bulk grid
* \param lowDimFvGridGeometry The finite-volume grid geometry of the lower-dimensional grid
- * \param gridManager Class that contains the embedments and allows obtaining entity insertion indices
+ * \param embeddings Class that contains the embedments among the grids and entity insertion indices
* \param codimOneGridAdapter Allows direct access to data on the bulk grid for lowdim grid entities
*/
- template< class GridManager, class CodimOneGridAdapter >
+ template< class Embeddings, class CodimOneGridAdapter >
void update(const BulkFVG& bulkFvGridGeometry,
const LowDimFVG& lowDimFvGridGeometry,
- const GridManager& gridManager,
+ std::shared_ptr<const Embeddings> embeddings,
const CodimOneGridAdapter& codimOneGridAdapter)
{
- // define the execution policy how to add map entries from an embedment
- auto addEmbedmentPolicy = [&] (auto&& embedments,
- const LowDimElement& lowDimElement,
- const LowDimFVG& lowDimFvGridGeometry,
- const BulkFVG& bulkFvGridGeometry)
+ // define the policy how to add map entries for given lowdim element and adjoined entity indices
+ auto addCouplingEntryPolicy = [&] (auto&& adjoinedEntityIndices,
+ const LowDimElement& lowDimElement,
+ const LowDimFVG& lowDimFvGridGeometry,
+ const BulkFVG& bulkFvGridGeometry)
{
using LowDimIndexType = typename LowDimGridView::IndexSet::IndexType;
using BulkIndexType = typename BulkGridView::IndexSet::IndexType;
@@ -115,10 +115,10 @@ public:
for (int i = 0; i < numElementCorners; ++i)
elementCorners[i] = codimOneGridAdapter.bulkGridVertexIndex(lowDimElement.template subEntity<lowDimDim>(i));
- // save unsorted set of corner indices and search scvfs in embedments
+ // save unsorted set of corner indices and search scvfs in adjoined entities
const auto unsortedElemCorners = elementCorners;
std::sort(elementCorners.begin(), elementCorners.end());
- for (auto bulkElemIdx : embedments)
+ for (auto bulkElemIdx : adjoinedEntityIndices)
{
const auto bulkElement = bulkFvGridGeometry.element(bulkElemIdx);
const auto bulkRefElem = BulkReferenceElements::general(bulkElement.geometry().type());
@@ -204,7 +204,7 @@ public:
};
// let the parent do the update subject to the execution policy defined above
- ParentType::update_(bulkFvGridGeometry, lowDimFvGridGeometry, gridManager, addEmbedmentPolicy);
+ ParentType::update_(bulkFvGridGeometry, lowDimFvGridGeometry, embeddings, addCouplingEntryPolicy);
// coupling stencils might not be unique with the policy above
auto makeStencilUnique = [] (auto& data)
diff --git a/dumux/multidomain/facet/cellcentered/tpfa/couplingmapper.hh b/dumux/multidomain/facet/cellcentered/tpfa/couplingmapper.hh
index 198e3f9379b80b6ddfe00d5e824d2c927a16f0c9..a966ff92c21dd9648a195b502961b3b43b01a7e6 100644
--- a/dumux/multidomain/facet/cellcentered/tpfa/couplingmapper.hh
+++ b/dumux/multidomain/facet/cellcentered/tpfa/couplingmapper.hh
@@ -62,18 +62,18 @@ public:
*
* \param bulkFvGridGeometry The finite-volume grid geometry of the bulk grid
* \param lowDimFvGridGeometry The finite-volume grid geometry of the lower-dimensional grid
- * \param gridManager Class that contains the embedments and allows obtaining entity insertion indices
+ * \param embeddings Class that contains the embedments among the grids and entity insertion indices
*/
- template< class GridManager >
+ template< class Embeddings >
void update(const BulkFVG& bulkFvGridGeometry,
const LowDimFVG& lowDimFvGridGeometry,
- const GridManager& gridManager)
+ std::shared_ptr<const Embeddings> embeddings)
{
- // define the execution policy how to add map entries from an embedment
- auto addEmbedmentPolicy = [&] (auto&& embedments,
- const LowDimElement& lowDimElement,
- const LowDimFVG& lowDimFvGridGeometry,
- const BulkFVG& bulkFvGridGeometry)
+ // define the policy how to add map entries for given lowdim element and adjoined entity indices
+ auto addCouplingEntryPolicy = [&] (auto&& adjoinedEntityIndices,
+ const LowDimElement& lowDimElement,
+ const LowDimFVG& lowDimFvGridGeometry,
+ const BulkFVG& bulkFvGridGeometry)
{
using LowDimIndexType = typename LowDimFVG::GridView::IndexSet::IndexType;
using BulkIndexType = typename BulkFVG::GridView::IndexSet::IndexType;
@@ -81,9 +81,9 @@ public:
const auto lowDimElemIdx = lowDimFvGridGeometry.elementMapper().index(lowDimElement);
auto& lowDimData = this->couplingMap_(facetGridId, bulkGridId)[lowDimElemIdx];
- // find the scvfs in the embedments coinciding with the low dim element
+ // find the scvfs in the adjoined entities coinciding with the low dim element
// since the bulk domain uses tpfa, there is always only going to be one scvf
- for (auto bulkElemIdx : embedments)
+ for (auto bulkElemIdx : adjoinedEntityIndices)
{
const auto bulkElement = bulkFvGridGeometry.element(bulkElemIdx);
@@ -98,7 +98,9 @@ public:
// of the outside scv indices is in the set of embedments
if (!scvf.boundary())
{
- if (std::find(embedments.begin(), embedments.end(), scvf.outsideScvIdx()) != embedments.end())
+ if ( std::find(adjoinedEntityIndices.begin(),
+ adjoinedEntityIndices.end(),
+ scvf.outsideScvIdx()) != adjoinedEntityIndices.end() )
{
embeddedScvfIdx = scvf.index();
found = true; break;
@@ -145,12 +147,12 @@ public:
lowDimData.embedments.emplace_back( bulkElemIdx, std::vector<BulkIndexType>({embeddedScvfIdx}) );
}
- // embedments = coupling stencil for tpfa
- lowDimData.couplingStencil = std::move(embedments);
+ // adjoint entity indices = coupling stencil for tpfa
+ lowDimData.couplingStencil = std::move(adjoinedEntityIndices);
};
// let the parent do the update subject to the execution policy defined above
- ParentType::update_(bulkFvGridGeometry, lowDimFvGridGeometry, gridManager, addEmbedmentPolicy);
+ ParentType::update_(bulkFvGridGeometry, lowDimFvGridGeometry, embeddings, addCouplingEntryPolicy);
// coupling stencils might not be unique if box is used in lowdim domain
if (LowDimFVG::discMethod == DiscretizationMethod::box)
diff --git a/dumux/multidomain/facet/codimonegridadapter.hh b/dumux/multidomain/facet/codimonegridadapter.hh
index ca2adfe28d4115ec8107967934c914ac1c0c68e3..d97456ee7c667aa30d1e928f91f692238a9dc06e 100644
--- a/dumux/multidomain/facet/codimonegridadapter.hh
+++ b/dumux/multidomain/facet/codimonegridadapter.hh
@@ -34,77 +34,73 @@ namespace Dumux {
/*!
* \ingroup MultiDomain
* \ingroup FacetCoupling
- * \brief Adapter to be plugged on top of a grid creator that allows for obtaining
- * information on a d-dimensional grid for entities of a (d-1)-dimensional
- * grid. This lower-dimensional grid is assumed to be facet-conforming to the
- * d-dimensional grid. This class can be used in the context of models where
- * a sub-domain lives on the facets of a bulk grid.
+ * \brief Adapter that allows retrieving information on a d-dimensional grid for
+ * entities of a (d-1)-dimensional grid. This lower-dimensional grid is
+ * assumed to be facet-conforming to the d-dimensional grid. This class
+ * can be used in the context of models where a sub-domain lives on the
+ * facets of a bulk grid.
*
- * \tparam GridManager A grid manager containing a hierarchy of facet-conforming grids.
+ * \tparam Embeddings Class containing the embedments of entites between grids of codim 1
* \tparam bulkGridId The grid id of the d-dimensional grid within the hierarchy
* \tparam facetGridId The grid id of the (d-1)-dimensional grid within the hierarchy
*/
-template<class GridManager, int bulkGridId = 0, int facetGridId = 1>
+template<class Embeddings, int bulkGridId = 0, int facetGridId = 1>
class CodimOneGridAdapter
{
// Extract some types of the facet-conforming grid of codimension one
- using FacetGrid = typename GridManager::template Grid<facetGridId>;
- using FacetGridView = typename FacetGrid::LeafGridView;
- using FacetGridVertex = typename FacetGridView::template Codim<FacetGrid::dimension>::Entity;
+ using FacetGridView = typename Embeddings::template GridView<facetGridId>;
+ using FacetGridVertex = typename FacetGridView::template Codim<FacetGridView::dimension>::Entity;
using FacetGridElement = typename FacetGridView::template Codim<0>::Entity;
using FacetGridIndexType = typename FacetGridView::IndexSet::IndexType;
// Extract some types of the bulk grid
- using BulkGrid = typename GridManager::template Grid<bulkGridId>;
- using BulkGridView = typename BulkGrid::LeafGridView;
+ using BulkGridView = typename Embeddings::template GridView<bulkGridId>;
using BulkMapper = Dune::MultipleCodimMultipleGeomTypeMapper<BulkGridView>;
- using BulkReferenceElements = typename Dune::ReferenceElements<typename BulkGridView::ctype, BulkGrid::dimension>;
+ using BulkReferenceElements = typename Dune::ReferenceElements<typename BulkGridView::ctype, BulkGridView::dimension>;
using BulkGridElement = typename BulkGridView::template Codim<0>::Entity;
using BulkGridIntersection = typename BulkGridView::Intersection;
- using BulkGridVertex = typename BulkGridView::template Codim<BulkGrid::dimension>::Entity;
+ using BulkGridVertex = typename BulkGridView::template Codim<BulkGridView::dimension>::Entity;
using BulkIndexType = typename BulkGridView::IndexSet::IndexType;
// Find out if the given bulk grid is the one with highest dimensionality among the created grids
- static constexpr bool bulkHasHighestDimension = (int(BulkGrid::dimension) == GridManager::bulkDim);
+ static constexpr bool bulkHasHighestDimension = (int(BulkGridView::dimension) == Embeddings::bulkDim);
// check if provided id combination makes sense
- static_assert( int(FacetGrid::dimension) == int(BulkGrid::dimension) - 1,
+ static_assert( int(FacetGridView::dimension) == int(BulkGridView::dimension) - 1,
"Grid dimension mismatch! Please check the provided domain ids!" );
- static_assert( int(FacetGrid::dimensionworld) == int(BulkGrid::dimensionworld),
+ static_assert( int(FacetGridView::dimensionworld) == int(BulkGridView::dimensionworld),
"Grid world dimension mismatch! All grids must have the same world dimension" );
public:
//! The constructor
- CodimOneGridAdapter(const GridManager& gridManager)
- : gridManagerPtr_(&gridManager)
- , bulkVertexMapper_(gridManager.template grid<bulkGridId>().leafGridView(), Dune::mcmgVertexLayout())
+ CodimOneGridAdapter(std::shared_ptr<const Embeddings> embeddings)
+ : embeddingsPtr_(embeddings)
+ , bulkVertexMapper_(embeddings->template gridView<bulkGridId>(), Dune::mcmgVertexLayout())
{
// bulk insertion to grid index map
- const auto& bulkGridView = gridManager.template grid<bulkGridId>().leafGridView();
- const auto& bulkGridFactory = gridManagerPtr_->template gridFactory<bulkGridId>();
- bulkInsertionToGridVIdx_.resize(bulkGridView.size(BulkGrid::dimension));
+ const auto& bulkGridView = embeddings->template gridView<bulkGridId>();
+ bulkInsertionToGridVIdx_.resize(bulkGridView.size(BulkGridView::dimension));
for (const auto& v : vertices(bulkGridView))
- bulkInsertionToGridVIdx_[ bulkGridFactory.insertionIndex(v) ] = bulkVertexMapper_.index(v);
+ bulkInsertionToGridVIdx_[embeddings->template insertionIndex<bulkGridId>(v)] = bulkVertexMapper_.index(v);
// maybe set up index map from hierachy insertion to bulk insertion indices
- makeBulkIndexMap_(gridManager);
+ makeBulkIndexMap_();
// determine which bulk vertices lie on facet elements
- bulkVertexIsOnFacetGrid_.resize(bulkGridView.size(BulkGrid::dimension), false);
- const auto& facetGridView = gridManager.template grid<facetGridId>().leafGridView();
- const auto& facetGridFactory = gridManager.template gridFactory<facetGridId>();
+ bulkVertexIsOnFacetGrid_.resize(bulkGridView.size(BulkGridView::dimension), false);
+ const auto& facetGridView = embeddings->template gridView<facetGridId>();
for (const auto& v : vertices(facetGridView))
{
- const auto insIdx = facetGridFactory.insertionIndex(v);
- const auto highestLevelInsIdx = gridManager.lowDimVertexIndices(facetGridId)[insIdx];
+ const auto insIdx = embeddings->template insertionIndex<facetGridId>(v);
+ const auto highestLevelInsIdx = embeddings->lowDimVertexIndices(facetGridId)[insIdx];
const auto bulkGridIdx = getBulkGridVertexIndex_(highestLevelInsIdx);
bulkVertexIsOnFacetGrid_[ bulkGridIdx ] = true;
}
// determine the bulk vertex indices that make up facet elements & connectivity
facetElementCorners_.resize(facetGridView.size(0));
- facetElementsAtBulkVertex_.resize(bulkGridView.size(BulkGrid::dimension));
+ facetElementsAtBulkVertex_.resize(bulkGridView.size(BulkGridView::dimension));
std::size_t facetElementCounter = 0;
for (const auto& element : elements(facetGridView))
@@ -112,10 +108,10 @@ public:
if (isEmbedded(element))
{
// obtain the bulk vertex indices of the corners of this element
- const auto numCorners = element.subEntities(FacetGrid::dimension);
+ const auto numCorners = element.subEntities(FacetGridView::dimension);
std::vector<BulkIndexType> cornerIndices(numCorners);
for (int i = 0; i < numCorners; ++i)
- cornerIndices[i] = bulkGridVertexIndex(element.template subEntity<FacetGrid::dimension>(i));
+ cornerIndices[i] = bulkGridVertexIndex(element.template subEntity<FacetGridView::dimension>(i));
// update connectivity map facetVertex -> facetElements
for (auto bulkVIdx : cornerIndices)
@@ -138,8 +134,8 @@ public:
*/
BulkIndexType bulkGridVertexIndex(const FacetGridVertex& v) const
{
- const auto insIdx = gridManagerPtr_->template gridFactory<facetGridId>().insertionIndex(v);
- const auto highestLevelInsIdx = gridManagerPtr_->lowDimVertexIndices(facetGridId)[insIdx];
+ const auto insIdx = embeddingsPtr_->template insertionIndex<facetGridId>(v);
+ const auto highestLevelInsIdx = embeddingsPtr_->lowDimVertexIndices(facetGridId)[insIdx];
return getBulkGridVertexIndex_(highestLevelInsIdx);
}
@@ -149,7 +145,7 @@ public:
*/
bool isOnFacetGrid(const BulkGridVertex& v) const
{
- const auto bulkInsIdx = gridManagerPtr_->template gridFactory<bulkGridId>().insertionIndex(v);
+ const auto bulkInsIdx = embeddingsPtr_->template insertionIndex<bulkGridId>(v);
const auto bulkVIdx = bulkInsertionToGridVIdx_[bulkInsIdx];
return bulkVertexIsOnFacetGrid_[bulkVIdx];
}
@@ -170,8 +166,8 @@ public:
std::vector<BulkIndexType> cornerIndices(numCorners);
for (int i = 0; i < numCorners; ++i)
cornerIndices[i] = bulkVertexMapper_.subIndex( element,
- refElement.subEntity(facetIdx, 1, i, BulkGrid::dimension),
- BulkGrid::dimension );
+ refElement.subEntity(facetIdx, 1, i, BulkGridView::dimension),
+ BulkGridView::dimension );
return composeFacetElement(cornerIndices);
}
@@ -230,29 +226,29 @@ public:
* given (d-1)-dimensional element is embedded in
*/
std::size_t numEmbedments(const FacetGridElement& e) const
- { return gridManagerPtr_->template embedmentEntityIndices<facetGridId>(e).size(); }
+ { return embeddingsPtr_->template adjoinedEntityIndices<facetGridId>(e).size(); }
private:
//! Determine map from the insertion idx of the highest-dimensional grid to bulk insertion idx
template< bool isHighest = bulkHasHighestDimension, std::enable_if_t<!isHighest, int> = 0 >
- void makeBulkIndexMap_(const GridManager& gridManager)
+ void makeBulkIndexMap_()
{
// obtain highest-dimensional grid using the bulkId from grid creator
- const auto& highestLevelGridView = gridManager.template grid<GridManager::bulkGridId>().leafGridView();
- highestLevelInsertionToBulkInsertionIdx_.resize(highestLevelGridView.size(GridManager::bulkDim));
+ const auto& highestLevelGridView = embeddingsPtr_->template gridView<Embeddings::bulkGridId>();
+ highestLevelInsertionToBulkInsertionIdx_.resize(highestLevelGridView.size(Embeddings::bulkDim));
// indices in grid creator stem from the grid file, which has one set of vertices
// for the entire hierarchy. Thus, the vertex indices we obtain from the grid creator
// that make up this bulk grid (lower-dimensional within the hierarchy), correspond to
// the highest-dimensional grid's insertion indices.
- const auto& vertexInsIndices = gridManager.lowDimVertexIndices(bulkGridId);
+ const auto& vertexInsIndices = embeddingsPtr_->lowDimVertexIndices(bulkGridId);
for (std::size_t insIdx = 0; insIdx < vertexInsIndices.size(); ++insIdx)
highestLevelInsertionToBulkInsertionIdx_[ vertexInsIndices[insIdx] ] = insIdx;
}
//! If the given bulk grid is on the highest level of grid creation, we do not need the map
template< bool isHighest = bulkHasHighestDimension, std::enable_if_t<isHighest, int> = 0 >
- void makeBulkIndexMap_(const GridManager& gridManager)
+ void makeBulkIndexMap_()
{}
//! Obtains the bulk grid vertex index from a given insertion index on the hierarchy
@@ -263,8 +259,8 @@ private:
: bulkInsertionToGridVIdx_[ highestLevelInsertionToBulkInsertionIdx_[ highestLevelInsertionIdx] ];
}
- // pointer to the grid creator
- const GridManager* gridManagerPtr_;
+ // shared pointer to the embedment data
+ std::shared_ptr<const Embeddings> embeddingsPtr_;
// vertex mapper of the bulk grid
BulkMapper bulkVertexMapper_;
diff --git a/dumux/multidomain/facet/couplingmapper.hh b/dumux/multidomain/facet/couplingmapper.hh
index 2adb20b983e41e43663ea79b7bd605bad9e7656d..3c8433b05c0ff5635a3a25db11cc2d75371d214e 100644
--- a/dumux/multidomain/facet/couplingmapper.hh
+++ b/dumux/multidomain/facet/couplingmapper.hh
@@ -113,16 +113,16 @@ public:
* \param bulkFvGridGeometry The finite-volume grid geometry of the bulk grid
* \param facetFvGridGeometry The finite-volume grid geometry of the codimension-one grid
* \param edgeFvGridGeometry The finite-volume grid geometry of the codimension-two grid
- * \param gridManager Class that contains the embedments and allows obtaining entity insertion indices
+ * \param embeddings Class that contains the embedments among the grids and entity insertion indices
*/
- template< class GridManager >
+ template< class Embeddings >
void update(const BulkFVG& bulkFvGridGeometry,
const FacetFVG& facetFvGridGeometry,
const EdgeFVG& edgeFvGridGeometry,
- const GridManager& gridManager)
+ std::shared_ptr<const Embeddings> embeddings)
{
- BulkFacetMapper::update(bulkFvGridGeometry, facetFvGridGeometry, gridManager);
- FacetEdgeMapper::update(facetFvGridGeometry, edgeFvGridGeometry, gridManager);
+ BulkFacetMapper::update(bulkFvGridGeometry, facetFvGridGeometry, embeddings);
+ FacetEdgeMapper::update(facetFvGridGeometry, edgeFvGridGeometry, embeddings);
}
//! Pull up the parents' access operators to allow for individual updates
diff --git a/dumux/multidomain/facet/couplingmapperbase.hh b/dumux/multidomain/facet/couplingmapperbase.hh
index f86b8c4006e79867020d65b867e5774111386c94..1594ba782d771557362c65175482f9d4b075c1dc 100644
--- a/dumux/multidomain/facet/couplingmapperbase.hh
+++ b/dumux/multidomain/facet/couplingmapperbase.hh
@@ -64,11 +64,11 @@ class FacetCouplingMapperBase
static constexpr auto bulkDiscMethod = BulkFVG::discMethod;
// helper struct to check validity of the given domain id offset
- template< class GridManager >
- class IsValidGridManager
+ template< class Embeddings >
+ class IsValidDomainId
{
- using GCBulkGridView = typename GridManager::template Grid<bulkId>::LeafGridView;
- using GCLowDimGridView = typename GridManager::template Grid<lowDimId>::LeafGridView;
+ using GCBulkGridView = typename Embeddings::template GridView<bulkId>;
+ using GCLowDimGridView = typename Embeddings::template GridView<lowDimId>;
static constexpr bool bulkMatch = std::is_same<GCBulkGridView, BulkGridView>::value;
static constexpr bool lowDimMatch = std::is_same<GCLowDimGridView, LowDimGridView>::value;
static_assert(bulkMatch, "The bulk domain id does not match the provided bulk grid geometry");
@@ -145,10 +145,10 @@ public:
* \brief Update coupling maps. This is the standard interface
* and has to be overloaded by the implementation.
*/
- template< class GridManager >
+ template< class Embeddings >
void update(const BulkFVG& bulkFvGridGeometry,
const LowDimFVG& lowDimFvGridGeometry,
- const GridManager& gridManager)
+ std::shared_ptr<const Embeddings> embeddings)
{ DUNE_THROW(Dune::NotImplemented, "Implementation does not provide an update() function."); }
//! returns coupling data for bulk -> lowDim
@@ -166,40 +166,40 @@ protected:
*
* \param bulkFvGridGeometry The finite-volume grid geometry of the bulk grid
* \param lowDimFvGridGeometry The finite-volume grid geometry of the lower-dimensional grid
- * \param gridManager Class that contains the embedments and allows obtaining entity insertion indices
- * \param EmbedmentExecutionPolicy Policy for adding coupling entries for embedments
+ * \param embeddings Class that contains the embedments and allows obtaining entity insertion indices
+ * \param AddCouplingEntryPolicy Policy for adding coupling entries starting from a lower-dimensional
+ * element and corresponding adjoined higher-dimensional entity indices
*/
- template< class GridManager, typename EmbedmentExecutionPolicy >
+ template< class Embeddings, typename AddCouplingEntryPolicy >
void update_(const BulkFVG& bulkFvGridGeometry,
const LowDimFVG& lowDimFvGridGeometry,
- const GridManager& gridManager,
- EmbedmentExecutionPolicy&& embedmentPolicy)
+ std::shared_ptr<const Embeddings> embeddings,
+ AddCouplingEntryPolicy&& addCouplingEntryPolicy)
{
// some static assertions on the grid creator
- static_assert(IsValidGridManager< GridManager >::value, "Grid type mismatch. Please review the provided domain id offset.");
+ static_assert(IsValidDomainId<Embeddings>::value, "Grid type mismatch. Please review the provided domain id offset.");
// clear data
bulkCouplingData_.clear();
lowDimCouplingData_.clear();
// set up maps between element indices and insertion indices
- const auto& bulkGridFactory = gridManager.template gridFactory<bulkId>();
- const auto bulkInsertionToElemIdxMap = makeInsertionToGridIndexMap_(bulkGridFactory, bulkFvGridGeometry);
+ const auto bulkInsertionToElemIdxMap = makeInsertionToGridIndexMap_(embeddings, bulkFvGridGeometry);
// set up coupling maps coming from the low dim domain
for (const auto& element : elements(lowDimFvGridGeometry.gridView()))
{
- auto embedments = gridManager.template embedmentEntityIndices<lowDimId>(element);
+ auto adjoinedEntities = embeddings->template adjoinedEntityIndices<lowDimId>(element);
- // proceed only if embedments were found
- if (embedments.size() == 0)
+ // proceed only if element is embedded
+ if (adjoinedEntities.size() == 0)
continue;
- // turn embedments into actual grid element indices ...
- std::for_each(embedments.begin(), embedments.end(), [&] (auto& idx) { idx = bulkInsertionToElemIdxMap[idx]; });
+ // turn (insertion) indices into actual grid element indices ...
+ std::for_each(adjoinedEntities.begin(), adjoinedEntities.end(), [&] (auto& idx) { idx = bulkInsertionToElemIdxMap[idx]; });
// ... and add them
- embedmentPolicy(std::move(embedments), element, lowDimFvGridGeometry, bulkFvGridGeometry);
+ addCouplingEntryPolicy(std::move(adjoinedEntities), element, lowDimFvGridGeometry, bulkFvGridGeometry);
}
}
@@ -231,15 +231,15 @@ protected:
private:
//! Creates the map from element insertion index to grid element index
- template< class GridFactory, class FVGridGeometry>
+ template< class Embeddings, class FVGridGeometry>
std::vector< typename FVGridGeometry::GridView::IndexSet::IndexType >
- makeInsertionToGridIndexMap_(const GridFactory& gridFactory, const FVGridGeometry& fvGridGeometry) const
+ makeInsertionToGridIndexMap_(std::shared_ptr<const Embeddings> embeddings, const FVGridGeometry& fvGridGeometry) const
{
using IndexType = typename FVGridGeometry::GridView::IndexSet::IndexType;
std::vector< IndexType > map(fvGridGeometry.gridView().size(0));
for (const auto& e : elements(fvGridGeometry.gridView()))
- map[ gridFactory.insertionIndex(e) ] = fvGridGeometry.elementMapper().index(e);
+ map[ embeddings->template insertionIndex<bulkId>(e) ] = fvGridGeometry.elementMapper().index(e);
return map;
}
diff --git a/dumux/multidomain/facet/gmshreader.hh b/dumux/multidomain/facet/gmshreader.hh
index 72c46b0b83b3b442ef10fc08637596d6f068a402..a2f3b4069c88b494e3f13e3c1a481d179e3cf9f0 100644
--- a/dumux/multidomain/facet/gmshreader.hh
+++ b/dumux/multidomain/facet/gmshreader.hh
@@ -53,16 +53,16 @@ namespace Dumux {
* indexing in your grid file in that case.
*
* \tparam BulkGrid The type of the highest-dimensional grid in the hierachy
- * \tparam IndexType The index type to be used
* \tparam numGrids The number of grids to be considered in the hierarchy
*/
-template <class BulkGrid, class IndexType, int numGrids>
+template <class BulkGrid, int numGrids>
class FacetCouplingGmshReader
{
// extract some necessary info from bulk grid
static constexpr int bulkDim = BulkGrid::dimension;
static constexpr int bulkDimWorld = BulkGrid::dimensionworld;
using ctype = typename BulkGrid::ctype;
+ using IndexType = typename BulkGrid::LeafGridView::IndexSet::IndexType;
using GlobalPosition = Dune::FieldVector<ctype, bulkDimWorld>;
// determine minimum dimension for which a grid is created
@@ -322,10 +322,10 @@ public:
}
//! Returns the maps of the embedments
- std::unordered_map< IndexType, std::vector<IndexType> >& embedmentMap(std::size_t id)
+ std::unordered_map< IndexType, std::vector<IndexType> >& adjoinedEntityMap(std::size_t id)
{
assert(id < numGrids && "Index exceeds number of grids provided");
- return embedmentMaps_[id];
+ return adjoinedEntityMaps_[id];
}
private:
@@ -398,7 +398,7 @@ private:
if ( std::all_of(e.cornerIndices.begin(), e.cornerIndices.end(), vertIsContained) )
{
embeddedEntityMaps_[gridIdx][curElemIdx].push_back(i);
- embedmentMaps_[embeddedGridIdx][i].push_back(curElemIdx);
+ adjoinedEntityMaps_[embeddedGridIdx][i].push_back(curElemIdx);
}
}
@@ -415,7 +415,7 @@ private:
//! data on connectivity between the grids
std::array< std::unordered_map< IndexType, std::vector<IndexType> >, numGrids > embeddedEntityMaps_;
- std::array< std::unordered_map< IndexType, std::vector<IndexType> >, numGrids > embedmentMaps_;
+ std::array< std::unordered_map< IndexType, std::vector<IndexType> >, numGrids > adjoinedEntityMaps_;
//! data on domain and boundary markers
std::array< std::vector<int>, numGrids > elementMarkerMaps_;
diff --git a/dumux/multidomain/facet/gridmanager.hh b/dumux/multidomain/facet/gridmanager.hh
index 5ecbabdfccfe0be76ab12786bf3f6d556097ffb3..8d5c39a8fc60bc58bd183f4d3ce75e30b1109f32 100644
--- a/dumux/multidomain/facet/gridmanager.hh
+++ b/dumux/multidomain/facet/gridmanager.hh
@@ -16,8 +16,8 @@
*****************************************************************************/
/*!
* \file
- * \ingroup MixedDimension
- * \ingroup MixedDimensionFacet
+ * \ingroup MultiDomain
+ * \ingroup FacetCoupling
* \brief Contains the grid manager class that creates the grids in the context
* of hybrid-dimensional coupled models, where the (n-1)-dimensional
* domains live on the element facets of the n-dimensional domains.
@@ -73,8 +73,8 @@ namespace Detail {
}
/*!
- * \ingroup MixedDimension
- * \ingroup MixedDimensionFacet
+ * \ingroup MultiDomain
+ * \ingroup FacetCoupling
* \brief Grid data object to store element and boundary segment markers
* for all grids of the hierarchy.
*
@@ -135,33 +135,38 @@ private:
};
/*!
- * \ingroup MixedDimension
- * \ingroup MixedDimensionFacet
- * \brief Creates the grids in the context of hybrid-dimensional coupled models,
- * where the (n-1)-dimensional domains live on the element facets of the
- * n-dimensional domains.
+ * \ingroup MultiDomain
+ * \ingroup FacetCoupling
+ * \brief Contains the embeddings between grids with codimension one
+ * among the grid hierarchy. All these embedments are given in
+ * insertion indices as they are read directly from the grid.
+ * Therefore, this class furthermore allows access to the insertion
+ * indices of entities. Additionally, it gives access to the grid
+ * views of the different grids on the hierarchy.
*
* \tparam Grids the types of the grid hierarchy
* \note Grids must be ordered in descending grid dimension
*/
template<typename... Grids>
-class FacetCouplingGridManager
+class FacetCouplingEmbeddings
{
// make sure all grids have the same world dimension and are ordered in descending dimension
static_assert(Detail::FulfillConditions<false, Grids...>::value, "All grids must have the same world dimension!");
static_assert(Detail::FulfillConditions<true, Grids...>::value, "Grids must be ordered w.r.t the dimension in descending order!");
- // we use a wrapper class for the grid data containing the data on all grids
- using GridDataWrapper = FacetCouplingGridDataWrapper<Grids...>;
-public:
- //! export the i-th grid type
+ //! the i-th grid type
template<std::size_t id> using Grid = typename std::tuple_element_t<id, std::tuple<Grids...>>;
- //! export the i-th grid pointer type
- template<std::size_t id> using GridPtr = typename std::shared_ptr< Grid<id> >;
- //! export the i-th Dune::GridFactory type
- template<std::size_t id> using GridFactory = Dune::GridFactory< Grid<id> >;
- //! export the i-th Dune::GridFactory type
- template<std::size_t id> using GridFactoryPtr = std::shared_ptr< Dune::GridFactory<Grid<id>> >;
+ //! the i-th grid factory type
+ template<std::size_t id> using GridFactory = typename Dune::GridFactory<Grid<id>>;
+
+ //! we use the bulk grid's index type here
+ using IT = typename Grid<0>::LeafGridView::IndexSet::IndexType;
+ //! the map type to store embedment data
+ using EmbedmentMap = std::unordered_map<IT, std::vector<IT>>;
+
+public:
+ //! export the i-th grid view type
+ template<std::size_t id> using GridView = typename Grid<id>::LeafGridView;
//! export the number of created grids
static constexpr std::size_t numGrids = sizeof...(Grids);
@@ -171,29 +176,19 @@ public:
static constexpr int bulkDim = Grid<bulkGridId>::dimension;
//! export the bulk grid type
- using BulkGrid = Grid<bulkGridId>;
- //! we use the bulk grid's index type during read etc.
- using IndexType = typename BulkGrid::LeafGridView::IndexSet::IndexType;
- //! export the grid data (wrapper) type, i.e. parameters/markers
- using GridData = GridDataWrapper;
+ using BulkGridView = GridView<bulkGridId>;
+ //! export the type used for indices
+ using IndexType = IT;
- //! returns the i-th grid
+ //! return reference to the i-th grid view
template<std::size_t id>
- const Grid<id>& grid() const
- { return *std::get<id>(gridPtrTuple_); }
+ const GridView<id>& gridView() const
+ { return *std::get<id>(gridViewPtrTuple_); }
- //! returns the i-th grid factory
- template<std::size_t id>
- const GridFactory<id>& gridFactory() const
- { return *std::get<id>(gridFactoryPtrTuple_); }
-
- //! return a pointer to the grid data object
- std::shared_ptr<const GridData> getGridData() const
- {
- if (!enableEntityMarkers_)
- DUNE_THROW(Dune::IOError, "No grid data available");
- return gridDataPtr_;
- }
+ //! return the insertion index of an entity of the i-th grid
+ template<std::size_t id, class Entity>
+ IndexType insertionIndex(const Entity& entity) const
+ { return std::get<id>(gridFactoryPtrTuple_)->insertionIndex(entity); }
//! Returns the insertion indices of the entities embedded in given element
template<std::size_t id>
@@ -201,7 +196,7 @@ public:
embeddedEntityIndices(const typename Grid<id>::template Codim<0>::Entity& element) const
{
const auto& map = embeddedEntityMaps_[id];
- auto it = map.find( gridFactory<id>().insertionIndex(element) );
+ auto it = map.find( std::get<id>(gridFactoryPtrTuple_)->insertionIndex(element) );
if (it != map.end()) return it->second;
else return typename std::unordered_map< IndexType, std::vector<IndexType> >::mapped_type();
}
@@ -209,10 +204,10 @@ public:
//! Returns the insertion indices of the entities in which the element is embedded
template<std::size_t id>
typename std::unordered_map< IndexType, std::vector<IndexType> >::mapped_type
- embedmentEntityIndices(const typename Grid<id>::template Codim<0>::Entity& element) const
+ adjoinedEntityIndices(const typename Grid<id>::template Codim<0>::Entity& element) const
{
- const auto& map = embedmentMaps_[id];
- auto it = map.find( gridFactory<id>().insertionIndex(element) );
+ const auto& map = adjoinedEntityMaps_[id];
+ auto it = map.find( std::get<id>(gridFactoryPtrTuple_)->insertionIndex(element) );
if (it != map.end()) return it->second;
else return typename std::unordered_map< IndexType, std::vector<IndexType> >::mapped_type();
}
@@ -221,25 +216,116 @@ public:
const std::unordered_map< IndexType, std::vector<IndexType> >& embeddedEntityMap(std::size_t id) const
{ assert(id < numGrids); return embeddedEntityMaps_[id]; }
- std::unordered_map< IndexType, std::vector<IndexType> >& embeddedEntityMap(std::size_t id)
- { assert(id < numGrids); return embeddedEntityMaps_[id]; }
-
- //! Returns the maps of the embedments
- const std::unordered_map< IndexType, std::vector<IndexType> >& embedmentMap(std::size_t id) const
- { assert(id < numGrids); return embedmentMaps_[id]; }
-
- std::unordered_map< IndexType, std::vector<IndexType> >& embedmentMap(std::size_t id)
- { assert(id < numGrids); return embedmentMaps_[id]; }
+ //! Returns the maps of the adjoined entities of dimension d+1
+ const std::unordered_map< IndexType, std::vector<IndexType> >& adjoinedEntityMap(std::size_t id) const
+ { assert(id < numGrids); return adjoinedEntityMaps_[id]; }
//! Returns the hierachy's insertion indices that make up the grid for the given id
const std::vector<IndexType>& lowDimVertexIndices(std::size_t id) const
{ assert(id > 0 && id < numGrids); return lowDimGridVertexIndices_[id-1]; }
+ /*!
+ * \brief Sets the required data for a specific grid on the hierarchy.
+ * \param gridPtr shared pointer to this (id-th) grid
+ * \param gridFactoryPtr shared pointer to this (id-th) grid factory
+ * \param embeddedEntityMap map containing the lower-dimensional entities for this grid's elements
+ * \param adjoinedEntityMap map containing the (d+1)-dimensional elements in which this grid's elements are embedded in
+ * \param lowDimGridVertexIndices the hierachy's insertion indices that make up this grid
+ * (only necessary for lower-dimensional grids)
+ */
+ template<std::size_t id>
+ void setData( std::shared_ptr<Grid<id>> gridPtr,
+ std::shared_ptr<GridFactory<id>> gridFactoryPtr,
+ EmbedmentMap&& embeddedEntityMap,
+ EmbedmentMap&& adjoinedEntityMap,
+ std::vector<IndexType>&& lowDimGridVertexIndices = std::vector<IndexType>() )
+ {
+ std::get<id>(gridViewPtrTuple_) = std::make_shared<GridView<id>>(gridPtr->leafGridView());
+ std::get<id>(gridFactoryPtrTuple_) = gridFactoryPtr;
+ embeddedEntityMaps_[id] = std::move(embeddedEntityMap);
+ adjoinedEntityMaps_[id] = std::move(adjoinedEntityMap);
+
+ if (id > bulkGridId)
+ lowDimGridVertexIndices_[id-1] = std::move(lowDimGridVertexIndices);
+ }
+private:
+ //! data on connectivity between the grids
+ std::array<EmbedmentMap, numGrids> embeddedEntityMaps_;
+ std::array<EmbedmentMap, numGrids> adjoinedEntityMaps_;
+
+ //! Contains the hierarchy insertion indices that make up a lower-dimensional grid
+ std::array<std::vector<IndexType>, numGrids-1> lowDimGridVertexIndices_;
+
+ //! tuple to store the grids
+ using Indices = std::make_index_sequence<numGrids>;
+ template<std::size_t id> using GridViewPtr = std::shared_ptr<GridView<id>>;
+ using GridPtrTuple = typename makeFromIndexedType<std::tuple, GridViewPtr, Indices>::type;
+ GridPtrTuple gridViewPtrTuple_;
+
+ //! tuple to store the grid grid factories
+ template<std::size_t id> using GridFactoryPtr = std::shared_ptr< Dune::GridFactory<Grid<id>> >;
+ using GridFactoryPtrTuple = typename makeFromIndexedType<std::tuple, GridFactoryPtr, Indices>::type;
+ GridFactoryPtrTuple gridFactoryPtrTuple_;
+};
+
+/*!
+ * \ingroup MultiDomain
+ * \ingroup FacetCoupling
+ * \brief Creates the grids in the context of hybrid-dimensional coupled models,
+ * where the (n-1)-dimensional domains live on the element facets of the
+ * n-dimensional domains.
+ *
+ * \tparam Grids the types of the grid hierarchy
+ * \note Grids must be ordered in descending grid dimension
+ */
+template<typename... Grids>
+class FacetCouplingGridManager
+{
+ // make sure all grids have the same world dimension and are ordered in descending dimension
+ static_assert(Detail::FulfillConditions<false, Grids...>::value, "All grids must have the same world dimension!");
+ static_assert(Detail::FulfillConditions<true, Grids...>::value, "Grids must be ordered w.r.t the dimension in descending order!");
+
+ // we use a wrapper class for the grid data containing the data on all grids
+ using GridDataWrapper = FacetCouplingGridDataWrapper<Grids...>;
+public:
+ //! export the i-th grid type
+ template<std::size_t id> using Grid = typename std::tuple_element_t<id, std::tuple<Grids...>>;
+ //! export the i-th grid pointer type
+ template<std::size_t id> using GridPtr = typename std::shared_ptr< Grid<id> >;
+
+ //! export the number of created grids
+ static constexpr std::size_t numGrids = sizeof...(Grids);
+ //! export the grid id of the bulk grid (descending grid dim -> always zero!)
+ static constexpr int bulkGridId = 0;
+
+ //! export the grid data (wrapper) type, i.e. parameters/markers
+ using GridData = GridDataWrapper;
+ //! export the type storing the embeddings
+ using Embeddings = FacetCouplingEmbeddings<Grids...>;
+
+ //! returns the i-th grid
+ template<std::size_t id>
+ const Grid<id>& grid() const
+ { return *std::get<id>(gridPtrTuple_); }
+
+ //! return a pointer to the grid data object
+ std::shared_ptr<const GridData> getGridData() const
+ {
+ if (!enableEntityMarkers_)
+ DUNE_THROW(Dune::IOError, "No grid data available");
+ return gridDataPtr_;
+ }
+
+ //! return a pointer to the object containing embeddings
+ std::shared_ptr<const Embeddings> getEmbeddings() const
+ { return embeddingsPtr_; }
+
//! creates the grids from a file given in parameter tree
void init(const std::string& paramGroup = "")
{
- // reset the grid data
+ // reset the grid & embedding data
gridDataPtr_ = std::make_shared<GridData>();
+ embeddingsPtr_ = std::make_shared<Embeddings>();
// get filename and determine grid file extension
const auto fileName = getParamFromGroup<std::string>(paramGroup, "Grid.File");
@@ -254,7 +340,7 @@ public:
if (ext == "msh")
{
const auto thresh = getParamFromGroup<std::size_t>(paramGroup, "Grid.GmshPhysicalEntityThreshold", 0);
- FacetCouplingGmshReader<BulkGrid, IndexType, numGrids> gmshReader;
+ FacetCouplingGmshReader<Grid<bulkGridId>, numGrids> gmshReader;
gmshReader.read(fileName, (boundarySegments ? thresh : 0), verbose);
passDataFromReader(gmshReader, domainMarkers, boundarySegments);
}
@@ -294,19 +380,16 @@ private:
using namespace Dune::Hybrid;
forEach(integralRange(Dune::Hybrid::size(gridPtrTuple_)), [&](const auto id)
{
- auto factoryPtr = std::make_shared<GridFactory<id>>();
- std::get<id>(this->gridFactoryPtrTuple_) = factoryPtr;
+ using GridFactory = Dune::GridFactory<Grid<id>>;
+ auto factoryPtr = std::make_shared<GridFactory>();
// insert grid vertices
if (id == 0)
for (const auto& v : bulkGridVertices)
factoryPtr->insertVertex(v);
else
- {
for (const auto idx : reader.lowDimVertexIndices(id))
factoryPtr->insertVertex(bulkGridVertices[idx]);
- std::swap(lowDimGridVertexIndices_[id-1], reader.lowDimVertexIndices(id));
- }
// insert elements
for (const auto& e : reader.elementData(id))
@@ -318,43 +401,47 @@ private:
factoryPtr->insertBoundarySegment(segment);
// make grid
- std::get<id>(gridPtrTuple_) = std::shared_ptr<Grid<id>>(factoryPtr->createGrid());
+ auto gridPtr = std::shared_ptr<Grid<id>>(factoryPtr->createGrid());
// maybe create and set grid data object
if (domainMarkers || boundarySegments)
{
- typename GridDataWrapper::template GridData<id> gridData( std::get<id>(gridPtrTuple_),
+ typename GridDataWrapper::template GridData<id> gridData( gridPtr,
factoryPtr,
std::move(reader.elementMarkerMap(id)),
std::move(reader.boundaryMarkerMap(id)) );
gridDataPtr_->template setGridData<id>( std::move(gridData) );
}
- // copy the embedments
- std::swap(embeddedEntityMaps_[id], reader.embeddedEntityMap(id));
- std::swap(embedmentMaps_[id], reader.embedmentMap(id));
+ // copy the embeddings
+ if (id == 0)
+ embeddingsPtr_->template setData<id>( gridPtr,
+ factoryPtr,
+ std::move(reader.embeddedEntityMap(id)),
+ std::move(reader.adjoinedEntityMap(id)) );
+ else
+ embeddingsPtr_->template setData<id>( gridPtr,
+ factoryPtr,
+ std::move(reader.embeddedEntityMap(id)),
+ std::move(reader.adjoinedEntityMap(id)),
+ std::move( reader.lowDimVertexIndices(id)) );
+
+ // set the grid pointer
+ std::get<id>(gridPtrTuple_) = gridPtr;
});
}
- using Indices = std::make_index_sequence<numGrids>;
//! tuple to store the grids
+ using Indices = std::make_index_sequence<numGrids>;
using GridPtrTuple = typename makeFromIndexedType<std::tuple, GridPtr, Indices>::type;
GridPtrTuple gridPtrTuple_;
- //! tuple to store the grid grid factories
- using GridFactoryPtrTuple = typename makeFromIndexedType<std::tuple, GridFactoryPtr, Indices>::type;
- GridFactoryPtrTuple gridFactoryPtrTuple_;
-
- //! data on connectivity between the grids
- std::array< std::unordered_map< IndexType, std::vector<IndexType> >, numGrids > embeddedEntityMaps_;
- std::array< std::unordered_map< IndexType, std::vector<IndexType> >, numGrids > embedmentMaps_;
-
- //! maps a low-dim vertex insertion index to the bulk grid vertex insertion index
- std::array< std::vector<IndexType>, numGrids-1 > lowDimGridVertexIndices_;
-
//! grid data, i.e. parameters and markers
bool enableEntityMarkers_;
std::shared_ptr<GridData> gridDataPtr_;
+
+ //! data on embeddings
+ std::shared_ptr<Embeddings> embeddingsPtr_;
};
} // end namespace Dumux
diff --git a/test/multidomain/facet/1p_1p/analytical/test_facetcoupling_fv_1p1p.cc b/test/multidomain/facet/1p_1p/analytical/test_facetcoupling_fv_1p1p.cc
index 5872642f33958a2e6f9a557e2c02ce73aa4812ba..f8d4303290dd2e6ec716b8698c72661ac21a3071 100644
--- a/test/multidomain/facet/1p_1p/analytical/test_facetcoupling_fv_1p1p.cc
+++ b/test/multidomain/facet/1p_1p/analytical/test_facetcoupling_fv_1p1p.cc
@@ -122,10 +122,8 @@ computeL2Norm(const GridView& gridView,
// make discrete element solution
const auto elemSol = elementSolution(element, x, problem.fvGridGeometry());
- // the element geometry
- const auto eg = element.geometry();
-
// integrate the pressure error over the element
+ const auto eg = element.geometry();
const auto& rule = Dune::QuadratureRules<Scalar, GridView::dimension>::rule(eg.type(), order);
for (auto&& qp : rule)
{
@@ -164,7 +162,8 @@ void updateBulkFVGridGeometry(FVGridGeometry& fvGridGeometry,
const GridManager& gridManager,
const LowDimGridView& lowDimGridView)
{
- Dumux::CodimOneGridAdapter<GridManager> facetGridAdapter(gridManager);
+ using BulkFacetGridAdapter = Dumux::CodimOneGridAdapter<typename GridManager::Embeddings>;
+ BulkFacetGridAdapter facetGridAdapter(gridManager.getEmbeddings());
fvGridGeometry.update(lowDimGridView, facetGridAdapter);
}
@@ -250,7 +249,7 @@ int main(int argc, char** argv) try
// the coupling mapper
auto couplingMapper = std::make_shared<typename TestTraits::CouplingMapper>();
- couplingMapper->update(*bulkFvGridGeometry, *lowDimFvGridGeometry, gridManager);
+ couplingMapper->update(*bulkFvGridGeometry, *lowDimFvGridGeometry, gridManager.getEmbeddings());
// the coupling manager
using CouplingManager = typename TestTraits::CouplingManager;
diff --git a/test/multidomain/facet/1p_1p/threedomain/CMakeLists.txt b/test/multidomain/facet/1p_1p/threedomain/CMakeLists.txt
index 296ca6f22dfc9a503a073542715069f1e9cbb8a4..61977afb95649315c3a492decfe6f39da9f4c11f 100644
--- a/test/multidomain/facet/1p_1p/threedomain/CMakeLists.txt
+++ b/test/multidomain/facet/1p_1p/threedomain/CMakeLists.txt
@@ -1,9 +1,8 @@
-dune_symlink_to_source_files(FILES "grids" "test_facetcoupling_1p1p_threedomain.input")
+dune_symlink_to_source_files(FILES "grids" "facetcoupling_1p1p_threedomain.input")
dune_add_test(NAME test_facetcoupling_tpfa_1p1p_threedomain
SOURCES test_facetcoupling_tpfa_1p1p_threedomain.cc
- CMAKE_GUARD dune-foamgrid_FOUND
- CMAKE_GUARD dune-alugrid_FOUND
+ CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )"
COMPILE_DEFINITIONS BULKTYPETAG=TissueCCTypeTag LOWDIMTYPETAG=BloodFlowCCTypeTag COUPLINGMODE=EmbeddedCouplingMode::average
COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
CMD_ARGS --script fuzzy
@@ -13,7 +12,7 @@ dune_add_test(NAME test_facetcoupling_tpfa_1p1p_threedomain
${CMAKE_CURRENT_BINARY_DIR}/test_1p_1p_facet-00001.vtu
${CMAKE_SOURCE_DIR}/test/references/facetcoupling_1p1p_threedomain_edge.vtp
${CMAKE_CURRENT_BINARY_DIR}/test_1p_1p_edge-00001.vtp
- --command "${CMAKE_CURRENT_BINARY_DIR}/test_facetcoupling_tpfa_1p1p_threedomain test_facetcoupling_1p1p_threedomain.input")
+ --command "${CMAKE_CURRENT_BINARY_DIR}/test_facetcoupling_tpfa_1p1p_threedomain facetcoupling_1p1p_threedomain.input")
set(CMAKE_BUILD_TYPE Release)
diff --git a/test/multidomain/facet/1p_1p/threedomain/test_facetcoupling_1p1p_threedomain.input b/test/multidomain/facet/1p_1p/threedomain/facetcoupling_1p1p_threedomain.input
similarity index 100%
rename from test/multidomain/facet/1p_1p/threedomain/test_facetcoupling_1p1p_threedomain.input
rename to test/multidomain/facet/1p_1p/threedomain/facetcoupling_1p1p_threedomain.input
diff --git a/test/multidomain/facet/1p_1p/threedomain/test_facetcoupling_tpfa_1p1p_threedomain.cc b/test/multidomain/facet/1p_1p/threedomain/test_facetcoupling_tpfa_1p1p_threedomain.cc
index 15b507fcbac4c4083df461317e110fad17301e6b..b5ba775d1943e457398b85bf4fd435c49ace20f5 100644
--- a/test/multidomain/facet/1p_1p/threedomain/test_facetcoupling_tpfa_1p1p_threedomain.cc
+++ b/test/multidomain/facet/1p_1p/threedomain/test_facetcoupling_tpfa_1p1p_threedomain.cc
@@ -90,9 +90,7 @@ int main(int argc, char** argv) try
// initialize parameter tree
Parameters::init(argc, argv);
- //////////////////////////////////////////////////////////////////////
// try to create a grid (from the given grid file or the input file)
- /////////////////////////////////////////////////////////////////////
using BulkProblemTypeTag = TTAG(OnePBulkTpfa);
using FacetProblemTypeTag = TTAG(OnePFacetTpfa);
using EdgeProblemTypeTag = TTAG(OnePEdgeTpfa);
@@ -154,7 +152,7 @@ int main(int argc, char** argv) try
// the coupling mapper
using CouplingMapper = typename TestTraits::CouplingMapper;
auto couplingMapper = std::make_shared<CouplingMapper>();
- couplingMapper->update(*bulkFvGridGeometry, *facetFvGridGeometry, *edgeFvGridGeometry, gridManager);
+ couplingMapper->update(*bulkFvGridGeometry, *facetFvGridGeometry, *edgeFvGridGeometry, gridManager.getEmbeddings());
// the coupling manager
using CouplingManager = typename TestTraits::CouplingManager;
diff --git a/test/multidomain/facet/test_facetcouplingmapper.cc b/test/multidomain/facet/test_facetcouplingmapper.cc
index e39334a276b01967c41cc88a7a90c05bba7c4bf5..326485146f8dc8ec5694be08890ae56f73af11eb 100644
--- a/test/multidomain/facet/test_facetcouplingmapper.cc
+++ b/test/multidomain/facet/test_facetcouplingmapper.cc
@@ -85,8 +85,8 @@ template< class BulkFVG, class FacetFVG, class GridManager,
std::enable_if_t<BulkFVG::discMethod == Dumux::DiscretizationMethod::box, int> = 0 >
void updateBulkFvGeometry(BulkFVG& bulkFVG, const FacetFVG& facetFVG, const GridManager& gm)
{
- using FacetGridAdapter = Dumux::CodimOneGridAdapter<GridManager, 0, 1>;
- bulkFVG.update(facetFVG.gridView(), FacetGridAdapter{gm}, true);
+ using FacetGridAdapter = Dumux::CodimOneGridAdapter<typename GridManager::Embeddings>;
+ bulkFVG.update(facetFVG.gridView(), FacetGridAdapter(gm.getEmbeddings()), true);
}
// main program
@@ -129,12 +129,12 @@ int main (int argc, char *argv[]) try
// instantiate and update mappers for all domain combinations
Dumux::FacetCouplingMapper<BulkFVGridGeometry, FacetFVGridGeometry> bulkFacetMapper;
- Dumux::FacetCouplingMapper<FacetFVGridGeometry, EdgeFVGridGeometry, /*bulkDomainId*/1, /*edgeDomainId*/2> facetEdgeMapper;
+ Dumux::FacetCouplingMapper<FacetFVGridGeometry, EdgeFVGridGeometry, /*bulkGridId*/1, /*edgeGridId*/2> facetEdgeMapper;
Dumux::FacetCouplingThreeDomainMapper<BulkFVGridGeometry, FacetFVGridGeometry, EdgeFVGridGeometry> hierarchyMapper;
- bulkFacetMapper.update(bulkFvGeometry, facetFvGeometry, gridManager);
- facetEdgeMapper.update(facetFvGeometry, edgeFvGeometry, gridManager);
- hierarchyMapper.update(bulkFvGeometry, facetFvGeometry, edgeFvGeometry, gridManager);
+ bulkFacetMapper.update(bulkFvGeometry, facetFvGeometry, gridManager.getEmbeddings());
+ facetEdgeMapper.update(facetFvGeometry, edgeFvGeometry, gridManager.getEmbeddings());
+ hierarchyMapper.update(bulkFvGeometry, facetFvGeometry, edgeFvGeometry, gridManager.getEmbeddings());
constexpr auto bulkDomainId = Dune::index_constant<0>();
constexpr auto facetDomainId = Dune::index_constant<1>();
diff --git a/test/multidomain/facet/test_facetcouplingmapper_boundary.cc b/test/multidomain/facet/test_facetcouplingmapper_boundary.cc
index f3dd490169791418aea08f8ff38f98f5df3eb230..7985e72e5163cac66234bc62bec5ce8e888cbc33 100644
--- a/test/multidomain/facet/test_facetcouplingmapper_boundary.cc
+++ b/test/multidomain/facet/test_facetcouplingmapper_boundary.cc
@@ -56,9 +56,9 @@ int main (int argc, char *argv[]) try
// initialize parameter tree
Dumux::Parameters::init(argc, argv);
+ // try to create a grid (from the given grid file or the input file)
using BulkGrid = BULKGRIDTYPE;
using FacetGrid = Dune::FoamGrid<1, 2>;
-
using GridManager = Dumux::FacetCouplingGridManager<BulkGrid, FacetGrid>;
GridManager gridManager;
gridManager.init();
@@ -76,7 +76,7 @@ int main (int argc, char *argv[]) try
// instantiate and update mapper for all domain combinations
Dumux::FacetCouplingMapper<BulkFVGridGeometry, FacetFVGridGeometry> mapper;
- mapper.update(bulkFvGeometry, facetFvGeometry, gridManager);
+ mapper.update(bulkFvGeometry, facetFvGeometry, gridManager.getEmbeddings());
constexpr auto bulkDomainId = Dune::index_constant<0>();
constexpr auto facetDomainId = Dune::index_constant<1>();
diff --git a/test/multidomain/facet/test_gridmanager.cc b/test/multidomain/facet/test_gridmanager.cc
index 84d254a97b273472141be7adac38b6a17db4ccdb..877cfcd76f4bd92c2e7bd5013133c08c5e3075e7 100644
--- a/test/multidomain/facet/test_gridmanager.cc
+++ b/test/multidomain/facet/test_gridmanager.cc
@@ -50,10 +50,10 @@ int main (int argc, char *argv[]) try
// parse command line argument parameters
Dumux::Parameters::init(argc, argv);
+ // make grid from input file
using BulkGrid = BULKGRIDTYPE;
using FacetGrid = Dune::FoamGrid<2, 3>;
using EdgeGrid = Dune::FoamGrid<1, 3>;
-
using GridManager = Dumux::FacetCouplingGridManager<BulkGrid, FacetGrid, EdgeGrid>;
GridManager gridManager;
gridManager.init();
@@ -116,7 +116,7 @@ int main (int argc, char *argv[]) try
if (gridManager.getGridData()->wasInserted<0>(is))
{
bSegmentCount++;
- const auto insIdx = gridManager.gridFactory<0>().insertionIndex(is);
+ const auto insIdx = gridManager.getEmbeddings()->insertionIndex<0>(is);
const auto marker = gridManager.getGridData()->getBoundaryDomainMarker<0>(insIdx);
if (Dune::FloatCmp::eq(n[0], 1.0, 1e-6)) // pos x-dir
@@ -174,16 +174,16 @@ int main (int argc, char *argv[]) try
if (negZCount != 40) DUNE_THROW(Dune::InvalidStateException, "Found " << negZCount << " instead of 40 boundary segments in neg z-direction");
//! check if we found the right number of embeddings
- const auto& edgeEmbeddings = gridManager.embeddedEntityMap(2);
- const auto& edgeEmbedments = gridManager.embedmentMap(2);
+ const auto& edgeEmbeddings = gridManager.getEmbeddings()->embeddedEntityMap(2);
+ const auto& edgeEmbedments = gridManager.getEmbeddings()->adjoinedEntityMap(2);
if (edgeEmbeddings.size() != 0) DUNE_THROW(Dune::InvalidStateException, "The grid with lowest dimension can't have embedded entities");
if (edgeEmbedments.size() != 2) DUNE_THROW(Dune::InvalidStateException, "Found " << edgeEmbedments.size() << " instead of 2 edge element embedments");
for (const auto& embedments : edgeEmbedments)
if (embedments.second.size() != 4)
DUNE_THROW(Dune::InvalidStateException, "edge element is embedded in " << embedments.second.size() << " facet elements instead of 4");
- const auto& facetEmbeddings = gridManager.embeddedEntityMap(1);
- const auto& facetEmbedments = gridManager.embedmentMap(1);
+ const auto& facetEmbeddings = gridManager.getEmbeddings()->embeddedEntityMap(1);
+ const auto& facetEmbedments = gridManager.getEmbeddings()->adjoinedEntityMap(1);
if (facetEmbeddings.size() != 8) DUNE_THROW(Dune::InvalidStateException, "Found " << facetEmbeddings.size() << " instead of 8 embeddings in facet grid");
if (facetEmbedments.size() != 32) DUNE_THROW(Dune::InvalidStateException, "Found " << facetEmbedments.size() << " instead of 32 facet element embedments");
for (const auto& embedments : facetEmbedments)
@@ -193,8 +193,8 @@ int main (int argc, char *argv[]) try
if (embeddings.second.size() != 1)
DUNE_THROW(Dune::InvalidStateException, "facet element has " << embeddings.second.size() << " embedded entities instead of 1");
- const auto& bulkEmbeddings = gridManager.embeddedEntityMap(0);
- const auto& bulkEmbedments = gridManager.embedmentMap(0);
+ const auto& bulkEmbeddings = gridManager.getEmbeddings()->embeddedEntityMap(0);
+ const auto& bulkEmbedments = gridManager.getEmbeddings()->adjoinedEntityMap(0);
if (bulkEmbeddings.size() != 56) DUNE_THROW(Dune::InvalidStateException, "Found " << bulkEmbeddings.size() << " instead of 56 embeddings in bulk grid");
if (bulkEmbedments.size() != 0) DUNE_THROW(Dune::InvalidStateException, "The grid with highest dimension can't have embedments");
@@ -216,14 +216,14 @@ int main (int argc, char *argv[]) try
doubleEmbeddings = 0;
for (const auto& e : elements(bulkGridView))
{
- if (gridManager.embeddedEntityIndices<0>(e).size() == 1)
+ if (gridManager.getEmbeddings()->embeddedEntityIndices<0>(e).size() == 1)
singleEmbeddings++;
- else if (gridManager.embeddedEntityIndices<0>(e).size() == 2)
+ else if (gridManager.getEmbeddings()->embeddedEntityIndices<0>(e).size() == 2)
doubleEmbeddings++;
- else if (gridManager.embeddedEntityIndices<0>(e).size() != 0)
+ else if (gridManager.getEmbeddings()->embeddedEntityIndices<0>(e).size() != 0)
DUNE_THROW(Dune::InvalidStateException, "wrong number of embeddings!");
- if (gridManager.embedmentEntityIndices<0>(e).size() != 0)
+ if (gridManager.getEmbeddings()->adjoinedEntityIndices<0>(e).size() != 0)
DUNE_THROW(Dune::InvalidStateException, "bulk grid can't be embedded anywhere!");
}
@@ -234,14 +234,14 @@ int main (int argc, char *argv[]) try
std::size_t embedments = 0;
for (const auto& e : elements(facetGridView))
{
- if (gridManager.embeddedEntityIndices<1>(e).size() == 1)
+ if (gridManager.getEmbeddings()->embeddedEntityIndices<1>(e).size() == 1)
embeddings++;
- else if (gridManager.embeddedEntityIndices<1>(e).size() != 0)
+ else if (gridManager.getEmbeddings()->embeddedEntityIndices<1>(e).size() != 0)
DUNE_THROW(Dune::InvalidStateException, "wrong number of embeddings!");
- if (gridManager.embedmentEntityIndices<1>(e).size() == 2)
+ if (gridManager.getEmbeddings()->adjoinedEntityIndices<1>(e).size() == 2)
embedments++;
- else if (gridManager.embedmentEntityIndices<1>(e).size() != 0)
+ else if (gridManager.getEmbeddings()->adjoinedEntityIndices<1>(e).size() != 0)
DUNE_THROW(Dune::InvalidStateException, "wrong number of embedments!");
}
@@ -252,12 +252,12 @@ int main (int argc, char *argv[]) try
embedments = 0;
for (const auto& e : elements(edgeGridView))
{
- if (gridManager.embeddedEntityIndices<2>(e).size() != 0)
+ if (gridManager.getEmbeddings()->embeddedEntityIndices<2>(e).size() != 0)
DUNE_THROW(Dune::InvalidStateException, "wrong number of embeddings!");
- if (gridManager.embedmentEntityIndices<2>(e).size() == 4)
+ if (gridManager.getEmbeddings()->adjoinedEntityIndices<2>(e).size() == 4)
embedments++;
- else if (gridManager.embedmentEntityIndices<2>(e).size() != 0)
+ else if (gridManager.getEmbeddings()->adjoinedEntityIndices<2>(e).size() != 0)
DUNE_THROW(Dune::InvalidStateException, "wrong number of embedments!");
}
diff --git a/test/multidomain/facet/test_vertexmapper.cc b/test/multidomain/facet/test_vertexmapper.cc
index 3bce5e756609ebe7cbe91fb6b4d367938d1ba841..dd4ad1ce5afb73f2061b4c83730dd3b70533aa61 100644
--- a/test/multidomain/facet/test_vertexmapper.cc
+++ b/test/multidomain/facet/test_vertexmapper.cc
@@ -99,6 +99,7 @@ int main (int argc, char *argv[]) try
// initialize parameter tree
Dumux::Parameters::init(argc, argv);
+ // make a grid from the grid file in input file
using BulkGrid = BULKGRIDTYPE;
using FacetGrid = FACETGRIDTYPE;
using GridManager = Dumux::FacetCouplingGridManager<BulkGrid, FacetGrid>;
@@ -112,10 +113,12 @@ int main (int argc, char *argv[]) try
const auto& bulkGridView = gridManager.grid<0>().leafGridView();
const auto& facetGridView = gridManager.grid<1>().leafGridView();
- // data converter
- Dumux::CodimOneGridAdapter<GridManager, 0, 1> facetGridAdapter(gridManager);
+ // adapter between bulk and facet grid
+ using Embeddings = typename GridManager::Embeddings;
+ using BulkFacetAdapter = Dumux::CodimOneGridAdapter<Embeddings>;
+ BulkFacetAdapter facetGridAdapter(gridManager.getEmbeddings());
- // enriched vertex dof mapper
+ // instantiate the enriched vertex dof mapper
Dumux::EnrichedVertexDofMapper<typename BulkGrid::LeafGridView> mapper(bulkGridView);
// print out number of dofs managed by the mapper before enrichment