#include <SMDS_Downward.hxx>

Inheritance diagram for SMDS_DownEdge:

Public Member Functions
virtual int	getNumberOfUpCells (int cellId)
virtual const int *	getUpCells (int cellId)
virtual const unsigned char *	getUpTypes (int cellId)
virtual void	getNodeIds (int cellId, std::set< int > &nodeSet)
virtual int	getNodes (int cellId, int *nodevec)
virtual int	getNumberOfDownCells (int cellId)
	Get the number of downward entities associated to a cell (always the same for a given vtk type of cell)
virtual const int *	getDownCells (int cellId)
	get a pointer on the downward entities id's associated to a cell.
virtual const unsigned char *	getDownTypes (int cellId)
	get a list of vtk cell types associated to downward entities of a given cell, in the same order than the downward entities id's list (
int	getVtkCellId (int cellId)
int	getMaxId ()
Static Public Member Functions
static int	getCellDimension (unsigned char cellType)
	get the dimension of a cell (1,2,3 for 1D, 2D 3D) given the vtk cell type
Protected Member Functions
	SMDS_DownEdge (SMDS_UnstructuredGrid *grid)
	~SMDS_DownEdge ()
virtual void	initCell (int cellId)
	clear vectors used to reference 2D cells containing the edge
virtual void	allocate (int nbElems)
	Resize the downward connectivity storage vector if needed.
virtual void	compactStorage ()
virtual void	addUpCell (int cellId, int upCellId, unsigned char aType)
	Id's are downward connectivity id's.
virtual int	getNodeSet (int cellId, int *nodeSet)
void	setNodes (int cellId, int vtkId)
void	setNodes (int cellId, const int *nodeIds)
int	computeVtkCells (int cellId, std::vector< int > &vtkIds)
	Build the list of vtkUnstructuredGrid cells containing the edge.
int	computeVtkCells (int *pts, std::vector< int > &vtkIds)
	Build the list of vtkUnstructuredGrid cells containing the edge.
int	computeFaces (int cellId, int vtkIds, int nbcells, int downFaces, unsigned char *downTypes)
	Build the list of downward faces from a list of vtk cells.
int	computeFaces (int pts, int vtkIds, int nbcells, int downFaces, unsigned char downTypes)
	Build the list of downward faces from a list of vtk cells.
int	addCell (int vtkId=-1)
	Give or create an entry for downward connectivity structure relative to a cell.
virtual void	addDownCell (int cellId, int lowCellId, unsigned char aType)
	Id's are downward connectivity id's.
Protected Attributes
std::vector< std::vector< int > >	_upCellIdsVector
	the number of faces sharing an edge is not known
std::vector< std::vector < unsigned char > >	_upCellTypesVector
	the number of faces sharing an edge is not known
std::vector< int >	_upCellIds
	compacted storage after connectivity calculation
std::vector< unsigned char >	_upCellTypes
	compacted storage after connectivity calculation
std::vector< int >	_upCellIndex
	compacted storage after connectivity calculation
SMDS_UnstructuredGrid *	_grid
int	_maxId
int	_nbDownCells
	the same number for all cells of a derived class
std::vector< int >	_cellIds
	growing size: all the down cell id's, size = _maxId * _nbDownCells
std::vector< int >	_vtkCellIds
	growing size: size = _maxId, either vtkId or -1
std::vector< unsigned char >	_cellTypes
	fixed size: the same vector for all cells of a derived class
Static Protected Attributes
static std::vector< int >	_cellDimension
	conversion table: type --> dimension
Friends
class	SMDS_UnstructuredGrid

Detailed Description

Definition at line 191 of file SMDS_Downward.hxx.

Constructor & Destructor Documentation

SMDS_DownEdge::SMDS_DownEdge ( SMDS_UnstructuredGrid * grid ) [protected]

Definition at line 857 of file SMDS_Downward.cxx.

References SMDS_Downward._cellTypes.

                                                        :
  SMDS_Down1D(grid, 2)
{
  _cellTypes.push_back(VTK_VERTEX);
  _cellTypes.push_back(VTK_VERTEX);
}

SMDS_DownEdge::~SMDS_DownEdge ( ) [protected]

Definition at line 864 of file SMDS_Downward.cxx.

