Back to index

salome-smesh  6.5.0
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes | Friends
SMDS_DownQuadTriangle Class Reference

#include <SMDS_Downward.hxx>

Inheritance diagram for SMDS_DownQuadTriangle:
Inheritance graph
[legend]
Collaboration diagram for SMDS_DownQuadTriangle:
Collaboration graph
[legend]

List of all members.

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 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 (
virtual int getNodes (int cellId, int *nodevec)
virtual void getOrderedNodesOfFace (int cellId, std::vector< vtkIdType > &orderedNodes)
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_DownQuadTriangle (SMDS_UnstructuredGrid *grid)
 ~SMDS_DownQuadTriangle ()
virtual void computeEdgesWithNodes (int cellId, ListElemByNodesType &edgesWithNodes)
virtual void addDownCell (int cellId, int lowCellId, unsigned char aType)
 Id's are downward connectivity id's.
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)
int computeVolumeIds (int cellId, int *ids)
 Find in vtkUnstructuredGrid the volumes containing a face already stored in vtkUnstructuredGrid.
int computeVolumeIds (ElemByNodesType &faceByNodes, int *ids)
 Find in vtkUnstructuredGrid the volumes containing a face described by it's nodes Search the volumes containing a face, to store the info in SMDS_Down2D for later uses with SMDS_Down2D::getUpCells and SMDS_Down2D::getUpTypes.
int computeVolumeIdsFromNodesFace (int *nodes, int nbNodes, int *ids)
 Find in vtkUnstructuredGrid the volumes containing a face described by it's nodes Search the volumes containing a face, to store the info in SMDS_Down2D for later uses with SMDS_Down2D::getUpCells and SMDS_Down2D::getUpTypes.
void setTempNodes (int cellId, int vtkId)
void setTempNodes (int cellId, ElemByNodesType &faceByNodes)
bool isInFace (int cellId, int *pts, int npts)
 Find if all the nodes belongs to the face.
int FindEdgeByNodes (int cellId, ElemByNodesType &edgeByNodes)
int addCell (int vtkId=-1)
 Give or create an entry for downward connectivity structure relative to a cell.
virtual void initCell (int cellId)
 generic method do nothing.

Protected Attributes

std::vector< int > _upCellIds
 2 volumes max.
std::vector< unsigned char > _upCellTypes
 2 volume types per face
std::vector< int > _tempNodes
 temporary storage of nodes, until downward connectivity completion
int _nbNodes
 number of nodes in a face
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 220 of file SMDS_Downward.hxx.


Constructor & Destructor Documentation

Definition at line 925 of file SMDS_Downward.cxx.

                                                                        :
  SMDS_Down2D(grid, 3)
{
  _cellTypes.push_back(VTK_QUADRATIC_EDGE);
  _cellTypes.push_back(VTK_QUADRATIC_EDGE);
  _cellTypes.push_back(VTK_QUADRATIC_EDGE);
  _nbNodes = 6;
}

Definition at line 934 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:
vtkIdfor a vtkUnstructuredGrid cell or -1 (default) for a created downward cell.
Returns:
the rank in downward[vtkType] structure.

Definition at line 99 of file SMDS_Downward.cxx.

{
  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;
}

Here is the call graph for this function:

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

Id's are downward connectivity id's.

Reimplemented from SMDS_Downward.

Definition at line 962 of file SMDS_Downward.cxx.

{
  //ASSERT((cellId >=0)&& (cellId < _maxId));
  //ASSERT(aType == VTK_QUADRATIC_EDGE);
  int *edges = &_cellIds[_nbDownCells * cellId];
  for (int i = 0; i < _nbDownCells; i++)
    {
      if (edges[i] < 0)
        {
          edges[i] = lowCellId;
          return;
        }
      if (edges[i] == lowCellId)
        return;
    }
  ASSERT(0);
}
void SMDS_Down2D::addUpCell ( int  cellId,
int  upCellId,
unsigned char  aType 
) [protected, virtual, inherited]

Id's are downward connectivity id's.

add a downward entity of dimension n+1 to a given cell.

Actual implementation is done in derived methods.

