Struct that hods all the data needed to represent a Cpgrid. More...

#include <CpGridData.hpp>

Public Types
enum	{ MAX_DATA_PER_CELL = 2 }

using	MPICommunicator = CpGridDataTraits::MPICommunicator
	The type of the mpi communicator.

using	Communication = CpGridDataTraits::Communication
	The type of the collective communication.

using	CollectiveCommunication = CpGridDataTraits::CollectiveCommunication

using	AttributeSet = CpGridDataTraits::AttributeSet
	The type of the set of the attributes.

Public Member Functions
	CpGridData (MPIHelper::MPICommunicator comm, std::vector< std::shared_ptr< CpGridData > > &data)
	Constructor for parallel grid data.

	CpGridData (std::vector< std::shared_ptr< CpGridData > > &data)
	Constructor.

	~CpGridData ()
	Destructor.

int	size (int codim) const
	number of leaf entities per codim in this process

int	size (GeometryType type) const
	number of leaf entities per geometry type in this process

void	readEclipseFormat (const std::string &filename, bool periodic_extension, bool turn_normals=false)
	Read the Eclipse grid format ('grdecl').

void	processEclipseFormat (const grdecl &input_data, std::array< std::set< std::pair< int, int > >, 2 > &nnc, bool remove_ij_boundary, bool turn_normals, bool pinchActive, double tolerance_unique_points)
	Read the Eclipse grid format ('grdecl').

void	getIJK (int c, std::array< int, 3 > &ijk) const
	Extract Cartesian index triplet (i,j,k) of an active cell.

int	cellFace (int cell, int local_index) const

int	faceToCellSize (int face) const

const std::vector< int > &	globalCell () const
	Return global_cell_ of any level grid, or the leaf grid view (in presence of refinement).

std::array< int, 3 >	getIJK (int idx_in_parent_cell, const std::array< int, 3 > &cells_per_dim) const
	Extract Cartesian index triplet (i,j,k) given an index between 0 and NXxNYxNZ -1 where NX, NY, and NZ is the total amoung of cells in each direction x-,y-,and z- respectively.

bool	disjointPatches (const std::vector< std::array< int, 3 > > &startIJK_vec, const std::vector< std::array< int, 3 > > &endIJK_vec) const
	Determine if a finite amount of patches (of cells) are disjoint, namely, they do not share any corner nor face.

std::vector< int >	getPatchesCells (const std::vector< std::array< int, 3 > > &startIJK_vec, const std::vector< std::array< int, 3 > > &endIJK_vec) const
	Compute cell indices of selected patches of cells (Cartesian grid required).

bool	hasNNCs (const std::vector< int > &cellIndices) const
	Check all cells selected for refinement have no NNCs (no neighbor connections).

void	validStartEndIJKs (const std::vector< std::array< int, 3 > > &startIJK_vec, const std::vector< std::array< int, 3 > > &endIJK_vec) const
	Check startIJK and endIJK of each patch of cells to be refined are valid, i.e.

void	checkCuboidShape (const std::vector< int > &cellIdx_vec) const
	Check that every cell to be refined has cuboid shape.

bool	patchesShareFace (const std::vector< std::array< int, 3 > > &startIJK_vec, const std::vector< std::array< int, 3 > > &endIJK_vec) const
	Determine if a finite amount of patches (of cells) share a face.

int	sharedFaceTag (const std::vector< std::array< int, 3 > > &startIJK_2Patches, const std::vector< std::array< int, 3 > > &endIJK_2Patches) const

bool	mark (int refCount, const cpgrid::Entity< 0 > &element)
	Mark entity for refinement or coarsening.

int	getMark (const cpgrid::Entity< 0 > &element) const
	Return refinement mark for entity.

bool	preAdapt ()
	Set mightVanish flags for elements that will be refined in the next adapt() call Need to be called after elements have been marked for refinement.

bool	adapt ()
	TO DO: Documentation. Triggers the grid refinement process - Currently, returns preAdapt()

void	postAdapt ()
	Clean up refinement/coarsening markers - set every element to the mark 0 which represents 'doing nothing'.

int	getGridIdx () const
	Add doc/or remove method and replace it with better approach.

const std::vector< std::shared_ptr< Dune::cpgrid::CpGridData > > &	levelData () const
	Add doc/or remove method and replace it with better approach.

