Class designed to hold node ID information and information about nodal connectivity. More...

#include <PorousFlowConnectedNodes.h>

Public Member Functions
	PorousFlowConnectedNodes ()

void	clear ()
	clear all data in readiness for adding global nodes and connections More...

void	addGlobalNode (dof_id_type global_node_ID)
	Add the given global_node_ID to the internal data structures If the global node ID has already been added this method does nothing. More...

void	finalizeAddingGlobalNodes ()
	Signal that all global node IDs have been added to the internal data structures. More...

std::size_t	numNodes () const
	number of nodes known by this class More...

dof_id_type	globalID (dof_id_type sequential_node_ID) const
	Return the global node ID (node number in the mesh) corresponding to the provided sequential node ID. More...

dof_id_type	sequentialID (dof_id_type global_node_ID) const
	Return the sequential node ID corresponding to the global node ID This is guaranteed to lie in the range [0, numNodes() - 1]. More...

const std::vector< dof_id_type > &	globalIDs () const
	Vector of all global node IDs (node numbers in the mesh) More...

void	addConnection (dof_id_type global_node_from, dof_id_type global_node_to)
	Specifies that global_node_to is connected to global_node_from. More...

void	finalizeAddingConnections ()
	Signal that all global node IDs have been added to the internal data structures. More...

const std::vector< dof_id_type > &	sequentialConnectionsToGlobalID (dof_id_type global_node_ID) const
	Return all the nodes (sequential node IDs) connected to the given global node ID All elements of the returned vector are guaranteed to be unique and lie in the range [0, numNodes() - 1]. More...

const std::vector< dof_id_type > &	sequentialConnectionsToSequentialID (dof_id_type sequential_node_ID) const
	Return all the nodes (sequential node IDs) connected to the given sequential node ID All elements of the returned vector are guaranteed to be unique and lie in the range [0, numNodes() - 1]. More...

const std::vector< dof_id_type > &	globalConnectionsToGlobalID (dof_id_type global_node_ID) const
	Return all the nodes (global node IDs) connected to the given global node ID. More...

const std::vector< dof_id_type > &	globalConnectionsToSequentialID (dof_id_type sequential_node_ID) const
	Return all the nodes (global node IDs) connected to the given sequential node ID. More...

unsigned	indexOfGlobalConnection (dof_id_type global_node_ID_from, dof_id_type global_node_ID_to) const
	Return the index of global_node_ID_to in the globalConnectionsToGlobalID(global_node_ID_from) vector. More...

unsigned	indexOfSequentialConnection (dof_id_type sequential_node_ID_from, dof_id_type sequential_node_ID_to) const
	Return the index of sequential_node_ID_to in the sequentialConnectionsToSequentialID(sequential_node_ID_from) vector. More...

std::size_t	sizeSequential () const
	Return the size of _sequential_id, for checking memory efficiency. More...

Private Attributes
bool	_still_adding_global_nodes

dof_id_type	_min_global_id

dof_id_type	_max_global_id

std::set< dof_id_type >	_set_of_global_ids

std::vector< dof_id_type >	_global_id

std::vector< dof_id_type >	_sequential_id

bool	_still_adding_connections

std::vector< std::set< dof_id_type > >	_neighbor_sets

std::vector< std::vector< dof_id_type > >	_sequential_neighbors

std::vector< std::vector< dof_id_type > >	_global_neighbors

Detailed Description

Class designed to hold node ID information and information about nodal connectivity.

Node ID is either:

global, meaning that it is the number assigned to the node in the mesh
sequential, meaning that it is the number used within this class The sequential numbering runs from zero to number_of_nodes - 1

The use case of interest in PorousFlow is where many quantities are recorded at each node in the mesh. To record this, a std::vector<quantity> may be used. But if the global node IDs are sparsely distributed between zero and the maximum node number, then basing the std::vector on global ID is inefficient because there are many elements in the std::vector that are unused. Instead, a std::vector based on the sequential node ID may be used, which is optimally memory efficient. (A std::map<dof_id_type, quantity> may be used, but it is slow.)