Parameters:
cellIdindex of the children cell (dimension n) in the downward structure relative to a vtk cell type.
upCellIdindex of the parent cell to add (dimension n+1)
aTypevtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add).

Reimplemented from SMDS_Downward.

Definition at line 695 of file SMDS_Downward.cxx.

{
  //ASSERT((cellId >=0)&& (cellId < _maxId));
  int *vols = &_upCellIds[2 * cellId];
  unsigned char *types = &_upCellTypes[2 * cellId];
  for (int i = 0; i < 2; i++)
    {
      if (vols[i] < 0)
        {
          vols[i] = upCellId; // use non affected volume
          types[i] = aType;
          return;
        }
      if ((vols[i] == upCellId) && (types[i] == aType)) // already done
        return;
    }
  ASSERT(0);
}
void SMDS_Down2D::allocate ( int  nbElems) [protected, virtual, inherited]

Resize the downward connectivity storage vector if needed.

Parameters:
nbElemstotal number of elements of the same type required

Implements SMDS_Downward.

Definition at line 674 of file SMDS_Downward.cxx.

{
  if (nbElems >= _vtkCellIds.size())
    {
      _cellIds.resize(_nbDownCells * (nbElems + SMDS_Mesh::chunkSize), -1);
      _vtkCellIds.resize(nbElems + SMDS_Mesh::chunkSize, -1);
      _upCellIds.resize(2 * (nbElems + SMDS_Mesh::chunkSize), -1);
      _upCellTypes.resize(2 * (nbElems + SMDS_Mesh::chunkSize), -1);
      _tempNodes.resize(_nbNodes * (nbElems + SMDS_Mesh::chunkSize), -1);
    }
}
void SMDS_Down2D::compactStorage ( ) [protected, virtual, inherited]

Implements SMDS_Downward.

Definition at line 686 of file SMDS_Downward.cxx.

{
  _cellIds.resize(_nbDownCells * _maxId);
  _upCellIds.resize(2 * _maxId);
  _upCellTypes.resize(2 * _maxId);
  _vtkCellIds.resize(_maxId);
  _tempNodes.clear();
}
void SMDS_DownQuadTriangle::computeEdgesWithNodes ( int  cellId,
ListElemByNodesType edgesWithNodes 
) [protected, virtual]

Implements SMDS_Down2D.

Definition at line 938 of file SMDS_Downward.cxx.

{
  int *nodes = &_tempNodes[_nbNodes * cellId];
  edgesWithNodes.nbElems = 3;

  edgesWithNodes.elems[0].nodeIds[0] = nodes[0];
  edgesWithNodes.elems[0].nodeIds[1] = nodes[1];
  edgesWithNodes.elems[0].nodeIds[2] = nodes[3];
  edgesWithNodes.elems[0].nbNodes = 3;
  edgesWithNodes.elems[0].vtkType = VTK_QUADRATIC_EDGE;

  edgesWithNodes.elems[1].nodeIds[0] = nodes[1];
  edgesWithNodes.elems[1].nodeIds[1] = nodes[2];
  edgesWithNodes.elems[1].nodeIds[2] = nodes[4];
  edgesWithNodes.elems[1].nbNodes = 3;
  edgesWithNodes.elems[1].vtkType = VTK_QUADRATIC_EDGE;

  edgesWithNodes.elems[2].nodeIds[0] = nodes[2];
  edgesWithNodes.elems[2].nodeIds[1] = nodes[0];
  edgesWithNodes.elems[2].nodeIds[2] = nodes[5];
  edgesWithNodes.elems[2].nbNodes = 3;
  edgesWithNodes.elems[2].vtkType = VTK_QUADRATIC_EDGE;
}
int SMDS_Down2D::computeVolumeIds ( int  cellId,
int *  ids 
) [protected, inherited]

Find in vtkUnstructuredGrid the volumes containing a face already stored in vtkUnstructuredGrid.

Search the volumes containing a face, to store the info in SMDS_Down2D for later uses with SMDS_Down2D::getUpCells and SMDS_Down2D::getUpTypes. A face belongs to 0, 1 or 2 volumes, identified by their id in vtkUnstructuredGrid.