const std::tuple< int, std::vector< int > > &	getChildrenLevelAndIndexList (int elemIdx) const
	Retrieves the level and child indices of a given parent cell.

const std::vector< std::tuple< int, std::vector< int > > > &	getParentToChildren () const

std::tuple< const std::shared_ptr< CpGridData >, const std::vector< std::array< int, 2 > >, const std::vector< std::tuple< int, std::vector< int > > >, const std::tuple< int, std::vector< int > >, const std::vector< std::array< int, 2 > >, const std::vector< std::array< int, 2 > > >	refineSingleCell (const std::array< int, 3 > &cells_per_dim, const int &parent_idx) const
	Refine a single cell and return a shared pointer of CpGridData type.

std::tuple< std::shared_ptr< CpGridData >, const std::vector< std::array< int, 2 > >, const std::vector< std::tuple< int, std::vector< int > > >, const std::vector< std::tuple< int, std::vector< int > > >, const std::vector< std::tuple< int, std::vector< int > > >, const std::vector< std::array< int, 2 > >, const std::vector< std::array< int, 2 > > >	refinePatch (const std::array< int, 3 > &cells_per_dim, const std::array< int, 3 > &startIJK, const std::array< int, 3 > &endIJK) const
	Refine a (connected block-shaped) patch of cells.

std::array< double, 3 >	computeEclCentroid (const int idx) const

std::array< double, 3 >	computeEclCentroid (const Entity< 0 > &elem) const

void	computeUniqueBoundaryIds ()

bool	uniqueBoundaryIds () const
	Is the grid currently using unique boundary ids?

void	setUniqueBoundaryIds (bool uids)
	Set whether we want to have unique boundary ids.

const std::vector< double > &	zcornData () const
	Return the internalized zcorn copy from the grid processing, if no cells were adjusted during the minpvprocessing this can be and empty vector.

const IndexSet &	indexSet () const
	Get the index set.

const cpgrid::IdSet &	localIdSet () const
	Get the local index set.

const cpgrid::LevelGlobalIdSet &	globalIdSet () const
	Get the global index set.

const std::array< int, 3 > &	logicalCartesianSize () const
	The logical cartesian size of the grid.

void	distributeGlobalGrid (CpGrid &grid, const CpGridData &view_data, const std::vector< int > &cell_part)
	Redistribute a global grid.

template<class DataHandle >
void	communicate (DataHandle &data, InterfaceType iftype, CommunicationDirection dir)
	communicate objects for all codims on a given level

void	computeCellPartitionType ()

void	computePointPartitionType ()

void	computeCommunicationInterfaces (int noexistingPoints)

const std::vector< int > &	sortedNumAquiferCells () const
	Get sorted active cell indices of numerical aquifer.

Friends
template<class T , int i>
struct	mover::Mover

class	GlobalIdSet

class	HierarchicIterator

class	Dune::cpgrid::IndexSet

class	Dune::cpgrid::IdSet

class	Dune::cpgrid::LevelGlobalIdSet

class	Dune::CpGrid

template<int >
class	Entity

template<int >
class	EntityRep

class	Intersection

class	PartitionTypeIndicator

Detailed Description

Struct that hods all the data needed to represent a Cpgrid.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator

MAX_DATA_PER_CELL

The maximum data items allowed per cell (DUNE < 2.5.2)

    Due to a bug in DUNE < 2.5.2 we need to limit this when
    communicating. 1 is big enough for OPM as we always use
    one block for all unknowns, but some DUNE's grid checks
    actually need 2. So 2 it is.

Constructor & Destructor Documentation

◆ CpGridData()

Dune::cpgrid::CpGridData::CpGridData	(	MPIHelper::MPICommunicator	comm,
		std::vector< std::shared_ptr< CpGridData > > &	data
	)

explicit

Constructor for parallel grid data.

Parameters

comm	The MPI communicator Default constructor.

Member Function Documentation

◆ communicate()

template<class DataHandle >

void Dune::cpgrid::CpGridData::communicate	(	DataHandle &	data,
		InterfaceType	iftype,
		CommunicationDirection	dir
	)

communicate objects for all codims on a given level

Parameters

