Holds the implementation of the CpGrid as a pimple. More...

Classes
class	CellQuadrature
	A class providing numerical quadrature for cells. More...
class	LevelCartesianIndexMapper
class	LevelCartesianIndexMapper< Dune::CpGrid >
class	FaceQuadrature
	A class providing numerical quadrature for faces. More...
class	GraphOfGrid
	A class storing a graph representation of the grid. More...
class	GridManager
	This class manages an Opm::UnstructuredGrid in the sense that it encapsulates creation and destruction of the grid. More...
struct	LookUpCellCentroid
	LookUpCellCentroid struct - To search cell centroids via element index. More...
class	LookUpData
	LookUpData class - To search field properties of leaf grid view elements via element/elementIndex. More...
class	LookUpCartesianData
	LookUpCartesianData - To search field properties of leaf grid view elements via CartesianIndex (cartesianMapper). More...
class	MinpvProcessor
	Transform a corner-point grid ZCORN field to account for MINPV processing. More...
class	LevelCartesianIndexMapper< Dune::PolyhedralGrid< dim, dimworld, coord_t > >
class	ElementChunks
	Class to simplify creating parallel yet performant threaded loops over a grid. More...
struct	iterator_range_pod
struct	iterator_range
struct	mutable_iterator_range
class	RegionMapping
	Forward and reverse mappings between cells and regions/partitions (e.g., the ECLIPSE-style 'SATNUM', 'PVTNUM', or 'EQUILNUM' arrays). More...
struct	PoisonIterator
class	SparseTable
	A SparseTable stores a table with rows of varying size as efficiently as possible. More...
class	VelocityInterpolationInterface
	Abstract interface for velocity interpolation method classes. More...
class	VelocityInterpolationConstant
	A constant velocity approximation. More...
class	VelocityInterpolationECVI
	Interpolate velocity using the extended CVI scheme: compute a corner velocity for each cell corner that is consistent with fluxes of adjacent faces, then interpolate with generalized barycentric coordinates. More...
class	WachspressCoord
	Class capable of computing Wachspress coordinates in 2d and 3d. More...

Functions
void	extractColumn (const UnstructuredGrid &grid, std::vector< std::vector< int > > &columns)
	Extract each column of the grid.
template<class T, class A, class C>
std::pair< std::vector< T, A >, std::vector< int > >	allGatherv (const std::vector< T, A > &input, const C &comm)
	Gathers vectors from all processes on all processes.
template<class T, class A, class C>
std::pair< std::vector< T, A >, std::vector< int > >	gatherv (const std::vector< T, A > &input, const C &comm, int root)
	Gathers vectors from all processes on a root process.
std::pair< std::unordered_map< int, int >, std::vector< std::array< int, 3 > > >	lgrIJK (const Dune::CpGrid &grid, const std::string &lgr_name)
	Retrieves Cartesian indices for a specified Local Grid Refinement (LGR) level in a Dune::CpGrid.
std::pair< std::vector< double >, std::vector< double > >	lgrCOORDandZCORN (const Dune::CpGrid &grid, int level, const std::unordered_map< int, int > &lgrCartesianIdxToCellIdx, const std::vector< std::array< int, 3 > > &lgrIJK)
	Extracts the COORD and ZCORN values for the LGR (Local Grid Refinement) block.
void	setPillarCoordinates (int i, int j, int nx, int topCorner, int bottomCorner, int positionIdx, const Dune::cpgrid::Entity< 0 > &topElem, const Dune::cpgrid::Entity< 0 > &bottomElem, std::vector< double > &lgrCOORD)
	Sets the coordinates for a pillar.
void	processPillars (int i, int j, int nx, const Dune::cpgrid::Entity< 0 > &topElem, const Dune::cpgrid::Entity< 0 > &bottomElem, std::vector< double > &lgrCOORD)
	Processes and sets the coordinates for all four pillars of a given "(i,j) column of cells".
bool	isNameInTheList (const std::vector< std::string > &lgr_parent_grid_names, const std::string &grid_name)
	Check whether a grid name exists in a list of parent grid names.
std::vector< int >	getLgrDataIndicesByParentGrid (const std::vector< std::string > &lgr_parent_grid_names, const std::string &parent_grid_name)
	Group LGRs by their parent grid, identified through indices.
