Gedim::MeshMatrices Struct Reference

#include <MeshMatrices.hpp>

Public Attributes
unsigned int	Dimension = 0
	Geometric dimension.
unsigned int	NumberCell0D = 0
	number of Cell0D
std::vector< double >	Cell0DCoordinates = {}
	Cell0D coordinates, size 3 x NumberCell0D (x,y,z)
std::vector< unsigned int >	Cell0DMarkers = {}
	Cell0D markers, size 1 x NumberCell0D (marker)
std::vector< unsigned int >	NumberCell0DNeighbourCell1D = {0}
std::vector< unsigned int >	Cell0DNeighbourCell1Ds = {}
std::vector< unsigned int >	NumberCell0DNeighbourCell2D = {0}
std::vector< unsigned int >	Cell0DNeighbourCell2Ds = {}
std::vector< unsigned int >	NumberCell0DNeighbourCell3D = {0}
std::vector< unsigned int >	Cell0DNeighbourCell3Ds = {}
std::vector< bool >	ActiveCell0D = {}
	active Cell0D
std::unordered_map< unsigned int, std::unordered_set< unsigned int > >	UpdatedCell0Ds = {}
std::vector< std::string >	Cell0DDoublePropertyIds = {}
	Cell0D double property id - double property index.
std::unordered_map< std::string, unsigned int >	Cell0DDoublePropertyIndices = {}
std::vector< std::vector< unsigned int > >	Cell0DDoublePropertySizes = {}
	Cell0D double property sizes.
std::vector< std::vector< double > >	Cell0DDoublePropertyValues = {}
	Cell0D double property values.
unsigned int	NumberCell1D = 0
	number of Cell1D
std::vector< unsigned int >	Cell1DVertices = {}
	Cell1D vertices indices, size 2 x NumberCell1D (fromId,toId)
std::vector< unsigned int >	NumberCell1DNeighbourCell2D = {0}
std::vector< unsigned int >	NumberCell1DNeighbourCell3D = {0}
std::vector< unsigned int >	Cell1DNeighbourCell2Ds = {}
std::vector< unsigned int >	Cell1DNeighbourCell3Ds = {}
std::vector< unsigned int >	Cell1DMarkers = {}
	Cell1D propertoes, size 1 x NumberCell1D (marker)
std::vector< bool >	ActiveCell1D = {}
	active Cell1D
std::vector< unsigned int >	Cell1DOriginalCell1Ds = {}
std::unordered_map< unsigned int, std::unordered_set< unsigned int > >	UpdatedCell1Ds = {}
std::vector< std::string >	Cell1DDoublePropertyIds = {}
	Cell1D double property id - double property index.
std::unordered_map< std::string, unsigned int >	Cell1DDoublePropertyIndices = {}
std::vector< std::vector< unsigned int > >	Cell1DDoublePropertySizes = {}
	Cell1D double property sizes.
std::vector< std::vector< double > >	Cell1DDoublePropertyValues = {}
	Cell1D double property values.
unsigned int	NumberCell2D = 0
	number of Cell2D
std::vector< unsigned int >	NumberCell2DVertices = {0}
	number of Vertices per Cell2D, size 1 x NumberCell2D + 1
std::vector< unsigned int >	NumberCell2DEdges = {0}
	number of Edges per Cell2D, size 1 x NumberCell2D + 1
std::vector< unsigned int >	Cell2DVertices = {}
std::vector< unsigned int >	Cell2DEdges = {}
	Cell2D Cell1D indices, size 1 x NumberCell2DEdges[NumberCell2D].
std::vector< unsigned int >	NumberCell2DNeighbourCell3D = {0}
std::vector< unsigned int >	Cell2DNeighbourCell3Ds = {}
std::vector< unsigned int >	Cell2DMarkers = {}
	Cell2D markers, size 1 x NumberCell2D (marker)
std::vector< bool >	ActiveCell2D = {}
	active Cell2D
std::vector< unsigned int >	NumberCell2DSubdivision = {0}
std::vector< unsigned int >	Cell2DSubdivision = {}
std::vector< unsigned int >	Cell2DOriginalCell2Ds = {}
std::unordered_map< unsigned int, std::unordered_set< unsigned int > >	UpdatedCell2Ds = {}
std::vector< std::string >	Cell2DDoublePropertyIds = {}
	Cell2D double property id - double property index.
std::unordered_map< std::string, unsigned int >	Cell2DDoublePropertyIndices = {}
std::vector< std::vector< unsigned int > >	Cell2DDoublePropertySizes = {}
	Cell2D double property sizes.