data	The data handle describing the data. Has to adhere to the Dune::DataHandleIF interface.
iftype	The interface to use for the communication.
dir	The direction of the communication along the interface (forward or backward).

◆ disjointPatches()

bool Dune::cpgrid::CpGridData::disjointPatches	(	const std::vector< std::array< int, 3 > > &	startIJK_vec,
		const std::vector< std::array< int, 3 > > &	endIJK_vec
	)		const

Determine if a finite amount of patches (of cells) are disjoint, namely, they do not share any corner nor face.

Parameters

[in]	startIJK_vec	Vector of Cartesian triplet indices where each patch starts.
[in]	endIJK_vec	Vector of Cartesian triplet indices where each patch ends. Last cell part of the lgr will be {endIJK_vec[<patch>][0]-1, ... ,endIJK_vec[<patch>][2]-1}.

◆ distributeGlobalGrid()

void Dune::cpgrid::CpGridData::distributeGlobalGrid	(	CpGrid &	grid,
		const CpGridData &	view_data,
		const std::vector< int > &	cell_part
	)

Redistribute a global grid.

The whole grid must be available on all processors.

◆ getChildrenLevelAndIndexList()

const std::tuple< int, std::vector< int > > & Dune::cpgrid::CpGridData::getChildrenLevelAndIndexList ( int elemIdx ) const

inline

Retrieves the level and child indices of a given parent cell.

Parameters

elemIdx The index of the parent cell.

Returns

A tuple of (- could be a pair -)

An integer representing the refinement level (LGR) of the parent cell.
A vector of integers representing the indices of the child cells.
If the parent cell has no children, the entry is {-1, {}}.

◆ getIJK() [1/2]

void Dune::cpgrid::CpGridData::getIJK	(	int	c,
		std::array< int, 3 > &	ijk
	)		const

inline

Extract Cartesian index triplet (i,j,k) of an active cell.

Parameters

[in]	c	Active cell index.
[out]	ijk	Cartesian index triplet

◆ getIJK() [2/2]

std::array< int, 3 > Dune::cpgrid::CpGridData::getIJK	(	int	idx_in_parent_cell,
		const std::array< int, 3 > &	cells_per_dim
	)		const

inline

Extract Cartesian index triplet (i,j,k) given an index between 0 and NXxNYxNZ -1 where NX, NY, and NZ is the total amoung of cells in each direction x-,y-,and z- respectively.

Parameters

[in]	idx	Integer between 0 and cells_per_dim[0]cells_per_dim[1]cells_per_dim[2]-1
[in]	cells_per_dim

Returns: Cartesian index triplet.

◆ getMark()

int Dune::cpgrid::CpGridData::getMark ( const cpgrid::Entity< 0 > & element ) const

Return refinement mark for entity.

Returns: refinement mark (1 refinement, 0 doing nothing, -1 coarsening - not supported yet).

◆ getPatchesCells()

std::vector< int > Dune::cpgrid::CpGridData::getPatchesCells	(	const std::vector< std::array< int, 3 > > &	startIJK_vec,
		const std::vector< std::array< int, 3 > > &	endIJK_vec
	)		const

Compute cell indices of selected patches of cells (Cartesian grid required).

Parameters

[in]	startIJK_vec	Vector of Cartesian triplet indices where each patch starts.
[in]	endIJK_vec	Vector of Cartesian triplet indices where each patch ends. Last cell part of the lgr will be {endIJK_vec[<patch>][0]-1, ... endIJK_vec[<patch>][2]-1}.

Returns: allPatches_cells

PATCH CELLS

◆ globalCell()

const std::vector< int > & Dune::cpgrid::CpGridData::globalCell ( ) const

inline

Return global_cell_ of any level grid, or the leaf grid view (in presence of refinement).

global_cell_ has size number of cells present on a process and maps to the underlying Cartesian Grid.

Note: CpGrid::globalCell() returns current_view_data_-> global_cell_ (current_view_data_ points at data_.back() or distributed_data_.back(), in general. If the grid has been refined, current_view_data_ points at the "leaf grid view").

◆ hasNNCs()

bool Dune::cpgrid::CpGridData::hasNNCs ( const std::vector< int > & cellIndices ) const

Check all cells selected for refinement have no NNCs (no neighbor connections).