Nodal connectivity is defined between two global node IDs. Note that it is uni-directional, meaning that if node 12 is connected to node 321, then node 321 is not necessarily connected to node 12 (the user must explicitly add both the 12->321 and 321->12 connections if that is desired).

This class is designed to be used as follows: (1) instantiation (2) populate the nodal information using addGlobalNode (3) finalizeAddingGlobalNodes() (4) populate the connectivity using addConnection (5) finalizeAddingConnections() (6) functions like sequentialID and sequentialNeighborsOfGlobalID are now ready for use

Definition at line 45 of file PorousFlowConnectedNodes.h.

Constructor & Destructor Documentation

◆ PorousFlowConnectedNodes()

PorousFlowConnectedNodes::PorousFlowConnectedNodes ( )

Definition at line 14 of file PorousFlowConnectedNodes.C.

14 { clear(); }

PorousFlowConnectedNodes::clear

void clear()

clear all data in readiness for adding global nodes and connections

Definition: PorousFlowConnectedNodes.C:17

Member Function Documentation

◆ addConnection()

void PorousFlowConnectedNodes::addConnection	(	dof_id_type	global_node_from,
		dof_id_type	global_node_to
	)

Specifies that global_node_to is connected to global_node_from.

Hence, globalConnectionsToGlobalID(global_node_from) will contain global_node_to. If the connection has already been added this method does nothing Recall that connections are uni-directional, so if you desire bi-directional connectivity you must call addConnection twice (the second time with arguments swapped)

Parameters

global_node_from	global node ID of the 'from' node
global_node_to	global node ID of the 'to' node

Definition at line 96 of file PorousFlowConnectedNodes.C.

Referenced by PorousFlowConnectedNodesTest::SetUp(), and AdvectiveFluxCalculatorBase::timestepSetup().

 {
   if (_still_adding_global_nodes)
     mooseError("PorousFlowConnectedNodes: addConnection called, but _still_adding_global_nodes is "
                "true.  Probably you should have called finalizeAddingGlobalNodes.");
   if (!_still_adding_connections)
     mooseError("PorousFlowConnectedNodes: addConnection called, but _still_adding_connections is "
                "false.  Probably you should have called finalizeAddingConnections.");
   _neighbor_sets[sequentialID(global_node_from)].insert(global_node_to);
 }

◆ addGlobalNode()

void PorousFlowConnectedNodes::addGlobalNode ( dof_id_type global_node_ID )

Add the given global_node_ID to the internal data structures If the global node ID has already been added this method does nothing.

Parameters

global_node_ID node number in the mesh

Definition at line 39 of file PorousFlowConnectedNodes.C.

Referenced by PorousFlowConnectedNodesTest::SetUp(), and AdvectiveFluxCalculatorBase::timestepSetup().

 {
   if (!_still_adding_global_nodes)
     mooseError("PorousFlowConnectedNodes: addGlobalNode called, but _still_adding_global_nodes is "
                "false.  You possibly called finalizeAddingGlobalNodes too soon.");
   _set_of_global_ids.insert(global_node_ID);
   _min_global_id = std::min(_min_global_id, global_node_ID);
   _max_global_id = std::max(_max_global_id, global_node_ID);
 }

◆ clear()

void PorousFlowConnectedNodes::clear ( )

clear all data in readiness for adding global nodes and connections

Definition at line 17 of file PorousFlowConnectedNodes.C.

Referenced by PorousFlowConnectedNodes(), and AdvectiveFluxCalculatorBase::timestepSetup().

 {
   _still_adding_global_nodes = true;
   _min_global_id = std::numeric_limits<dof_id_type>::max();
   _max_global_id = std::numeric_limits<dof_id_type>::lowest();
   _set_of_global_ids.clear();
   _global_id.clear();
   _sequential_id.clear();
   _still_adding_connections = true;
   _neighbor_sets.clear();
   _sequential_neighbors.clear();
 }