std::vector< std::vector< double > >	Cell2DDoublePropertyValues = {}
	Cell2D double property values.
unsigned int	NumberCell3D = 0
	number of Cell3D
std::vector< unsigned int >	NumberCell3DVertices = {0}
	number of Vertices per Cell3D, size 1 x NumberCell3D + 1
std::vector< unsigned int >	NumberCell3DEdges = {0}
	number of Edges per Cell3D, size 1 x NumberCell3D + 1
std::vector< unsigned int >	NumberCell3DFaces = {0}
	number of Faces per Cell3D, size 1 x NumberCell3D + 1
std::vector< unsigned int >	Cell3DVertices = {}
std::vector< unsigned int >	Cell3DEdges = {}
	Cell3D Cell1D indices, size 1 x NumberCell3DEdges[NumberCell3D].
std::vector< unsigned int >	Cell3DFaces = {}
	Cell3D Cell2D indices, size 1 x NumberCell3DFaces[NumberCell3D].
std::vector< unsigned int >	Cell3DMarkers = {}
	Cell3D markers, size 1 x NumberCell3D (marker)
std::vector< bool >	ActiveCell3D = {}
	active Cell3D
std::vector< unsigned int >	Cell3DOriginalCell3Ds = {}
std::unordered_map< unsigned int, std::unordered_set< unsigned int > >	UpdatedCell3Ds = {}
std::vector< std::string >	Cell3DDoublePropertyIds = {}
	Cell3D double property id - double property index.
std::unordered_map< std::string, unsigned int >	Cell3DDoublePropertyIndices = {}
std::vector< std::vector< unsigned int > >	Cell3DDoublePropertySizes = {}
	Cell3D double property sizes.
std::vector< std::vector< double > >	Cell3DDoublePropertyValues = {}
	Cell3D double property values.

Member Data Documentation

ActiveCell0D

std::vector<bool> Gedim::MeshMatrices::ActiveCell0D = {}

active Cell0D

ActiveCell1D

std::vector<bool> Gedim::MeshMatrices::ActiveCell1D = {}

active Cell1D

ActiveCell2D

std::vector<bool> Gedim::MeshMatrices::ActiveCell2D = {}

active Cell2D

ActiveCell3D

std::vector<bool> Gedim::MeshMatrices::ActiveCell3D = {}

active Cell3D

Cell0DCoordinates

std::vector<double> Gedim::MeshMatrices::Cell0DCoordinates = {}

Cell0D coordinates, size 3 x NumberCell0D (x,y,z)

Cell0DDoublePropertyIds

std::vector<std::string> Gedim::MeshMatrices::Cell0DDoublePropertyIds = {}

Cell0D double property id - double property index.

Cell0DDoublePropertyIndices

std::unordered_map<std::string, unsigned int> Gedim::MeshMatrices::Cell0DDoublePropertyIndices = {}

Cell0D double property id - double property index

Cell0DDoublePropertySizes

std::vector<std::vector<unsigned int> > Gedim::MeshMatrices::Cell0DDoublePropertySizes = {}

Cell0D double property sizes.

Cell0DDoublePropertyValues

std::vector<std::vector<double> > Gedim::MeshMatrices::Cell0DDoublePropertyValues = {}

Cell0D double property values.

Cell0DMarkers

std::vector<unsigned int> Gedim::MeshMatrices::Cell0DMarkers = {}

Cell0D markers, size 1 x NumberCell0D (marker)

Cell0DNeighbourCell1Ds

std::vector<unsigned int> Gedim::MeshMatrices::Cell0DNeighbourCell1Ds = {}

Cell0D neighbour Cell1D indices, size 1 x NumberCell0DNeighbourCell1D[NumberCell0D]

Cell0DNeighbourCell2Ds

std::vector<unsigned int> Gedim::MeshMatrices::Cell0DNeighbourCell2Ds = {}

Cell0D neighbour Cell2D indices, size 1 x NumberCell0DNeighbourCell2D[NumberCell0D]

Cell0DNeighbourCell3Ds

std::vector<unsigned int> Gedim::MeshMatrices::Cell0DNeighbourCell3Ds = {}

Cell0D neighbour Cell3D indices, size 1 x NumberCell0DNeighbourCell3D[NumberCell0D]

Cell1DDoublePropertyIds

std::vector<std::string> Gedim::MeshMatrices::Cell1DDoublePropertyIds = {}

Cell1D double property id - double property index.

Cell1DDoublePropertyIndices