Assumption: all grid cells are active.

◆ indexSet()

const IndexSet & Dune::cpgrid::CpGridData::indexSet ( ) const

inline

Get the index set.

This is the lead as well as th level index set.

Returns: The index set.

◆ logicalCartesianSize()

const std::array< int, 3 > & Dune::cpgrid::CpGridData::logicalCartesianSize ( ) const

inline

The logical cartesian size of the grid.

This function is not part of the Dune grid interface, and should be used with caution.

◆ mark()

bool Dune::cpgrid::CpGridData::mark	(	int	refCount,
		const cpgrid::Entity< 0 > &	element
	)

Mark entity for refinement or coarsening.

Refinement on CpGrid is partially supported for Cartesian grids, with the keyword CARFIN. This only works for entities of codim 0.

Parameters

[in]	refCount	To mark the element for refinement, refCount == 1 doing nothing, refCount == 0 coarsening, refCount == -1 (not applicable yet)
[in]	element	Entity<0>. Currently, an element from the GLOBAL grid (level zero).

Returns: true, if marking was succesfull. false, if marking was not possible.

◆ patchesShareFace()

bool Dune::cpgrid::CpGridData::patchesShareFace	(	const std::vector< std::array< int, 3 > > &	startIJK_vec,
		const std::vector< std::array< int, 3 > > &	endIJK_vec
	)		const

Determine if a finite amount of patches (of cells) share a face.

Parameters

[in]	startIJK_vec	Vector of Cartesian triplet indices where each patch starts.
[in]	endIJK_vec	Vector of Cartesian triplet indices where each patch ends. Last cell part of the lgr will be {endIJK_vec[<patch>][0]-1, ... ,endIJK_vec[<patch>][2]-1}.

◆ processEclipseFormat()

void Dune::cpgrid::CpGridData::processEclipseFormat	(	const grdecl &	input_data,
		std::array< std::set< std::pair< int, int > >, 2 > &	nnc,
		bool	remove_ij_boundary,
		bool	turn_normals,
		bool	pinchActive,
		double	tolerance_unique_points
	)

Read the Eclipse grid format ('grdecl').

Read the Eclipse grid format ('.grdecl').

Parameters

input_data	the data in grdecl format, declared in preprocess.h.
ecl_state	the object from opm-parser provide information regarding to pore volume, NNC, aquifer information when ecl_state is available. NNC and aquifer connection information will also be updated during the function call when available and necessary.
nnc	is the non-neighboring connections
remove_ij_boundary	if true, will remove (i, j) boundaries. Used internally.
pinchActive	If true, we will add faces between vertical cells that have only inactive cells or cells with zero volume between them. If false these cells will not be connected.
tolerance_unique_points	Tolerance used to identify points based on their cooridinate

◆ readEclipseFormat()

void Dune::cpgrid::CpGridData::readEclipseFormat	(	const std::string &	filename,
		bool	periodic_extension,
		bool	turn_normals = `false`
	)

Read the Eclipse grid format ('grdecl').

Parameters

filename	the name of the file to read.
periodic_extension	if true, the grid will be (possibly) refined, so that intersections/faces along i and j boundaries will match those on the other side. That is, i- faces will match i+ faces etc.

◆ refinePatch()

std::tuple< std::shared_ptr< CpGridData >, const std::vector< std::array< int, 2 > >, const std::vector< std::tuple< int, std::vector< int > > >, const std::vector< std::tuple< int, std::vector< int > > >, const std::vector< std::tuple< int, std::vector< int > > >, const std::vector< std::array< int, 2 > >, const std::vector< std::array< int, 2 > > > Dune::cpgrid::CpGridData::refinePatch	(	const std::array< int, 3 > &	cells_per_dim,
		const std::array< int, 3 > &	startIJK,
		const std::array< int, 3 > &	endIJK
	)		const

Refine a (connected block-shaped) patch of cells.

Based on the patch, a Geometry<3,3> object is created and refined.

Parameters

[in]	cells_per_dim	Number of (refined) cells in each direction that each parent cell should be refined to.
[in]	startIJK	Cartesian triplet index where the patch starts.
[in]	endIJK	Cartesian triplet index where the patch ends. Last cell part of the lgr will be {endijk[0]-1, ... endIJK[2]-1}.