◆ finalizeAddingConnections()

void PorousFlowConnectedNodes::finalizeAddingConnections ( )

Signal that all global node IDs have been added to the internal data structures.

Definition at line 108 of file PorousFlowConnectedNodes.C.

Referenced by PorousFlowConnectedNodesTest::SetUp(), and AdvectiveFluxCalculatorBase::timestepSetup().

 {
   _sequential_neighbors.assign(_global_id.size(), std::vector<dof_id_type>());
   _global_neighbors.assign(_global_id.size(), std::vector<dof_id_type>());
   for (std::size_t i = 0; i < _global_id.size(); ++i)
     for (const auto & n : _neighbor_sets[i])
     {
       _sequential_neighbors[i].push_back(sequentialID(n));
       _global_neighbors[i].push_back(n);
     }
   _still_adding_connections = false;
   _neighbor_sets.clear();
 }

◆ finalizeAddingGlobalNodes()

void PorousFlowConnectedNodes::finalizeAddingGlobalNodes ( )

Signal that all global node IDs have been added to the internal data structures.

Definition at line 50 of file PorousFlowConnectedNodes.C.

Referenced by PorousFlowConnectedNodesTest::SetUp(), and AdvectiveFluxCalculatorBase::timestepSetup().

 {
   // populate the _global_id vector with the values in the set of global IDs
   _global_id.clear();
   for (const auto & n : _set_of_global_ids)
     _global_id.push_back(n);
   _still_adding_global_nodes = false;
   _set_of_global_ids.clear();
 
   // populate the _sequential_id
   _sequential_id.assign(_max_global_id - _min_global_id + 1, 0);
   for (std::size_t i = 0; i < _global_id.size(); ++i)
     _sequential_id[_global_id[i] - _min_global_id] = i;
 
   // prepare the _neighbor_sets
   _neighbor_sets.assign(_global_id.size(), std::set<dof_id_type>());
 }

◆ globalConnectionsToGlobalID()

const std::vector< dof_id_type > & PorousFlowConnectedNodes::globalConnectionsToGlobalID ( dof_id_type global_node_ID ) const

Return all the nodes (global node IDs) connected to the given global node ID.

Definition at line 143 of file PorousFlowConnectedNodes.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::buildCommLists(), AdvectiveFluxCalculatorBase::finalize(), PorousFlowAdvectiveFluxCalculatorBase::finalize(), and AdvectiveFluxCalculatorBase::zeroedConnection().

 {
   if (_still_adding_connections)
     mooseError("PorousFlowConnectedNodes: globalConnectionsToGlobalID called, but "
                "_still_adding_connections is true.  Probably you should have called "
                "finalizeAddingConnections.");
   return _global_neighbors[sequentialID(global_node_ID)];
 }

◆ globalConnectionsToSequentialID()

const std::vector< dof_id_type > & PorousFlowConnectedNodes::globalConnectionsToSequentialID ( dof_id_type sequential_node_ID ) const

Return all the nodes (global node IDs) connected to the given sequential node ID.

Definition at line 153 of file PorousFlowConnectedNodes.C.

Referenced by AdvectiveFluxCalculatorBase::finalize(), PorousFlowAdvectiveFluxCalculatorBase::initialize(), PorousFlowAdvectiveFluxCalculatorBase::threadJoin(), and PorousFlowAdvectiveFluxCalculatorBase::timestepSetup().

 {
   if (_still_adding_connections)
     mooseError("PorousFlowConnectedNodes: globalConnectionsToSequentialID called, but "
                "_still_adding_connections is true.  Probably you should have called "
                "finalizeAddingConnections.");
   return _global_neighbors[sequential_node_ID];
 }

◆ globalID()