Parameters:
cellIdthe face cell id in vkUnstructuredGrid
idsa couple of vtkId, initialized at -1 (no parent volume)
Returns:
number of volumes (0, 1 or 2)

Definition at line 529 of file SMDS_Downward.cxx.

{
  // --- find point id's of the face

  vtkIdType npts = 0;
  vtkIdType *pts; // will refer to the point id's of the face
  _grid->GetCellPoints(cellId, npts, pts);
  vector<int> nodes;
  for (int i = 0; i < npts; i++)
    nodes.push_back(pts[i]);
  int nvol = this->computeVolumeIdsFromNodesFace(&nodes[0], npts, ids);
  return nvol;
}

Here is the call graph for this function:

int SMDS_Down2D::computeVolumeIds ( ElemByNodesType faceByNodes,
int *  ids 
) [protected, inherited]

Find in vtkUnstructuredGrid the volumes containing a face described by it's nodes Search the volumes containing a face, to store the info in SMDS_Down2D for later uses with SMDS_Down2D::getUpCells and SMDS_Down2D::getUpTypes.

A face belongs to 0, 1 or 2 volumes, identified by their id in vtkUnstructuredGrid.

Parameters:
faceByNodes
idsa couple of vtkId, initialized at -1 (no parent volume)
Returns:
number of volumes (0, 1 or 2)

Definition at line 551 of file SMDS_Downward.cxx.

{
  int nvol = this->computeVolumeIdsFromNodesFace(&faceByNodes.nodeIds[0], faceByNodes.nbNodes, ids);
  return nvol;
}

Here is the call graph for this function:

int SMDS_Down2D::computeVolumeIdsFromNodesFace ( int *  pts,
int  npts,
int *  ids 
) [protected, inherited]

Find in vtkUnstructuredGrid the volumes containing a face described by it's nodes Search the volumes containing a face, to store the info in SMDS_Down2D for later uses with SMDS_Down2D::getUpCells and SMDS_Down2D::getUpTypes.

A face belongs to 0, 1 or 2 volumes, identified by their id in vtkUnstructuredGrid.

Parameters:
ptsarray of vtk node id's
nptsnumber of nodes
ids
Returns:
number of volumes (0, 1 or 2)

Definition at line 566 of file SMDS_Downward.cxx.

{

  // --- 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 < npts; i++)
    {
      vtkIdType point = pts[i];
      int numCells = _grid->GetLinks()->GetNcells(point);
      //MESSAGE("cells pour " << i << " " << numCells);
      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 volume cells: they contains all the points and are of type volume

  int nvol = 0;
  for (int i = 0; i < cnt; i++)
    {
      //MESSAGE("cell " << cellIds[i] << " points " << cellCnt[i]);
      if (cellCnt[i] == npts)
        {
          int vtkElemId = cellIds[i];
          int vtkType = _grid->GetCellType(vtkElemId);
          if (SMDS_Downward::getCellDimension(vtkType) == 3)
            {
              ids[nvol] = vtkElemId; // store the volume id in given vector
              nvol++;
            }
        }
      if (nvol == 2)
        break;
    }

  return nvol;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int SMDS_Down2D::FindEdgeByNodes ( int  cellId,
ElemByNodesType edgeByNodes 
) [protected, inherited]

Definition at line 721 of file SMDS_Downward.cxx.

{
  int *edges = &_cellIds[_nbDownCells * cellId];
  for (int i = 0; i < _nbDownCells; i++)
    {
      if ((edges[i] >= 0) && (edgeByNodes.vtkType == _cellTypes[i]))
        {
          int nodeSet[3];
          int npts = this->_grid->getDownArray(edgeByNodes.vtkType)->getNodeSet(edges[i], nodeSet);
          bool found = false;
          for (int j = 0; j < npts; j++)
            {
              int point = edgeByNodes.nodeIds[j];
              found = false;
              for (int k = 0; k < npts; k++)
                {
                  if (nodeSet[k] == point)
                    {
                      found = true;
                      break;
                    }
                }
              if (!found)
                break;
            }
          if (found)
            return edges[i];
        }
    }
  return -1;
}
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:
cellTypevtk cell type
See also:
vtkCellType.h
Returns:
1,2 or 3

Definition at line 44 of file SMDS_Downward.cxx.

{
  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_BIQUADRATIC_QUAD] = 2;
      _cellDimension[VTK_TETRA] = 3;
      _cellDimension[VTK_QUADRATIC_TETRA] = 3;
      _cellDimension[VTK_HEXAHEDRON] = 3;
      _cellDimension[VTK_QUADRATIC_HEXAHEDRON] = 3;
      _cellDimension[VTK_TRIQUADRATIC_HEXAHEDRON] = 3;
      _cellDimension[VTK_WEDGE] = 3;
      _cellDimension[VTK_QUADRATIC_WEDGE] = 3;
      _cellDimension[VTK_PYRAMID] = 3;
      _cellDimension[VTK_QUADRATIC_PYRAMID] = 3;
      _cellDimension[VTK_HEXAGONAL_PRISM] = 3;
    }
  return _cellDimension[cellType];
}