{
}

Member Function Documentation

int SMDS_Downward::addCell ( int vtkId = -1 ) [protected, inherited]

Give or create an entry for downward connectivity structure relative to a cell.

If the entry already exists, just return its id, otherwise, create it. The internal storage memory is allocated if needed. The SMDS_UnstructuredGrid._cellIdToDownId vector is completed for vtkUnstructuredGrid cells.

Parameters:

vtkId for a vtkUnstructuredGrid cell or -1 (default) for a created downward cell.

Returns:: the rank in downward[vtkType] structure.

Definition at line 112 of file SMDS_Downward.cxx.

References SMDS_Downward._grid, SMDS_Downward._maxId, SMDS_Downward._vtkCellIds, SMDS_Downward.allocate(), SMDS_UnstructuredGrid.CellIdToDownId(), SMDS_Downward.initCell(), and SMDS_UnstructuredGrid.setCellIdToDownId().

{
  int localId = -1;
  if (vtkId >= 0)
    localId = _grid->CellIdToDownId(vtkId);
  if (localId >= 0)
    return localId;

  localId = this->_maxId;
  this->_maxId++;
  this->allocate(_maxId);
  if (vtkId >= 0)
    {
      this->_vtkCellIds[localId] = vtkId;
      _grid->setCellIdToDownId(vtkId, localId);
    }
  this->initCell(localId);
  return localId;
}

void SMDS_Downward::addDownCell	(	int	cellId,
		int	lowCellId,
		unsigned char	aType
	)		`[protected, virtual, inherited]`

Id's are downward connectivity id's.

add a downward entity of dimension n-1 (cell or node) to a given cell.

Actual implementation is done in derived methods.

Parameters:

cellId	index of the parent cell (dimension n) in the downward structure relative to a vtk cell type.
lowCellId	index of the children cell to add (dimension n-1)
aType	vtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add).

Reimplemented in SMDS_DownTriangle, SMDS_DownQuadTriangle, SMDS_DownQuadrangle, SMDS_DownQuadQuadrangle, SMDS_DownTetra, SMDS_DownQuadTetra, SMDS_DownPyramid, SMDS_DownQuadPyramid, SMDS_DownPenta, SMDS_DownQuadPenta, SMDS_DownHexa, and SMDS_DownQuadHexa.

Definition at line 179 of file SMDS_Downward.cxx.

{
  ASSERT(0); // must be re-implemented in derived class
}

void SMDS_Down1D::addUpCell	(	int	cellId,
		int	upCellId,
		unsigned char	aType
	)		`[protected, virtual, inherited]`

Id's are downward connectivity id's.

Reimplemented from SMDS_Downward.

Definition at line 269 of file SMDS_Downward.cxx.

References SMDS_Down1D._upCellIdsVector, and SMDS_Down1D._upCellTypesVector.

{
  //ASSERT((cellId >=0) && (cellId < _maxId));
  int nbFaces = _upCellIdsVector[cellId].size();
  for (int i = 0; i < nbFaces; i++)
    {
      if ((_upCellIdsVector[cellId][i] == upCellId) && (_upCellTypesVector[cellId][i] == aType))
        {
          return; // already done
        }
    }
  _upCellIdsVector[cellId].push_back(upCellId);
  _upCellTypesVector[cellId].push_back(aType);
}

void SMDS_Down1D::allocate ( int nbElems ) [protected, virtual, inherited]

Resize the downward connectivity storage vector if needed.

Parameters:

nbElems total number of elements of the same type required

Implements SMDS_Downward.

Definition at line 230 of file SMDS_Downward.cxx.

References SMDS_Downward._cellIds, SMDS_Downward._nbDownCells, SMDS_Down1D._upCellIdsVector, SMDS_Down1D._upCellTypesVector, SMDS_Downward._vtkCellIds, and SMDS_Mesh.chunkSize.

{
  if (nbElems >= _vtkCellIds.size())
    {
      _vtkCellIds.resize(nbElems + SMDS_Mesh::chunkSize, -1);
      _cellIds.resize(_nbDownCells * (nbElems + SMDS_Mesh::chunkSize), -1);
      _upCellIdsVector.resize(nbElems + SMDS_Mesh::chunkSize);
      _upCellTypesVector.resize(nbElems + SMDS_Mesh::chunkSize);
    }
}