Returns: refined_grid_ptr Shared pointer of CpGridData type, pointing at the refined_grid; boundary_old_to_new_corners/faces Corner/face indices on the patch-boundary associated with new-born-entity indices.; parent_to_children_faces/cell For each parent face/cell, we store its child-face/cell indices. {parent face/cell index in coarse level, {indices of its children in refined level}}; child_to_parent_faces/cells {child index, parent index}

◆ refineSingleCell()

std::tuple< const std::shared_ptr< CpGridData >, const std::vector< std::array< int, 2 > >, const std::vector< std::tuple< int, std::vector< int > > >, const std::tuple< int, std::vector< int > >, const std::vector< std::array< int, 2 > >, const std::vector< std::array< int, 2 > > > Dune::cpgrid::CpGridData::refineSingleCell	(	const std::array< int, 3 > &	cells_per_dim,
		const int &	parent_idx
	)		const

Refine a single cell and return a shared pointer of CpGridData type.

refineSingleCell() takes a cell and refines it in a chosen amount of cells (per direction); creating the geometries, topological relations, etc. Stored in a CpGridData object. Additionally, containers for parent-to-new-born entities are buil, as well as, new-born-to-parent. Maps(<int,bool>) to detect parent faces or cells are also provided. (Cell with 6 faces required).

Parameters

[in]	cells_per_dim	Number of (refined) cells in each direction that each parent cell should be refined to.
[in]	parent_idx	Parent cell index, cell to be refined.

Returns: refined_grid_ptr Shared pointer pointing at refined_grid.; parent_to_refined_corners For each corner of the parent cell, we store the index of the refined corner that coincides with the old one. We assume they are ordered 0,1,..7 6—7 2—3 | | TOP FACE | | 4—5 0—1 BOTTOM FACE; parent_to_children_faces/cell For each parent face/cell, we store its child-face/cell indices. {parent face/cell index in coarse level, {indices of its children in refined level}}; child_to_parent_faces/cells {child index, parent index}

◆ setUniqueBoundaryIds()

void Dune::cpgrid::CpGridData::setUniqueBoundaryIds ( bool uids )

inline

Set whether we want to have unique boundary ids.

Parameters

uids	if true, each boundary intersection will have a unique boundary id.

◆ uniqueBoundaryIds()

bool Dune::cpgrid::CpGridData::uniqueBoundaryIds ( ) const

inline

Is the grid currently using unique boundary ids?

Returns: true if each boundary intersection has a unique id false if we use the (default) 1-6 ids for i- i+ j- j+ k- k+ boundaries.

◆ validStartEndIJKs()

void Dune::cpgrid::CpGridData::validStartEndIJKs	(	const std::vector< std::array< int, 3 > > &	startIJK_vec,
		const std::vector< std::array< int, 3 > > &	endIJK_vec
	)		const

Check startIJK and endIJK of each patch of cells to be refined are valid, i.e.

startIJK and endIJK vectors have the same size and, startIJK < endIJK coordenate by coordenate.

Parameters

[in]	startIJK_vec	Vector of Cartesian triplet indices where each patch starts.
[in]	endIJK_vec	Vector of Cartesian triplet indices where each patch ends. Last cell part of the lgr will be {endIJK_vec[patch][0]-1, ..., endIJK_vec[patch][2]-1}.

The documentation for this class was generated from the following files:

opm/grid/cpgrid/CpGridData.hpp
opm/grid/cpgrid/CpGridData.cpp
opm/grid/cpgrid/processEclipseFormat.cpp

Public Types

Public Member Functions

Friends

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ CpGridData()

Member Function Documentation

◆ communicate()

◆ disjointPatches()

◆ distributeGlobalGrid()

◆ getChildrenLevelAndIndexList()

◆ getIJK() [1/2]

◆ getIJK() [2/2]

◆ getMark()

◆ getPatchesCells()

◆ globalCell()

◆ hasNNCs()

◆ indexSet()

◆ logicalCartesianSize()

◆ mark()

◆ patchesShareFace()

◆ processEclipseFormat()

◆ readEclipseFormat()

◆ refinePatch()

◆ refineSingleCell()

◆ setUniqueBoundaryIds()

◆ uniqueBoundaryIds()

◆ validStartEndIJKs()