Here is the caller graph for this function:

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:
cellIdindex of the cell in the downward structure relative to a given vtk cell type.
Returns:
table of downward entities id's.

Definition at line 143 of file SMDS_Downward.cxx.

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

Here is the caller graph for this function:

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:
cellIdindex of the cell in the downward structure relative to a vtk cell type.
Returns:
table of downward entities types.

Definition at line 155 of file SMDS_Downward.cxx.

{
  return &_cellTypes[0];
}

Here is the caller graph for this function:

int SMDS_Downward::getMaxId ( ) [inline, inherited]

Definition at line 86 of file SMDS_Downward.hxx.

  {
    return _maxId;
  }
void SMDS_Down2D::getNodeIds ( int  cellId,
std::set< int > &  nodeSet 
) [virtual, inherited]

Implements SMDS_Downward.

Definition at line 511 of file SMDS_Downward.cxx.

{
  for (int i = 0; i < _nbDownCells; i++)
    {
      int downCellId = _cellIds[_nbDownCells * cellId + i];
      unsigned char cellType = _cellTypes[i];
      this->_grid->getDownArray(cellType)->getNodeIds(downCellId, nodeSet);
    }
}
virtual int SMDS_Downward::getNodes ( int  cellId,
int *  nodevec 
) [inline, virtual, inherited]

Reimplemented in SMDS_Down1D.

Definition at line 80 of file SMDS_Downward.hxx.

{return 0; }
int SMDS_Down2D::getNodeSet ( int  cellId,
int *  nodeSet 
) [protected, virtual, inherited]

Reimplemented from SMDS_Downward.

Definition at line 714 of file SMDS_Downward.cxx.

{
  for (int i = 0; i < _nbNodes; i++)
    nodeSet[i] = _tempNodes[_nbNodes * cellId + i];
  return _nbNodes;
}
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:
cellIdnot used here.
Returns:

Definition at line 132 of file SMDS_Downward.cxx.

{
  return _nbDownCells;
}

Here is the caller graph for this function:

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

Implements SMDS_Downward.

Definition at line 489 of file SMDS_Downward.cxx.

{
  int nbup = 0;
  if (_upCellIds[2 * cellId] >= 0)
    nbup++;
  if (_upCellIds[2 * cellId + 1] >= 0)
    nbup++;
  return nbup;
}
virtual void SMDS_Downward::getOrderedNodesOfFace ( int  cellId,
std::vector< vtkIdType > &  orderedNodes 
) [inline, virtual, inherited]
const int * SMDS_Down2D::getUpCells ( int  cellId) [virtual, inherited]

Implements SMDS_Downward.

Definition at line 499 of file SMDS_Downward.cxx.

{
  //ASSERT((cellId >=0) && (cellId < _maxId));
  return &_upCellIds[2 * cellId];
}
const unsigned char * SMDS_Down2D::getUpTypes ( int  cellId) [virtual, inherited]

Implements SMDS_Downward.

Definition at line 505 of file SMDS_Downward.cxx.

{
  //ASSERT((cellId >=0) && (cellId < _maxId));
  return &_upCellTypes[2 * cellId];
}
int SMDS_Downward::getVtkCellId ( int  cellId) [inline, inherited]