void SMDS_Down1D::compactStorage ( ) [protected, virtual, inherited]

Implements SMDS_Downward.

Definition at line 241 of file SMDS_Downward.cxx.

References SMDS_Downward._cellIds, SMDS_Downward._maxId, SMDS_Downward._nbDownCells, SMDS_Down1D._upCellIds, SMDS_Down1D._upCellIdsVector, SMDS_Down1D._upCellIndex, SMDS_Down1D._upCellTypes, SMDS_Down1D._upCellTypesVector, SMDS_Downward._vtkCellIds, and ex21_lamp.size.

{
  _cellIds.resize(_nbDownCells * _maxId);
  _vtkCellIds.resize(_maxId);

  int sizeUpCells = 0;
  for (int i = 0; i < _maxId; i++)
    sizeUpCells += _upCellIdsVector[i].size();
  _upCellIds.resize(sizeUpCells, -1);
  _upCellTypes.resize(sizeUpCells);
  _upCellIndex.resize(_maxId + 1, -1); // id and types of rank i correspond to [ _upCellIndex[i], _upCellIndex[i+1] [
  int current = 0;
  for (int i = 0; i < _maxId; i++)
    {
      _upCellIndex[i] = current;
      for (int j = 0; j < _upCellIdsVector[i].size(); j++)
        {
          _upCellIds[current] = _upCellIdsVector[i][j];
          _upCellTypes[current] = _upCellTypesVector[i][j];
          current++;
        }
    }
  _upCellIndex[_maxId] = current;

  _upCellIdsVector.clear();
  _upCellTypesVector.clear();
}

int SMDS_Down1D::computeFaces	(	int *	pts,
		int *	vtkIds,
		int	nbcells,
		int *	downFaces,
		unsigned char *	downTypes
	)		`[protected, inherited]`

Build the list of downward faces from a list of vtk cells.

Parameters:

pts	list of points id's defining an edge
vtkIds	vector of vtk id's
downFaces	vector of face id's in downward structures
downTypes	vector of face types

Returns:: number of downward faces

Definition at line 439 of file SMDS_Downward.cxx.

References SMDS_Downward._grid, SMDS_Downward._nbDownCells, SMDS_UnstructuredGrid.CellIdToDownId(), SMDS_Downward.getCellDimension(), SMDS_UnstructuredGrid.getDownArray(), SMDS_Downward.getDownCells(), SMDS_Downward.getDownTypes(), SMDS_Downward.getNumberOfDownCells(), and SMDS_Down2D.isInFace().

{
  int cnt = 0;
  for (int i = 0; i < nbcells; i++)
    {
      int vtkId = vtkIds[i];
      int vtkType = _grid->GetCellType(vtkId);
      if (SMDS_Downward::getCellDimension(vtkType) == 2)
        {
          int faceId = _grid->CellIdToDownId(vtkId);
          downFaces[cnt] = faceId;
          downTypes[cnt] = vtkType;
          cnt++;
        }
      else if (SMDS_Downward::getCellDimension(vtkType) == 3)
        {
          int volId = _grid->CellIdToDownId(vtkId);
          SMDS_Downward * downvol = _grid->getDownArray(vtkType);
          //const int *downIds = downvol->getDownCells(volId);
          const unsigned char* downTypesVol = downvol->getDownTypes(volId);
          int nbFaces = downvol->getNumberOfDownCells(volId);
          const int* faceIds = downvol->getDownCells(volId);
          for (int n = 0; n < nbFaces; n++)
            {
              SMDS_Down2D *downFace = static_cast<SMDS_Down2D*> (_grid->getDownArray(downTypesVol[n]));
              bool isInFace = downFace->isInFace(faceIds[n], pts, _nbDownCells);
              if (isInFace)
                {
                  bool alreadySet = false;
                  for (int k = 0; k < cnt; k++)
                    if (faceIds[n] == downFaces[k])
                      {
                        alreadySet = true;
                        break;
                      }
                  if (!alreadySet)
                    {
                      downFaces[cnt] = faceIds[n];
                      downTypes[cnt] = downTypesVol[n];
                      cnt++;
                    }
                }
            }
        }
    }
  return cnt;
}