std::unordered_map<std::string, unsigned int> Gedim::MeshMatrices::Cell1DDoublePropertyIndices = {}

Cell1D double property id - double property index

Cell1DDoublePropertySizes

std::vector<std::vector<unsigned int> > Gedim::MeshMatrices::Cell1DDoublePropertySizes = {}

Cell1D double property sizes.

Cell1DDoublePropertyValues

std::vector<std::vector<double> > Gedim::MeshMatrices::Cell1DDoublePropertyValues = {}

Cell1D double property values.

Cell1DMarkers

std::vector<unsigned int> Gedim::MeshMatrices::Cell1DMarkers = {}

Cell1D propertoes, size 1 x NumberCell1D (marker)

Cell1DNeighbourCell2Ds

std::vector<unsigned int> Gedim::MeshMatrices::Cell1DNeighbourCell2Ds = {}

Cell1D neighbour Cell2D indices, size 1 x NumberCell1DNeighbourCell2D[NumberCell1D]

Cell1DNeighbourCell3Ds

std::vector<unsigned int> Gedim::MeshMatrices::Cell1DNeighbourCell3Ds = {}

Cell1D neighbour Cell3D indices, size 1 x NumberCell1DNeighbourCell3D[NumberCell1D]

Cell1DOriginalCell1Ds

std::vector<unsigned int> Gedim::MeshMatrices::Cell1DOriginalCell1Ds = {}

for each cell1D the index of original cell1D, NumberCell1D is the default value (no original cell), size 1 x NumberCell1D

Cell1DVertices

std::vector<unsigned int> Gedim::MeshMatrices::Cell1DVertices = {}

Cell1D vertices indices, size 2 x NumberCell1D (fromId,toId)

Cell2DDoublePropertyIds

std::vector<std::string> Gedim::MeshMatrices::Cell2DDoublePropertyIds = {}

Cell2D double property id - double property index.

Cell2DDoublePropertyIndices

std::unordered_map<std::string, unsigned int> Gedim::MeshMatrices::Cell2DDoublePropertyIndices = {}

Cell2D double property id - double property index

Cell2DDoublePropertySizes

std::vector<std::vector<unsigned int> > Gedim::MeshMatrices::Cell2DDoublePropertySizes = {}

Cell2D double property sizes.

Cell2DDoublePropertyValues

std::vector<std::vector<double> > Gedim::MeshMatrices::Cell2DDoublePropertyValues = {}

Cell2D double property values.

Cell2DEdges

std::vector<unsigned int> Gedim::MeshMatrices::Cell2DEdges = {}

Cell2D Cell1D indices, size 1 x NumberCell2DEdges[NumberCell2D].

Cell2DMarkers

std::vector<unsigned int> Gedim::MeshMatrices::Cell2DMarkers = {}

Cell2D markers, size 1 x NumberCell2D (marker)

Cell2DNeighbourCell3Ds

std::vector<unsigned int> Gedim::MeshMatrices::Cell2DNeighbourCell3Ds = {}

Cell2D neighbour Cell3D indices, size 1 x NumberCell2DNeighbourCell3D[NumberCell2D]

Cell2DOriginalCell2Ds

std::vector<unsigned int> Gedim::MeshMatrices::Cell2DOriginalCell2Ds = {}

for each cell2D the index of original cell2D, NumberCell2D is the default value (no original cell), size 1 x NumberCell2D

Cell2DSubdivision

std::vector<unsigned int> Gedim::MeshMatrices::Cell2DSubdivision = {}

Sub-division of Cell2Ds, used for Concave polygons, size 1 x NumberCell2DSubdivision[NumberCell2D]

Cell2DVertices

std::vector<unsigned int> Gedim::MeshMatrices::Cell2DVertices = {}

Cell2D Vertices indices, size 1 x NumberCell2DVertices[NumberCell2D]

Cell3DDoublePropertyIds

std::vector<std::string> Gedim::MeshMatrices::Cell3DDoublePropertyIds = {}

Cell3D double property id - double property index.

Cell3DDoublePropertyIndices

std::unordered_map<std::string, unsigned int> Gedim::MeshMatrices::Cell3DDoublePropertyIndices = {}

Cell3D double property id - double property index

Cell3DDoublePropertySizes

std::vector<std::vector<unsigned int> > Gedim::MeshMatrices::Cell3DDoublePropertySizes = {}

Cell3D double property sizes.

Cell3DDoublePropertyValues

std::vector<std::vector<double> > Gedim::MeshMatrices::Cell3DDoublePropertyValues = {}

Cell3D double property values.