Definition at line 82 of file SMDS_Downward.hxx.

  {
    return _vtkCellIds[cellId];
  }
void SMDS_Downward::initCell ( int  cellId) [protected, virtual, inherited]

generic method do nothing.

see derived methods

Parameters:
cellId

Reimplemented in SMDS_Down1D.

Definition at line 123 of file SMDS_Downward.cxx.

{
}

Here is the caller graph for this function:

bool SMDS_Down2D::isInFace ( int  cellId,
int *  pts,
int  npts 
) [protected, inherited]

Find if all the nodes belongs to the face.

Parameters:
cellIdthe face cell Id
nodeSetset of node id's to be found in the face list of nodes
Returns:

Definition at line 651 of file SMDS_Downward.cxx.

{
  int nbFound = 0;
  int *nodes = &_tempNodes[_nbNodes * cellId];
  for (int j = 0; j < npts; j++)
    {
      int point = pts[j];
      for (int i = 0; i < _nbNodes; i++)
        {
          if (nodes[i] == point)
            {
              nbFound++;
              break;
            }
        }
    }
  return (nbFound == npts);
}

Here is the caller graph for this function:

void SMDS_Down2D::setTempNodes ( int  cellId,
int  vtkId 
) [protected, inherited]

Definition at line 626 of file SMDS_Downward.cxx.

{
  vtkIdType npts = 0;
  vtkIdType *pts; // will refer to the point id's of the face
  _grid->GetCellPoints(vtkId, npts, pts);
  // MESSAGE(vtkId << " " << npts << "  " << _nbNodes);
  //ASSERT(npts == _nbNodes);
  for (int i = 0; i < npts; i++)
    {
      _tempNodes[_nbNodes * cellId + i] = pts[i];
    }
}
void SMDS_Down2D::setTempNodes ( int  cellId,
ElemByNodesType faceByNodes 
) [protected, inherited]

Definition at line 639 of file SMDS_Downward.cxx.

{
  for (int i = 0; i < faceByNodes.nbNodes; i++)
    _tempNodes[_nbNodes * cellId + i] = faceByNodes.nodeIds[i];
}

Friends And Related Function Documentation

friend class SMDS_UnstructuredGrid [friend]

Reimplemented from SMDS_Down2D.

Definition at line 222 of file SMDS_Downward.hxx.


Member Data Documentation

vector< int > SMDS_Downward::_cellDimension [static, protected, inherited]

conversion table: type --> dimension

Definition at line 109 of file SMDS_Downward.hxx.

std::vector<int> SMDS_Downward::_cellIds [protected, inherited]

growing size: all the down cell id's, size = _maxId * _nbDownCells

Definition at line 105 of file SMDS_Downward.hxx.

std::vector<unsigned char> SMDS_Downward::_cellTypes [protected, inherited]

fixed size: the same vector for all cells of a derived class

Definition at line 107 of file SMDS_Downward.hxx.

Definition at line 102 of file SMDS_Downward.hxx.

int SMDS_Downward::_maxId [protected, inherited]

Definition at line 103 of file SMDS_Downward.hxx.

int SMDS_Downward::_nbDownCells [protected, inherited]

the same number for all cells of a derived class

Definition at line 104 of file SMDS_Downward.hxx.

int SMDS_Down2D::_nbNodes [protected, inherited]

number of nodes in a face

Definition at line 171 of file SMDS_Downward.hxx.

std::vector<int> SMDS_Down2D::_tempNodes [protected, inherited]

temporary storage of nodes, until downward connectivity completion

Definition at line 170 of file SMDS_Downward.hxx.

std::vector<int> SMDS_Down2D::_upCellIds [protected, inherited]

2 volumes max.

per face

Definition at line 168 of file SMDS_Downward.hxx.

std::vector<unsigned char> SMDS_Down2D::_upCellTypes [protected, inherited]

2 volume types per face

Definition at line 169 of file SMDS_Downward.hxx.

std::vector<int> SMDS_Downward::_vtkCellIds [protected, inherited]

growing size: size = _maxId, either vtkId or -1

Definition at line 106 of file SMDS_Downward.hxx.


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