int SMDS_Down1D::computeFaces	(	int	cellId,
		int *	vtkIds,
		int	nbcells,
		int *	downFaces,
		unsigned char *	downTypes
	)		`[protected, inherited]`

Build the list of downward faces from a list of vtk cells.

Parameters:

cellId	id of the edge in the downward structure
vtkIds	vector of vtk id's
downFaces	vector of face id's in downward structures
downTypes	vector of face types

Returns:: number of downward faces

Definition at line 424 of file SMDS_Downward.cxx.

References SMDS_Downward._cellIds, and SMDS_Downward._nbDownCells.

Referenced by SMDS_UnstructuredGrid.BuildDownwardConnectivity().

{
  int *pts = &_cellIds[_nbDownCells * cellId];
  int nbFaces = this->computeFaces(pts, vtkIds, nbcells, downFaces, downTypes);
  return nbFaces;
}

int SMDS_Down1D::computeVtkCells	(	int	cellId,
		std::vector< int > &	vtkIds
	)		`[protected, inherited]`

Build the list of vtkUnstructuredGrid cells containing the edge.

We keep in the list the cells that contains all the nodes, we keep only volumes and faces.

Parameters:

cellId	id of the edge in the downward structure
vtkIds	vector of vtk id's

Returns:: number of vtk cells (size of vector)

Definition at line 343 of file SMDS_Downward.cxx.

References SMDS_Downward._cellIds, and SMDS_Downward._nbDownCells.

Referenced by SMDS_UnstructuredGrid.BuildDownwardConnectivity().

{
  vtkIds.clear();

  // --- find all the cells the points belong to, and how many of the points belong to a given cell

  int *pts = &_cellIds[_nbDownCells * cellId];
  int ncells = this->computeVtkCells(pts, vtkIds);
  return ncells;
}

int SMDS_Down1D::computeVtkCells	(	int *	pts,
		std::vector< int > &	vtkIds
	)		`[protected, inherited]`

Build the list of vtkUnstructuredGrid cells containing the edge.

Parameters:

pts	list of points id's defining an edge
vtkIds	vector of vtk id's

Returns:: number of vtk cells (size of vector)

Definition at line 360 of file SMDS_Downward.cxx.

References SMDS_Downward._grid, SMDS_Downward._nbDownCells, SMDS_Downward.getCellDimension(), SMDS_UnstructuredGrid.GetLinks(), and SMESH_mechanic_editor.point.

{

  // --- find all the cells the points belong to, and how many of the points belong to a given cell

  int cellIds[1000];
  int cellCnt[1000];
  int cnt = 0;
  for (int i = 0; i < _nbDownCells; i++)
    {
      vtkIdType point = pts[i];
      int numCells = _grid->GetLinks()->GetNcells(point);
      vtkIdType *cells = _grid->GetLinks()->GetCells(point);
      for (int j = 0; j < numCells; j++)
        {
          int vtkCellId = cells[j];
          bool found = false;
          for (int k = 0; k < cnt; k++)
            {
              if (cellIds[k] == vtkCellId)
                {
                  cellCnt[k] += 1;
                  found = true;
                  break;
                }
            }
          if (!found)
            {
              cellIds[cnt] = vtkCellId;
              cellCnt[cnt] = 1;
              // TODO ASSERT(cnt<1000);
              cnt++;
            }
        }
    }

  // --- find the face and volume cells: they contains all the points and are of type volume or face

  int ncells = 0;
  for (int i = 0; i < cnt; i++)
    {
      if (cellCnt[i] == _nbDownCells)
        {
          int vtkElemId = cellIds[i];
          int vtkType = _grid->GetCellType(vtkElemId);
          if (SMDS_Downward::getCellDimension(vtkType) > 1)
            {
              vtkIds.push_back(vtkElemId);
              ncells++;
            }
        }
    }

  return ncells;
}

int SMDS_Downward::getCellDimension ( unsigned char cellType ) [static, inherited]

get the dimension of a cell (1,2,3 for 1D, 2D 3D) given the vtk cell type

Parameters:

cellType vtk cell type

See also:: vtkCellType.h

Returns:: 1,2 or 3

Definition at line 44 of file SMDS_Downward.cxx.

References VTK_MAXTYPE.