std::tuple< std::vector< std::array< int, 3 > >, std::vector< std::array< int, 3 > >, std::vector< std::array< int, 3 > >, std::vector< std::string > >	filterLgrDataPerParentGridName (const std::vector< std::array< int, 3 > > &cells_per_dim_vec, const std::vector< std::array< int, 3 > > &startIJK_vec, const std::vector< std::array< int, 3 > > &endIJK_vec, const std::vector< std::string > &lgr_name_vec, const std::vector< std::string > &lgr_parent_grid_name_vec, const std::string &parent_grid_name)
	Retrieve LGR data associated with a specific parent grid.
bool	areParentGridsAvailableBeforeTheirLgrs (const std::map< std::string, int > &existing_grid_names, const std::vector< std::string > &new_lgr_names, const std::vector< std::string > &new_lgrs_parent_grid_names)
	Check whether each parent grid exists before its child LGRs.
void	addFutureConnectionWells (GraphOfGrid< Dune::CpGrid > &gog, const std::unordered_map< std::string, std::set< int > > &wells, bool checkWellIntersections=true)
	Adds well to the GraphOfGrid.
void	addWellConnections (GraphOfGrid< Dune::CpGrid > &gog, const Dune::cpgrid::WellConnections &wells, bool checkWellIntersections=true)
	Add WellConnections to the GraphOfGrid.
void	extendGIDtoRank (const GraphOfGrid< Dune::CpGrid > &gog, std::vector< int > &gIDtoRank, const int &root=-1)
	Correct gIDtoRank's data about well cells.
std::vector< int >	getWellRanks (const std::vector< int > &gIDtoRank, const Dune::cpgrid::WellConnections &wellConnections)
	Find to which ranks wells were assigned.
SparseTable< int >	cellNeighboursAcrossVertices (const UnstructuredGrid &grid)
	For each cell, find indices of all other cells sharing a vertex with it.
void	orderCounterClockwise (const UnstructuredGrid &grid, SparseTable< int > &nb)
	For each cell, order the (cell) neighbours counterclockwise.
std::unordered_map< int, int >	cartesianToCompressed (const int num_cells, const int *global_cell)
std::vector< int >	compressedToCartesian (const int num_cells, const int *global_cell)
template<class Range>
auto	createChunkIterators (const Range &r, const std::size_t num_elem, const std::size_t num_chunks)
	Create a vector containing a spread of iterators into the elements of the range, to facilitate for example OpenMP parallelization of iterations over the elements.
template<class Range>
auto	createThreadIterators (const Range &r, const std::size_t num_elem, const std::size_t num_threads, const std::size_t max_chunk_size, int &chunk_size)
	Create a vector containing a spread of iterators into the elements of the range, to facilitate for example OpenMP parallelization of iterations over the elements.
template<class GridView>
auto	createThreadIterators (const GridView &gv, const std::size_t num_threads, const std::size_t max_chunk_size, int &chunk_size)
	Convenience function for using createThreadIterators() with the cells in a grid view.

Variables
template<class>
constexpr bool	always_false_v = false

Detailed Description

Holds the implementation of the CpGrid as a pimple.

Author: Markus Blatt marku.nosp@m.s@dr.nosp@m.-blat.nosp@m.t.de Atgeirr F Rasmussen atgei.nosp@m.rr@s.nosp@m.intef.nosp@m..no Bård Skaflestad bard..nosp@m.skaf.nosp@m.lesta.nosp@m.d@si.nosp@m.ntef..nosp@m.no

Function Documentation

◆ addFutureConnectionWells()

void Opm::addFutureConnectionWells	(	GraphOfGrid< Dune::CpGrid > &	gog,
		const std::unordered_map< std::string, std::set< int > > &	wells,
		bool	checkWellIntersections = true )

Adds well to the GraphOfGrid.

Translates wells' cartesian ID to global ID used in the graph. Adding the well contracts vertices of the well into one vertex.

checkWellIntersections==true makes the algorithm check if wells intersect and if their cell IDs are present in the graph. Setting it to false makes the algorithm faster but leaves user responsible for keeping wells disjoint.

◆ addWellConnections()

void Opm::addWellConnections	(	GraphOfGrid< Dune::CpGrid > &	gog,
		const Dune::cpgrid::WellConnections &	wells,
		bool	checkWellIntersections = true )

Add WellConnections to the GraphOfGrid.

checkWellIntersections==true makes the algorithm check if wells intersect and if their cell IDs are present in the graph. Setting it to false makes the algorithm faster but leaves user responsible for keeping wells disjoint.

◆ allGatherv()

template<class T, class A, class C>

std::pair< std::vector< T, A >, std::vector< int > > Opm::allGatherv	(	const std::vector< T, A > &	input,
		const C &	comm )