dof_id_type PorousFlowConnectedNodes::globalID ( dof_id_type sequential_node_ID ) const

Return the global node ID (node number in the mesh) corresponding to the provided sequential node ID.

Parameters

sequential_node_ID the sequential node ID

Definition at line 78 of file PorousFlowConnectedNodes.C.

Referenced by AdvectiveFluxCalculatorBase::finalize(), and AdvectiveFluxCalculatorBase::timestepSetup().

 {
   if (_still_adding_global_nodes)
     mooseError("PorousFlowConnectedNodes: globalID called, but _still_adding_global_nodes is true. "
                " Probably you should have called finalizeAddingGlobalNodes.");
   return _global_id[sequential_node_ID];
 }

◆ globalIDs()

const std::vector< dof_id_type > & PorousFlowConnectedNodes::globalIDs ( ) const

Vector of all global node IDs (node numbers in the mesh)

Definition at line 163 of file PorousFlowConnectedNodes.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::finalize().

 {
   if (_still_adding_global_nodes)
     mooseError("PorousFlowConnectedNodes: globalIDs called, but _still_adding_global_nodes is "
                "true.  Probably you should have called finalizeAddingGlobalNodes.");
   return _global_id;
 }

◆ indexOfGlobalConnection()

unsigned PorousFlowConnectedNodes::indexOfGlobalConnection	(	dof_id_type	global_node_ID_from,
		dof_id_type	global_node_ID_to
	)		const

Return the index of global_node_ID_to in the globalConnectionsToGlobalID(global_node_ID_from) vector.

Definition at line 172 of file PorousFlowConnectedNodes.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::buildCommLists(), AdvectiveFluxCalculatorBase::buildCommLists(), PorousFlowAdvectiveFluxCalculatorBase::executeOnElement(), AdvectiveFluxCalculatorBase::executeOnElement(), and PorousFlowAdvectiveFluxCalculatorBase::getdK_dvar().

 {
   if (_still_adding_connections)
     mooseError(
         "PorousFlowConnectedNodes: indexOfGlobalConnection called, but _still_adding_connections "
         "is true.  Probably you should have called finalizeAddingConnections.");
   const std::vector<dof_id_type> con = _global_neighbors[sequentialID(global_node_ID_from)];
   const auto it = std::find(con.begin(), con.end(), global_node_ID_to);
   if (it == con.end())
     mooseError("PorousFlowConnectedNode: global_node_ID_from " +
                Moose::stringify(global_node_ID_from) + " has no connection to global_node_ID_to " +
                Moose::stringify(global_node_ID_to));
   return std::distance(con.begin(), it);
 }

◆ indexOfSequentialConnection()

unsigned PorousFlowConnectedNodes::indexOfSequentialConnection	(	dof_id_type	sequential_node_ID_from,
		dof_id_type	sequential_node_ID_to
	)		const

Return the index of sequential_node_ID_to in the sequentialConnectionsToSequentialID(sequential_node_ID_from) vector.

Definition at line 189 of file PorousFlowConnectedNodes.C.

Referenced by AdvectiveFluxCalculatorBase::finalize(), and AdvectiveFluxCalculatorBase::PQPlusMinus().

 {
   if (_still_adding_connections)
     mooseError("PorousFlowConnectedNodes: indexOfSequentialConnection called, but "
                "_still_adding_connections is true.  Probably you should have called "
                "finalizeAddingConnections.");
   const std::vector<dof_id_type> con = _sequential_neighbors[sequential_node_ID_from];
   const auto it = std::find(con.begin(), con.end(), sequential_node_ID_to);
   if (it == con.end())
     mooseError("PorousFlowConnectedNode: sequential_node_ID_from " +
                Moose::stringify(sequential_node_ID_from) +
                " has no connection to sequential_node_ID_to " +
                Moose::stringify(sequential_node_ID_to));
   return std::distance(con.begin(), it);
 }

◆ numNodes()