Cell3DEdges

std::vector<unsigned int> Gedim::MeshMatrices::Cell3DEdges = {}

Cell3D Cell1D indices, size 1 x NumberCell3DEdges[NumberCell3D].

Cell3DFaces

std::vector<unsigned int> Gedim::MeshMatrices::Cell3DFaces = {}

Cell3D Cell2D indices, size 1 x NumberCell3DFaces[NumberCell3D].

Cell3DMarkers

std::vector<unsigned int> Gedim::MeshMatrices::Cell3DMarkers = {}

Cell3D markers, size 1 x NumberCell3D (marker)

Cell3DOriginalCell3Ds

std::vector<unsigned int> Gedim::MeshMatrices::Cell3DOriginalCell3Ds = {}

for each cell3D the index of original cell3D, NumberCell3D is the default value (no original cell), size 1 x NumberCell3D

Cell3DVertices

std::vector<unsigned int> Gedim::MeshMatrices::Cell3DVertices = {}

Cell3D Cell0D indices, size 1 x NumberCell3DVertices[NumberCell3D]

Dimension

unsigned int Gedim::MeshMatrices::Dimension = 0

Geometric dimension.

NumberCell0D

unsigned int Gedim::MeshMatrices::NumberCell0D = 0

number of Cell0D

NumberCell0DNeighbourCell1D

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell0DNeighbourCell1D = {0}

Cell0D neighbour Cell1D indices per cell, size 1 x NumberCell0D + 1

NumberCell0DNeighbourCell2D

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell0DNeighbourCell2D = {0}

Cell0D neighbour Cell2D indices per cell, size 1 x NumberCell0D + 1

NumberCell0DNeighbourCell3D

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell0DNeighbourCell3D = {0}

Cell0D neighbour Cell2D indices per cell, size 1 x NumberCell0D + 1

NumberCell1D

unsigned int Gedim::MeshMatrices::NumberCell1D = 0

number of Cell1D

NumberCell1DNeighbourCell2D

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell1DNeighbourCell2D = {0}

Cell1D neighbour Cell2D indices per cell, size 1 x NumberCell1D + 1

NumberCell1DNeighbourCell3D

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell1DNeighbourCell3D = {0}

Cell1D neighbour Cell3D indices per cell, size 1 x NumberCell1D + 1

NumberCell2D

unsigned int Gedim::MeshMatrices::NumberCell2D = 0

number of Cell2D

NumberCell2DEdges

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell2DEdges = {0}

number of Edges per Cell2D, size 1 x NumberCell2D + 1

NumberCell2DNeighbourCell3D

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell2DNeighbourCell3D = {0}

Cell2D neighbour Cell3D indices per cell, size 1 x NumberCell2D + 1

NumberCell2DSubdivision

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell2DSubdivision = {0}

number of sub-division per Cell2D, size 1 x NumberCell2D + 1

NumberCell2DVertices

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell2DVertices = {0}

number of Vertices per Cell2D, size 1 x NumberCell2D + 1

NumberCell3D

unsigned int Gedim::MeshMatrices::NumberCell3D = 0

number of Cell3D

NumberCell3DEdges

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell3DEdges = {0}

number of Edges per Cell3D, size 1 x NumberCell3D + 1

NumberCell3DFaces

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell3DFaces = {0}

number of Faces per Cell3D, size 1 x NumberCell3D + 1

NumberCell3DVertices

std::vector<unsigned int> Gedim::MeshMatrices::NumberCell3DVertices = {0}

number of Vertices per Cell3D, size 1 x NumberCell3D + 1

UpdatedCell0Ds

std::unordered_map<unsigned int, std::unordered_set<unsigned int> > Gedim::MeshMatrices::UpdatedCell0Ds = {}

for each cell0D the list to the new cell0Ds

UpdatedCell1Ds

std::unordered_map<unsigned int, std::unordered_set<unsigned int> > Gedim::MeshMatrices::UpdatedCell1Ds = {}

for each cell1D the list to the new cell1Ds

UpdatedCell2Ds

std::unordered_map<unsigned int, std::unordered_set<unsigned int> > Gedim::MeshMatrices::UpdatedCell2Ds = {}

for each cell2D the list to the new cell2Ds

UpdatedCell3Ds

std::unordered_map<unsigned int, std::unordered_set<unsigned int> > Gedim::MeshMatrices::UpdatedCell3Ds = {}

for each cell3D the list to the new cell3Ds

---

The documentation for this struct was generated from the following file:

• MeshMatrices.hpp