Gathers vectors from all processes on all processes.

In parallel this will call MPI_Allgatherv. Has to be called on all ranks.

Parameters

input	The input vector to gather from the rank.
comm	The Dune::Communication object.

Returns: A pair of a vector with all the values gathered (first the ones from rank 0, then the ones from rank 1, ...) and a vector with the offsets of the first value from each rank (values[offset[rank]] will be the first value from rank). This vector is one bigger than the number of processes and the last entry is the size of the first array.

◆ areParentGridsAvailableBeforeTheirLgrs()

bool Opm::areParentGridsAvailableBeforeTheirLgrs	(	const std::map< std::string, int > &	existing_grid_names,
		const std::vector< std::string > &	new_lgr_names,
		const std::vector< std::string > &	new_lgrs_parent_grid_names )

Check whether each parent grid exists before its child LGRs.

Ensures that a parent grid is either already present in the set of existing grids or appears earlier in the list of new LGRs, before its children.

Parameters

[in]	existing_grid_names	Map of existing grid names.
[in]	new_lgr_names	Names of new LGRs to be created.
[in]	new_lgrs_parent_grid_names	Corresponding parent grid names for each LGR.

Returns: true if all parent grids exist before their child LGRs, false otherwise.

◆ cellNeighboursAcrossVertices()

SparseTable< int > Opm::cellNeighboursAcrossVertices ( const UnstructuredGrid & grid )

For each cell, find indices of all other cells sharing a vertex with it.

For each cell, find indices of all cells sharing a vertex with it.

Parameters

[in] grid A grid object.

Returns: A table of neighbour cell-indices by cell.

◆ createChunkIterators()

template<class Range>

auto Opm::createChunkIterators	(	const Range &	r,
		const std::size_t	num_elem,
		const std::size_t	num_chunks )

Create a vector containing a spread of iterators into the elements of the range, to facilitate for example OpenMP parallelization of iterations over the elements.

While the original range may have only forward iterators to the individual elements, the returned vector will provide random access to the chunks.

Template Parameters

Range Range of elements that supports (multipass) forward iteration.

Parameters

[in]	r	Range to be iterated over.
[in]	num_elem	The number of elements in r.
[in]	num_chunks	The number of chunks to create.

Returns: A vector of iterators, with the range's begin and end iterators being the first and last ones, and filling in iterators in between such that the distance from one to the next is num_elem/num_chunks, except for possibly the last interval(s). The size of the vector will be num_chunks + 1.

◆ createThreadIterators()

template<class Range>

auto Opm::createThreadIterators	(	const Range &	r,
		const std::size_t	num_elem,
		const std::size_t	num_threads,
		const std::size_t	max_chunk_size,
		int &	chunk_size )

Create a vector containing a spread of iterators into the elements of the range, to facilitate for example OpenMP parallelization of iterations over the elements.

While the original range may have only forward iterators to the individual elements, the returned vector will provide random access to the chunks.

Template Parameters

Range Range of elements that supports (multipass) forward iteration.

Parameters

[in]	r	Range to be iterated over.
[in]	num_elem	The number of elements in r.
[in]	num_threads	The number of threads to target.
[in]	max_chunk_size	The maximum allowed chunk size.
[out]	chunk_size	The chunk size found by the algorithm.

Returns: A vector of iterators, with the range's begin and end iterators being the first and last ones, and filling in iterators in between such that the distance from one to the next is chunk_size, except for possibly the last interval. If num_threads is 1, there will only be the begin and end iterators and no chunks in between.

◆ extendGIDtoRank()

void Opm::extendGIDtoRank	(	const GraphOfGrid< Dune::CpGrid > &	gog,
		std::vector< int > &	gIDtoRank,
		const int &	root = -1 )

Correct gIDtoRank's data about well cells.

gIDtoRank's entries come from Zoltan partitioner's export list that does not contain all well cells. Default value is root's rank. parameter root allows skipping wells that are correct.

◆ extractColumn()

void Opm::extractColumn	(	const UnstructuredGrid &	grid,
		std::vector< std::vector< int > > &	columns )

Extract each column of the grid.

Note: Assumes the pillars of the grid are all vertically aligned.

Parameters

grid	The grid from which to extract the columns.
columns	will for each (i, j) where (i, j) represents a non-empty column, contain the cell indices contained in the column centered at (i, j) in the second variable, and i+jN in the first variable.

◆ filterLgrDataPerParentGridName()