Referenced by SMDS_UnstructuredGrid.BuildDownwardConnectivity(), SMDS_Down1D.computeFaces(), SMDS_Down2D.computeVolumeIdsFromNodesFace(), SMDS_Down1D.computeVtkCells(), SMDS_UnstructuredGrid.GetNeighbors(), SMDS_UnstructuredGrid.getOrderedNodesOfFace(), and SMDS_UnstructuredGrid.GetParentVolumes().

{
  if (_cellDimension.empty())
    {
      _cellDimension.resize(VTK_MAXTYPE + 1, 0);
      _cellDimension[VTK_LINE] = 1;
      _cellDimension[VTK_QUADRATIC_EDGE] = 1;
      _cellDimension[VTK_TRIANGLE] = 2;
      _cellDimension[VTK_QUADRATIC_TRIANGLE] = 2;
      _cellDimension[VTK_QUAD] = 2;
      _cellDimension[VTK_QUADRATIC_QUAD] = 2;
      _cellDimension[VTK_TETRA] = 3;
      _cellDimension[VTK_QUADRATIC_TETRA] = 3;
      _cellDimension[VTK_HEXAHEDRON] = 3;
      _cellDimension[VTK_QUADRATIC_HEXAHEDRON] = 3;
      _cellDimension[VTK_WEDGE] = 3;
      _cellDimension[VTK_QUADRATIC_WEDGE] = 3;
      _cellDimension[VTK_PYRAMID] = 3;
      _cellDimension[VTK_QUADRATIC_PYRAMID] = 3;
    }
  return _cellDimension[cellType];
}

const int * SMDS_Downward::getDownCells ( int cellId ) [virtual, inherited]

get a pointer on the downward entities id's associated to a cell.

See also:: SMDS_Downward.getNumberOfDownCells for the number of downward entities.; SMDS_Downward.getDownTypes for the vtk cell types associated to the downward entities.

Parameters:

cellId index of the cell in the downward structure relative to a given vtk cell type.

Returns:: table of downward entities id's.

Definition at line 156 of file SMDS_Downward.cxx.

References SMDS_Downward._cellIds, and SMDS_Downward._nbDownCells.

Referenced by SMDS_Down1D.computeFaces(), and SMESH_MeshEditor.DoubleNodesOnGroupBoundaries().

{
  //ASSERT((cellId >=0) && (cellId < _maxId));
  return &_cellIds[_nbDownCells * cellId];
}

const unsigned char * SMDS_Downward::getDownTypes ( int cellId ) [virtual, inherited]

get a list of vtk cell types associated to downward entities of a given cell, in the same order than the downward entities id's list (

See also:: SMDS_Downward.getDownCells).

Parameters:

cellId index of the cell in the downward structure relative to a vtk cell type.

Returns:: table of downward entities types.

Definition at line 168 of file SMDS_Downward.cxx.

References SMDS_Downward._cellTypes.

Referenced by SMDS_Down1D.computeFaces(), and SMESH_MeshEditor.DoubleNodesOnGroupBoundaries().

{
  return &_cellTypes[0];
}

int SMDS_Downward.getMaxId ( ) [inherited]

Definition at line 85 of file SMDS_Downward.hxx.

References SMDS_Downward._maxId.

Referenced by SMDS_UnstructuredGrid.BuildDownwardConnectivity().

  {
    return _maxId;
  }

void SMDS_Down1D::getNodeIds	(	int	cellId,
		std::set< int > &	nodeSet
	)		`[virtual, inherited]`

Implements SMDS_Downward.

Definition at line 302 of file SMDS_Downward.cxx.

References SMDS_Downward._cellIds, and SMDS_Downward._nbDownCells.

{
  for (int i = 0; i < _nbDownCells; i++)
    nodeSet.insert(_cellIds[_nbDownCells * cellId + i]);
}

virtual int SMDS_Down1D.getNodes	(	int	cellId,
		int *	nodevec
	)		`[virtual, inherited]`

Reimplemented from SMDS_Downward.

Definition at line 119 of file SMDS_Downward.hxx.

References SMDS_Down1D.getNodeSet().

{ return getNodeSet(cellId, nodevec); }

int SMDS_Down1D::getNodeSet	(	int	cellId,
		int *	nodeSet
	)		`[protected, virtual, inherited]`