std::size_t PorousFlowConnectedNodes::numNodes ( ) const

number of nodes known by this class

Definition at line 31 of file PorousFlowConnectedNodes.C.

Referenced by PorousFlowAdvectiveFluxCalculatorBase::initialize(), PorousFlowAdvectiveFluxCalculatorBase::threadJoin(), AdvectiveFluxCalculatorBase::timestepSetup(), and PorousFlowAdvectiveFluxCalculatorBase::timestepSetup().

 {
   if (_still_adding_global_nodes)
     return _set_of_global_ids.size();
   return _global_id.size();
 }

◆ sequentialConnectionsToGlobalID()

const std::vector< dof_id_type > & PorousFlowConnectedNodes::sequentialConnectionsToGlobalID ( dof_id_type global_node_ID ) const

Return all the nodes (sequential node IDs) connected to the given global node ID All elements of the returned vector are guaranteed to be unique and lie in the range [0, numNodes() - 1].

Definition at line 123 of file PorousFlowConnectedNodes.C.

 {
   if (_still_adding_connections)
     mooseError("PorousFlowConnectedNodes: sequentialConnectionsToGlobalID called, but "
                "_still_adding_connections is true.  Probably you should have called "
                "finalizeAddingConnections.");
   return _sequential_neighbors[sequentialID(global_node_ID)];
 }

◆ sequentialConnectionsToSequentialID()

const std::vector< dof_id_type > & PorousFlowConnectedNodes::sequentialConnectionsToSequentialID ( dof_id_type sequential_node_ID ) const

Return all the nodes (sequential node IDs) connected to the given sequential node ID All elements of the returned vector are guaranteed to be unique and lie in the range [0, numNodes() - 1].

Definition at line 133 of file PorousFlowConnectedNodes.C.

Referenced by AdvectiveFluxCalculatorBase::finalize(), AdvectiveFluxCalculatorBase::initialize(), AdvectiveFluxCalculatorBase::PQPlusMinus(), AdvectiveFluxCalculatorBase::rMinus(), AdvectiveFluxCalculatorBase::rPlus(), AdvectiveFluxCalculatorBase::threadJoin(), and AdvectiveFluxCalculatorBase::timestepSetup().

 {
   if (_still_adding_connections)
     mooseError("PorousFlowConnectedNodes: sequentialConnectionsToSequentialID called, but "
                "_still_adding_connections is true.  Probably you should have called "
                "finalizeAddingConnections.");
   return _sequential_neighbors[sequential_node_ID];
 }

◆ sequentialID()

dof_id_type PorousFlowConnectedNodes::sequentialID ( dof_id_type global_node_ID ) const

Return the sequential node ID corresponding to the global node ID This is guaranteed to lie in the range [0, numNodes() - 1].

Parameters

global_node_ID global node ID (ie the node number in the mesh)

Definition at line 87 of file PorousFlowConnectedNodes.C.

 {
   if (_still_adding_global_nodes)
     mooseError("PorousFlowConnectedNodes: sequentialID called, but _still_adding_global_nodes is "
                "true.  Probably you should have called finalizeAddingGlobalNodes.");
   return _sequential_id[global_node_ID - _min_global_id];
 }

◆ sizeSequential()

std::size_t PorousFlowConnectedNodes::sizeSequential ( ) const

Return the size of _sequential_id, for checking memory efficiency.

The memory wasted by this class is (sizeSequential() - numNodes()) * (size of dof_id_type). finalizeAddingGlobalNodes() must have been called prior to calling this method

Definition at line 69 of file PorousFlowConnectedNodes.C.

Referenced by AdvectiveFluxCalculatorBase::timestepSetup().

 {
   if (_still_adding_global_nodes)
     mooseError("PorousFlowConnectedNodes: sizeSequential called, but _still_adding_global_nodes is "
                "true.  Probably you should have called finalizeAddingGlobalNodes.");
   return _sequential_id.size();
 }