std::tuple< std::vector< std::array< int, 3 > >, std::vector< std::array< int, 3 > >, std::vector< std::array< int, 3 > >, std::vector< std::string > > Opm::filterLgrDataPerParentGridName	(	const std::vector< std::array< int, 3 > > &	cells_per_dim_vec,
		const std::vector< std::array< int, 3 > > &	startIJK_vec,
		const std::vector< std::array< int, 3 > > &	endIJK_vec,
		const std::vector< std::string > &	lgr_name_vec,
		const std::vector< std::string > &	lgr_parent_grid_name_vec,
		const std::string &	parent_grid_name )

Retrieve LGR data associated with a specific parent grid.

Filters LGR information (cell refinements, block bounds, and LGR names) based on the given parent grid name.

Parameters

[in]	cells_per_dim_vec	Vector of triplets specifying the number of refined cells in each dimension for each patch.
[in]	startIJK_vec	Vector of triplets specifying the starting Cartesian indices of each patch.
[in]	endIJK_vec	Vector of triplets specifying the ending Cartesian indices of each patch.
[in]	lgr_name_vec	Vector of LGR/level names.
[in]	lgr_parent_grid_name_vec	Vector of parent grid names corresponding to each LGR.
[in]	parent_grid_name	Parent grid name to filter by.

Returns

A tuple containing:

Vector of cell refinement triplets (cells per dimension),
Vector of starting index triplets,
Vector of ending index triplets,
Vector of LGR names, all restricted to the specified parent grid.

◆ gatherv()

template<class T, class A, class C>

std::pair< std::vector< T, A >, std::vector< int > > Opm::gatherv	(	const std::vector< T, A > &	input,
		const C &	comm,
		int	root )

Gathers vectors from all processes on a root process.

In parallel this will call MPI_Gatherv. Has to be called on all ranks.

Parameters

input	The input vector to gather from the rank.
comm	The Dune::Communication object.
root	The rank of the processes to gather the values-

Returns: On non-root ranks a pair of empty vectors. On the root rank a pair of a vector with all the values gathered (first the ones from rank 0, then the ones from rank 1, ...) and a vector with the offsets of the first value from each rank (values[offset[rank]] will be the first value from rank). This vector is one bigger than the number of processes and the last entry is the size of the first array.

◆ getLgrDataIndicesByParentGrid()

std::vector< int > Opm::getLgrDataIndicesByParentGrid	(	const std::vector< std::string > &	lgr_parent_grid_names,
		const std::string &	parent_grid_name )

Group LGRs by their parent grid, identified through indices.

Parameters

[in]	lgr_parent_grid_names	List of parent grid names (std::string) used for refinement.
[in]	parent_grid_name	Parent grid name to match.

Returns: A vector of indices corresponding to LGRs associated with the given parent grid. These indices can be used to access LGR data and trigger refinement.

◆ getWellRanks()

std::vector< int > Opm::getWellRanks	(	const std::vector< int > &	gIDtoRank,
		const Dune::cpgrid::WellConnections &	wellConnections )

Find to which ranks wells were assigned.

returns the vector of ranks, ordering is given by wellConnections

Parameters

gIDtoRank	Takes global ID and returns rank
wellConnections	Has global IDs of well cells

◆ isNameInTheList()

bool Opm::isNameInTheList	(	const std::vector< std::string > &	lgr_parent_grid_names,
		const std::string &	grid_name )

Check whether a grid name exists in a list of parent grid names.

Parameters

[in]	lgr_parent_grid_names	List of parent grid names (std::string) used for refinement.
[in]	grid_name	Grid name to search for.

Returns: true if grid_name is found in lgr_parent_grid_names, false otherwise.

◆ lgrCOORDandZCORN()

std::pair< std::vector< double >, std::vector< double > > Opm::lgrCOORDandZCORN	(	const Dune::CpGrid &	grid,
		int	level,
		const std::unordered_map< int, int > &	lgrCartesianIdxToCellIdx,
		const std::vector< std::array< int, 3 > > &	lgrIJK )

Extracts the COORD and ZCORN values for the LGR (Local Grid Refinement) block.

COORD: This retrieves a vector of std::array<double, 6>, where each element represents the coordinate values of a pillar in the LGR block. The values correspond to the COORD keyword, which defines the corner-point geometry of the grid. ZCORN: It is initialized to inactive values, i.e. set to std::numeric_limits<double>::max(), and then calculates the bottom and top ZCORN values for each cell in the LGR based on its geometry. It determines the active cell layers and assigns ZCORN values accordingly.

Special Cases:

If a pillar within the LGR block is "inactive", its COORD values are set to std::numeric_limits<double>::max() to indicate the inactive status.
If all pillars are "inactive", an exception is thrown.

Parameters

[in]	grid
[in]	level	The refinement level of the LGR block.
[in]	lgrCartesianIdxToCellIdx	Mapping from LGR Cartesian indices to level cell indices.
[in]	lgrIJK	The IJK indices corresponding to the LGR block active cells.

Returns

A pair containing:

A std::vector<double> storing the coordinate values for each pillar.
A std::vector<double> storing the depth of each corner point of the LGR pillars.

◆ lgrIJK()

std::pair< std::unordered_map< int, int >, std::vector< std::array< int, 3 > > > Opm::lgrIJK	(	const Dune::CpGrid &	grid,
		const std::string &	lgr_name )

Retrieves Cartesian indices for a specified Local Grid Refinement (LGR) level in a Dune::CpGrid.

This function extracts the mapping between active cell indices and Cartesian indices for a given LGR name. If the specified name is not found, an exception is thrown.

Parameters

[in]	grid	The Dune::CpGrid
[in]	lgr_name	The name of the LGR whose indices are to be retrieved.

Returns

A pair containing:

A std::unordered_map<int, int> mapping Cartesian indices back to cell indices (handles inactive parent cells).
A std::vector<std::array<int, 3>> storing the (i, j, k) Cartesian coordinates for active cells.

◆ orderCounterClockwise()

void Opm::orderCounterClockwise	(	const UnstructuredGrid &	grid,
		SparseTable< int > &	nb )

For each cell, order the (cell) neighbours counterclockwise.

Parameters

[in]	grid	A 2d grid object.
[in,out]	nb	A cell-cell neighbourhood table, such as from cellNeighboursAcrossVertices().
[in]	grid	A 2d grid object.
[in,out]	nb	A cell-cell neighbourhood table, such as from vertexNeighbours().

◆ processPillars()

void Opm::processPillars	(	int	i,
		int	j,
		int	nx,
		const Dune::cpgrid::Entity< 0 > &	topElem,
		const Dune::cpgrid::Entity< 0 > &	bottomElem,
		std::vector< double > &	lgrCOORD )

Processes and sets the coordinates for all four pillars of a given "(i,j) column of cells".

This function calls setPillarCoordinates for each of the four pillars (i,j), (i+1,j), (i,j+1), and (i+1,j+1), assigning the correct top and bottom coordinates from the given elements.

Parameters

[in]	i	Column index of the current element.
[in]	j	Row index of the current element.
[in]	nx	Number of elements in the x-direction.
[in]	topElem	Reference to the top element.
[in]	bottomElem	Reference to the bottom element.
[out]	lgrCOORD	Reference to the array storing the pillar coordinates.

◆ setPillarCoordinates()

void Opm::setPillarCoordinates	(	int	i,
		int	j,
		int	nx,
		int	topCorner,
		int	bottomCorner,
		int	positionIdx,
		const Dune::cpgrid::Entity< 0 > &	topElem,
		const Dune::cpgrid::Entity< 0 > &	bottomElem,
		std::vector< double > &	lgrCOORD )

Sets the coordinates for a pillar.

This function calculates the pillar index based on the given (i, j) position and assigns the top and bottom coordinates from the corresponding element corners.

Parameters

[in]	i	Column index of the pillar.
[in]	j	Row index of the pillar.
[in]	nx	Number of elements in the x-direction.
[in]	topCorner	Index of the top element corner associated with the pillar.
[in]	bottomCorner	Index of the bottom element corner associated with the pillar.
[in]	positionIdx	To determine the correct pillar index (0-3).
[in]	topElem	Reference to the top element.
[in]	bottomElem	Reference to the bottom element.
[out]	lgrCOORD	Reference to the array storing the pillar coordinates.

Classes

Functions

Variables

Detailed Description

Function Documentation

◆ addFutureConnectionWells()

◆ addWellConnections()

◆ allGatherv()

◆ areParentGridsAvailableBeforeTheirLgrs()

◆ cellNeighboursAcrossVertices()

◆ createChunkIterators()

◆ createThreadIterators()

◆ extendGIDtoRank()

◆ extractColumn()

◆ filterLgrDataPerParentGridName()

◆ gatherv()

◆ getLgrDataIndicesByParentGrid()

◆ getWellRanks()

◆ isNameInTheList()

◆ lgrCOORDandZCORN()

◆ lgrIJK()

◆ orderCounterClockwise()

◆ processPillars()

◆ setPillarCoordinates()