Reimplemented from SMDS_Downward.

Definition at line 308 of file SMDS_Downward.cxx.

References SMDS_Downward._cellIds, and SMDS_Downward._nbDownCells.

Referenced by SMDS_Down1D.getNodes().

{
  for (int i = 0; i < _nbDownCells; i++)
    nodeSet[i] = _cellIds[_nbDownCells * cellId + i];
  return _nbDownCells;
}

int SMDS_Downward::getNumberOfDownCells ( int cellId ) [virtual, inherited]

Get the number of downward entities associated to a cell (always the same for a given vtk type of cell)

Parameters:

cellId not used here.

Returns:

Definition at line 145 of file SMDS_Downward.cxx.

References SMDS_Downward._nbDownCells.

Referenced by SMDS_Down1D.computeFaces(), and SMESH_MeshEditor.DoubleNodesOnGroupBoundaries().

{
  return _nbDownCells;
}

int SMDS_Down1D::getNumberOfUpCells ( int cellId ) [virtual, inherited]

Implements SMDS_Downward.

Definition at line 284 of file SMDS_Downward.cxx.

References SMDS_Down1D._upCellIndex.

{
  //ASSERT((cellId >=0) && (cellId < _maxId));
  return _upCellIndex[cellId + 1] - _upCellIndex[cellId];
}

const int * SMDS_Down1D::getUpCells ( int cellId ) [virtual, inherited]

Implements SMDS_Downward.

Definition at line 290 of file SMDS_Downward.cxx.

References SMDS_Down1D._upCellIds, and SMDS_Down1D._upCellIndex.

{
  //ASSERT((cellId >=0) && (cellId < _maxId));
  return &_upCellIds[_upCellIndex[cellId]];
}

const unsigned char * SMDS_Down1D::getUpTypes ( int cellId ) [virtual, inherited]

Implements SMDS_Downward.

Definition at line 296 of file SMDS_Downward.cxx.

References SMDS_Down1D._upCellIndex, and SMDS_Down1D._upCellTypes.

{
  //ASSERT((cellId >=0) && (cellId < _maxId));
  return &_upCellTypes[_upCellIndex[cellId]];
}

int SMDS_Downward.getVtkCellId ( int cellId ) [inherited]

Definition at line 81 of file SMDS_Downward.hxx.

References SMDS_Downward._vtkCellIds.

  {
    return _vtkCellIds[cellId];
  }

void SMDS_Down1D::initCell ( int cellId ) [protected, virtual, inherited]

clear vectors used to reference 2D cells containing the edge

Parameters:

cellId

Reimplemented from SMDS_Downward.

Definition at line 220 of file SMDS_Downward.cxx.

References SMDS_Down1D._upCellIdsVector, and SMDS_Down1D._upCellTypesVector.

{
  _upCellIdsVector[cellId].clear();
  _upCellTypesVector[cellId].clear();
}

void SMDS_Down1D::setNodes	(	int	cellId,
		const int *	nodeIds
	)		`[protected, inherited]`

Definition at line 328 of file SMDS_Downward.cxx.

References SMDS_Downward._cellIds, and SMDS_Downward._nbDownCells.

{
  //ASSERT(nodeIds.size() == _nbDownCells);
  for (int i = 0; i < _nbDownCells; i++)
    {
      _cellIds[_nbDownCells * cellId + i] = nodeIds[i];
    }
}

void SMDS_Down1D::setNodes	(	int	cellId,
		int	vtkId
	)		`[protected, inherited]`

Definition at line 315 of file SMDS_Downward.cxx.

References SMDS_Downward._cellIds, SMDS_Downward._grid, and SMDS_Downward._nbDownCells.

Referenced by SMDS_UnstructuredGrid.BuildDownwardConnectivity().

{
  vtkIdType npts = 0;
  vtkIdType *pts; // will refer to the point id's of the face
  _grid->GetCellPoints(vtkId, npts, pts);
  // MESSAGE(vtkId << " " << npts << "  " << _nbDownCells);
  //ASSERT(npts == _nbDownCells);
  for (int i = 0; i < npts; i++)
    {
      _cellIds[_nbDownCells * cellId + i] = pts[i];
    }
}