ConnectivityBuilder< MeshType > Class Template Reference

#include <ConnectivityBuilder.hpp>

Collaboration diagram for ConnectivityBuilder< MeshType >:

Collaboration graph
[legend]

List of all members.

Public Member Functions

void generates (const size_t &buildType)
void borderMesh (ReferenceCounting< typename MeshType::BorderMeshType > &border)
 ConnectivityBuilder (const MeshType &m)
 ~ConnectivityBuilder ()

Private Types

typedef MeshType::CellType CellType
typedef CellType::FaceType FaceType
typedef TinyVector
< FaceType::NumberOfVertices,
size_t > 		FaceVerticesList
typedef std::pair< const
CellType *, size_t > 		CellFace
typedef std::map
< FaceVerticesList, std::list
< CellFace > > 		FaceToCellMapping

Private Member Functions

void __getOptions (const size_t &buildType)
 ConnectivityBuilder (const ConnectivityBuilder< MeshType > &)
void __faceToCellsConstruction ()
void __cellToCellsConstruction ()
void __cellToFacesConstruction ()
void __cellToEdgesConstruction ()
void __vertexToCellConstruction ()
void __vertexToVerticesGeneralizedConstruction ()

Private Attributes

MeshType & __mesh
bool __buildCellToCells
bool __buildCellToFaces
bool __buildCellToEdges
bool __buildCellToVertices
bool __buildFaceToCells
bool __buildFaceToEdges
bool __buildFaceToVertices
bool __buildEdgeToCells
bool __buildEdgeToFaces
bool __buildEdgeToVertices
bool __buildVertexToCell
bool __buildVertexToFaces
bool __buildVertexToEdges
bool __buildVertexToVertices
bool __buildVertexToVerticesGeneralized
FaceToCellMapping __faceToCells

Friends

struct BorderLinker< MeshType::family >

Detailed Description

template<typename MeshType>
class ConnectivityBuilder< MeshType >

Definition at line 54 of file ConnectivityBuilder.hpp.

Member Typedef Documentation

template<typename MeshType>
typedef MeshType::CellType ConnectivityBuilder< MeshType >::CellType [private]

Definition at line 77 of file ConnectivityBuilder.hpp.

template<typename MeshType>
typedef CellType::FaceType ConnectivityBuilder< MeshType >::FaceType [private]

Definition at line 78 of file ConnectivityBuilder.hpp.

template<typename MeshType>
typedef TinyVector<FaceType::NumberOfVertices, size_t> ConnectivityBuilder< MeshType >::FaceVerticesList [private]

Definition at line 126 of file ConnectivityBuilder.hpp.

template<typename MeshType>
typedef std::pair<const CellType*, size_t> ConnectivityBuilder< MeshType >::CellFace [private]

Definition at line 127 of file ConnectivityBuilder.hpp.

template<typename MeshType>
typedef std::map<FaceVerticesList, std::list<CellFace> > ConnectivityBuilder< MeshType >::FaceToCellMapping [private]

Definition at line 129 of file ConnectivityBuilder.hpp.

Constructor & Destructor Documentation

template<typename MeshType>
ConnectivityBuilder< MeshType >::ConnectivityBuilder ( const ConnectivityBuilder< MeshType > &   )  [private]

Forbidds the copy constructor

template<typename MeshType>
ConnectivityBuilder< MeshType >::ConnectivityBuilder ( const MeshType &  m  )  [inline]

Definition at line 576 of file ConnectivityBuilder.hpp.

References ffout().

00578     : __mesh(const_cast<MeshType&>(m)), // This allows to built the connectivity "on-demand"
00579       __buildCellToCells(false),
00580       __buildCellToFaces(false),
00581       __buildCellToEdges(false),
00582       __buildCellToVertices(false),
00583       __buildFaceToCells(false),
00584       __buildFaceToEdges(false),
00585       __buildFaceToVertices(false),
00586       __buildEdgeToCells(false),
00587       __buildEdgeToFaces(false),
00588       __buildEdgeToVertices(false),
00589       __buildVertexToCell(false),
00590       __buildVertexToFaces(false),
00591       __buildVertexToEdges(false)
00592   {
00593     ffout(3) << "Starting connectivity builder\n";

Here is the call graph for this function:

template<typename MeshType>
ConnectivityBuilder< MeshType >::~ConnectivityBuilder (  )  [inline]

Definition at line 595 of file ConnectivityBuilder.hpp.

References ffout().

00597   {
00598     ffout(3) << "Connectivity builder finished\n";

Here is the call graph for this function:

Member Function Documentation

template<typename MeshType>
void ConnectivityBuilder< MeshType >::__getOptions ( const size_t &  buildType  )  [inline, private]

Definition at line 80 of file ConnectivityBuilder.hpp.

References ConnectivityBuilder< MeshType >::__buildCellToCells, ConnectivityBuilder< MeshType >::__buildCellToEdges, ConnectivityBuilder< MeshType >::__buildCellToFaces, ConnectivityBuilder< MeshType >::__buildCellToVertices, ConnectivityBuilder< MeshType >::__buildEdgeToCells, ConnectivityBuilder< MeshType >::__buildEdgeToFaces, ConnectivityBuilder< MeshType >::__buildEdgeToVertices, ConnectivityBuilder< MeshType >::__buildFaceToCells, ConnectivityBuilder< MeshType >::__buildFaceToEdges, ConnectivityBuilder< MeshType >::__buildFaceToVertices, ConnectivityBuilder< MeshType >::__buildVertexToCell, ConnectivityBuilder< MeshType >::__buildVertexToEdges, ConnectivityBuilder< MeshType >::__buildVertexToFaces, ConnectivityBuilder< MeshType >::__buildVertexToVertices, ConnectivityBuilder< MeshType >::__buildVertexToVerticesGeneralized, and ErrorHandler::unexpected.

00082   {
00083     if ((buildType>>15)!=0) {
00084       throw ErrorHandler(__FILE__,__LINE__,
00085                          "unknown connectivity type",
00086                          ErrorHandler::unexpected);
00087     }
00088     __buildCellToCells
00089       = (Connectivity<MeshType>::CellToCells & buildType);
00090     __buildCellToFaces
00091       = (Connectivity<MeshType>::CellToFaces & buildType);
00092     __buildCellToEdges
00093       = (Connectivity<MeshType>::CellToEdges & buildType);
00094     __buildCellToVertices
00095       = (Connectivity<MeshType>::CellToVertices & buildType);
00096     __buildFaceToCells
00097       = (Connectivity<MeshType>::FaceToCells & buildType);
00098     __buildFaceToEdges
00099       = (Connectivity<MeshType>::FaceToEdges & buildType);
00100     __buildFaceToVertices
00101       = (Connectivity<MeshType>::FaceToVertices & buildType);
00102     __buildEdgeToCells
00103       = (Connectivity<MeshType>::EdgeToCells & buildType);
00104     __buildEdgeToFaces
00105       = (Connectivity<MeshType>::EdgeToFaces & buildType);
00106     __buildEdgeToVertices
00107       = (Connectivity<MeshType>::EdgeToVertices & buildType);
00108     __buildVertexToCell
00109       = (Connectivity<MeshType>::VertexToCell & buildType);
00110     __buildVertexToFaces
00111       = (Connectivity<MeshType>::VertexToFaces & buildType);
00112     __buildVertexToEdges
00113       = (Connectivity<MeshType>::VertexToEdges & buildType);
00114     __buildVertexToVertices
00115       = (Connectivity<MeshType>::VertexToVertices & buildType);
00116     __buildVertexToVerticesGeneralized
00117       = (Connectivity<MeshType>::VertexToVerticesGeneralized & buildType);

template<typename MeshType>
void ConnectivityBuilder< MeshType >::__faceToCellsConstruction (  )  [inline, private]

Builds internal table that associates elements to their faces

Definition at line 137 of file ConnectivityBuilder.hpp.

Referenced by BorderLinker< Mesh::volume >::BorderLinker().

00139   {
00140     ffout(4) << " - building face to cells mapping...\n";
00141     if (not(__faceToCells.empty())) {
00142       ffout(4) << "already done\n";
00143       return;
00144     }
00145 
00146     if (not(__mesh.hasFaces())) {
00147       __mesh.buildFaces();
00148     }
00149 
00150     for (typename MeshType::const_iterator i(__mesh); not(i.end()); ++i) {
00151       for (size_t l=0; l<CellType::NumberOfFaces; ++l) {
00152         std::set<size_t> verticesSet;
00153         for (size_t k=0; k<FaceType::NumberOfVertices; ++k) {
00154           const size_t vertexNumber
00155             = __mesh.vertexNumber((*i)(CellType::faces[l][k]));
00156           verticesSet.insert(__mesh.correspondance(vertexNumber));
00157         }
00158         FaceVerticesList vertices;
00159         size_t k=0;
00160         for (std::set<size_t>::iterator n=verticesSet.begin();
00161              n !=  verticesSet.end(); ++n) {
00162           vertices[k++]=*n;
00163         }
00164         __faceToCells[vertices].push_back(CellFace(i.pointer(),l));
00165       }
00166     }
00167     ffout(4) << "done\n";
00168     if (__buildFaceToCells) { // storing or not this connectivity
00169       ffout(3) << "- Storing face to cells connectivity\n";
00170       if (__mesh.connectivity().hasFaceToCells()) {
00171         ffout(4) << "already done\n";
00172         return;
00173       }
00174 
00175       typedef
00176         typename Connectivity<MeshType>::FaceToCellsType
00177         FaceToCellsType;
00178 
00179       ReferenceCounting<Vector<FaceToCellsType> > pFaceToCells
00180         = new Vector<FaceToCellsType>(__faceToCells.size());
00181       Vector<FaceToCellsType>& faceToCells = *pFaceToCells;
00182 
00183       size_t faceNumber = 0;
00184       for (typename FaceToCellMapping::iterator i = __faceToCells.begin();
00185            i != __faceToCells.end(); ++i) {
00186         typename FaceToCellMapping::mapped_type& faceList
00187           = (*i).second;
00188 
00189         switch (faceList.size()) {
00190         case 1: {
00191           typename FaceToCellMapping::mapped_type::iterator j
00192             = (*i).second.begin();
00193           faceToCells[faceNumber][0]=(*j);
00194           faceToCells[faceNumber][1]= std::make_pair(static_cast<CellType*>(0),
00195                                                      std::numeric_limits<size_t>::max());
00196           break;
00197         }
00198         case 2: {
00199           typename FaceToCellMapping::mapped_type::iterator j1 = (*i).second.begin();
00200           typename FaceToCellMapping::mapped_type::iterator j2 = j1;
00201           j2++;
00202 
00203           faceToCells[faceNumber][0] = (*j2);
00204           faceToCells[faceNumber][1] = (*j1);
00205           break;
00206         }
00207         default: {
00208           fferr(0) << "\noops: Something strange happened: incorrect mesh:\n";
00209           fferr(0) << "        One of the faces of your mesh is related to "
00210                    << faceList.size() << " cells (vertices: " << (*i).first << ")\n"; ;
00211 #ifndef NDEBUG
00212           throw ErrorHandler(__FILE__,__LINE__,
00213                              "stopping execution since debug mode is activated",
00214                              ErrorHandler::unexpected);
00215 #endif // NDEBUG
00216         }
00217         }
00218         faceNumber++;
00219       }
00220       __mesh.connectivity().setFaceToCells(pFaceToCells);
00221 
00222     }

template<typename MeshType>
void ConnectivityBuilder< MeshType >::__cellToCellsConstruction (  )  [inline, private]

Builds the cell to cell connectivity

Definition at line 228 of file ConnectivityBuilder.hpp.

00230   {
00231     this->__faceToCellsConstruction();
00232     ffout(3) << "- Storing cell to cells connectivity\n";
00233 
00234     if (__mesh.connectivity().hasCellToCells()) {
00235       ffout(4) << "already done\n";
00236       return;
00237     }
00238 
00239     if (not(__mesh.hasFaces())) {
00240       __mesh.buildFaces();
00241     }
00242 
00243     typedef
00244       typename Connectivity<MeshType>::CellToCellsType
00245       CellToCellsType;
00246 
00247     ReferenceCounting<Vector<CellToCellsType> > pCellToCells
00248       = new Vector<CellToCellsType>(__mesh.numberOfCells());
00249     Vector<CellToCellsType>& cellToCells = *pCellToCells;
00250 
00251     for (typename FaceToCellMapping::iterator i
00252            = __faceToCells.begin();
00253          i != __faceToCells.end(); ++i) {
00254       typename FaceToCellMapping::mapped_type& faceList
00255         = (*i).second;
00256 
00257       switch (faceList.size()) {
00258       case 1: {
00259         typename FaceToCellMapping::mapped_type::iterator j
00260           = (*i).second.begin();
00261         // Ensure that the face is 0
00262         cellToCells(__mesh.cellNumber(*(*j).first))[(*j).second] = 0;
00263         break;
00264       }
00265       case 2: {
00266         typename FaceToCellMapping::mapped_type::iterator j1 = (*i).second.begin();
00267         typename FaceToCellMapping::mapped_type::iterator j2 = j1;
00268         j2++;
00269 
00270         cellToCells(__mesh.cellNumber(*(*j1).first))[(*j1).second] = (*j2).first;
00271         cellToCells(__mesh.cellNumber(*(*j2).first))[(*j2).second] = (*j1).first;
00272 
00273         break;
00274       }
00275       default: {
00276         fferr(0) << "\noops: Something strange happened: incorrect mesh:\n";
00277         fferr(0) << "        One of the faces of your mesh is related to "
00278                  << faceList.size() << " cells (vertices: " << (*i).first << ")\n";
00279         for(typename FaceToCellMapping::mapped_type::iterator j = faceList.begin();
00280             j != faceList.end(); ++j) {
00281           const CellType& K = *(*j).first;
00282           fferr(0) << "Cell " << (*j).second << ':';
00283           for (size_t k=0; k<CellType::NumberOfVertices; ++k) {
00284             fferr(0) << ' ' << __mesh.vertexNumber(K(k));
00285           }
00286           fferr(0) << '\n';
00287         }
00288       }
00289       }
00290     }
00291     __mesh.connectivity().setCellToCells(pCellToCells);

template<typename MeshType>
void ConnectivityBuilder< MeshType >::__cellToFacesConstruction (  )  [inline, private]

Builds cell to faces connectivity

Definition at line 297 of file ConnectivityBuilder.hpp.

00299   {
00300     this->__faceToCellsConstruction();
00301     ffout(3) << "- Storing cell to faces connectivity\n";
00302     if (__mesh.connectivity().hasCellToFaces()) {
00303       ffout(3) << "already done\n";
00304       return;
00305     }
00306 
00307     if (not(__mesh.hasFaces())) {
00308       __mesh.buildFaces();
00309     }
00310 
00311     typedef
00312       typename Connectivity<MeshType>::CellToFacesType
00313       CellToFacesType;
00314 
00315     ReferenceCounting<Vector<CellToFacesType> > pCellToFaces
00316       = new Vector<CellToFacesType>(__mesh.numberOfCells());
00317 
00318     Vector<CellToFacesType>& cellToFaces = *pCellToFaces;
00319     size_t faceNumber = 0;
00320     for (typename FaceToCellMapping::iterator i = __faceToCells.begin();
00321          i != __faceToCells.end(); ++i) {
00322       const std::list<CellFace>& cellList = (*i).second;
00323       for (typename std::list<CellFace>::const_iterator j = cellList.begin();
00324            j != (*i).second.end(); ++j) {
00325         const size_t cellNumber = __mesh.cellNumber(*(*j).first);
00326         const size_t localFaceNumber = (*j).second;
00327         cellToFaces[cellNumber][localFaceNumber]
00328           = &__mesh.face(faceNumber);
00329       }
00330       faceNumber++;
00331     }
00332 
00333     __mesh.connectivity().setCellToFaces(pCellToFaces);

template<typename MeshType>
void ConnectivityBuilder< MeshType >::__cellToEdgesConstruction (  )  [inline, private]

Builds cell to edges connectivity

Definition at line 339 of file ConnectivityBuilder.hpp.

00341   {
00342     ffout(3) << "- Storing cell to edges connectivity\n";
00343 
00344     if (__mesh.connectivity().hasCellToEdges()) {
00345       ffout(4) << "already done\n";
00346       return;
00347     }
00348 
00349     if (not(__mesh.hasEdges())) {
00350       __mesh.buildEdges();
00351     }
00352 
00353     typedef TinyVector<2, size_t> EdgeVerticesList;
00354     typedef std::pair<const CellType*, size_t> CellEdge;
00355     typedef std::map<EdgeVerticesList,
00356                      std::list<CellEdge> > EdgeToCellMapping;
00357 
00358     if (__mesh.numberOfEdges() == 0) {
00359       throw ErrorHandler(__FILE__,__LINE__,
00360                          "edge list not built",
00361                          ErrorHandler::unexpected);
00362     }
00363 
00364     EdgeToCellMapping edgeToCells;
00365 
00366     for (typename MeshType::const_iterator icell(__mesh); not(icell.end()); ++icell) {
00367       for (size_t l=0; l<CellType::NumberOfEdges; ++l) {
00368         std::set<size_t> verticesSet;
00369         for (size_t k=0; k<2; ++k) {
00370           const size_t vertexNumber
00371             = __mesh.vertexNumber((*icell)(CellType::edges[l][k]));
00372           verticesSet.insert(__mesh.correspondance(vertexNumber));
00373         }
00374         EdgeVerticesList vertices;
00375         size_t k=0;
00376         for (std::set<size_t>::iterator n=verticesSet.begin();
00377              n !=  verticesSet.end(); ++n) {
00378           vertices[k++] = *n;
00379         }
00380         edgeToCells[vertices].push_back(CellFace(icell.pointer(),l));
00381       }
00382     }
00383 
00384     typedef typename  Connectivity<MeshType>::CellToEdgesType CellToEdgesType;
00385 
00386     ReferenceCounting<Vector<CellToEdgesType> >
00387       pCellToEdges = new Vector<CellToEdgesType>(__mesh.numberOfCells());
00388     Vector<CellToEdgesType>& cellToEdges = *pCellToEdges;
00389 
00390     for (size_t i=0; i<__mesh.numberOfEdges(); ++i) {
00391       const Edge& edge = __mesh.edge(i);
00392       std::set<size_t> edgeVerticesSet;
00393       for (size_t k=0; k<2; ++k) {
00394         const size_t vertexNumber = __mesh.vertexNumber(edge(k));
00395         edgeVerticesSet.insert(__mesh.correspondance(vertexNumber));
00396       }
00397 
00398       size_t k=0;
00399       EdgeVerticesList vertices;
00400 
00401       for (std::set<size_t>::iterator n=edgeVerticesSet.begin();
00402            n !=  edgeVerticesSet.end(); ++n) {
00403         vertices[k++]=*n;
00404       }
00405       typename EdgeToCellMapping::iterator ie
00406         = edgeToCells.find(vertices);
00407       if (ie == edgeToCells.end()) {
00408         fferr(0) << "\noops: Something strange happened: incorrect mesh:\n";
00409         fferr(0) << "        One of the edges of your mesh is related to "
00410                  << "        no cells (vertices: " << (*ie).first << ")\n";
00411 #ifndef NDEBUG
00412         throw ErrorHandler(__FILE__,__LINE__,
00413                            "stopping execution since debug mode is activated",
00414                            ErrorHandler::unexpected);
00415 #endif // NDEBUG
00416       }
00417       for (typename EdgeToCellMapping::mapped_type::iterator
00418              j = ie->second.begin();
00419            j != ie->second.end(); ++j) {
00420         const CellType& cell = *j->first;
00421         const size_t edgeNumber = j->second;
00422         cellToEdges(__mesh.cellNumber(cell))[edgeNumber] = &edge;
00423       }
00424     }
00425     __mesh.connectivity().setCellToEdges(pCellToEdges);

template<typename MeshType>
void ConnectivityBuilder< MeshType >::__vertexToCellConstruction (  )  [inline, private]

builds vertex to cell connectivity

Definition at line 431 of file ConnectivityBuilder.hpp.

00433   {
00434     ffout(3) << "- Storing Vertex to Cells connectivity\n";
00435 
00436     if (__mesh.connectivity().hasVertexToCells()) {
00437       ffout(4) << "already done\n";
00438       return;
00439     }
00440 
00441     typedef
00442       typename Connectivity<MeshType>::VertexToCellsType
00443       VertexToCellsType;
00444 
00445     ReferenceCounting<Vector<VertexToCellsType> > pVertexToCells
00446       = new Vector<VertexToCellsType>(__mesh.numberOfVertices());
00447     Vector<VertexToCellsType>& vertexToCells = *pVertexToCells;
00448 
00449     for (typename MeshType::const_iterator i(__mesh); not(i.end()); ++i) {
00450       const CellType& cell = *i;
00451       for (size_t n=0; n<CellType::NumberOfVertices; ++n) {
00452         const size_t vertexNumber = __mesh.vertexNumber(cell(n));
00453         vertexToCells[__mesh.correspondance(vertexNumber)].insert(&cell);
00454       }
00455     }
00456 
00457     __mesh.connectivity().setVertexToCells(pVertexToCells);

template<typename MeshType>
void ConnectivityBuilder< MeshType >::__vertexToVerticesGeneralizedConstruction (  )  [inline, private]

builds generalized vertex to vertices connectivity. Generalized in the sens that they are connected by cells.

Definition at line 464 of file ConnectivityBuilder.hpp.

00466   {
00467     ffout(3) << "- Storing Vertex to Vertices connectivity\n";
00468 
00469     if (__mesh.connectivity().hasVertexToVericesGeneralized()) {
00470       ffout(4) << "already done\n";
00471       return;
00472     }
00473 
00474     typedef
00475       typename Connectivity<MeshType>::VertexToVerticesType
00476       VertexToVerticesType;
00477 
00478     ReferenceCounting<Vector<VertexToVerticesType> > pVertexToVertices
00479       = new Vector<VertexToVerticesType>(__mesh.numberOfVertices());
00480     Vector<VertexToVerticesType>& vertexToVertices = *pVertexToVertices;
00481 
00482     for (typename MeshType::const_iterator i(__mesh); not(i.end()); ++i) {
00483       const CellType& cell = *i;
00484       for (size_t n=0; n<CellType::NumberOfVertices; ++n) {
00485         for (size_t m=0; m<CellType::NumberOfVertices; ++m) {
00486           if (m != n) {
00487             vertexToVertices[__mesh.vertexNumber(cell(n))].insert(&cell(m));
00488           }
00489         }
00490       }
00491     }
00492 
00493     __mesh.connectivity().setVertexToVerticesGeneralized(pVertexToVertices);

template<typename MeshType>
void ConnectivityBuilder< MeshType >::generates ( const size_t &  buildType  )  [inline]

Builds required connectivities

Parameters:
buildType required connectivities

Definition at line 502 of file ConnectivityBuilder.hpp.

Referenced by ScalarDegreeOfFreedomPositionsSet::Builder::__computeFEMNbDOF(), SurfaceMeshGenerator::Internals::__createTrianglesIntersection(), MeshOfTriangles::buildLocalizationTools(), MeshOfTetrahedra::buildLocalizationTools(), MeshOfHexahedra::buildLocalizationTools(), SurfaceMeshGenerator::generateSurfacicMesh(), Convection< MeshOfHexahedra >::operator()(), Convection< MeshOfTetrahedra >::operator()(), and Convection< Structured3DMesh >::operator()().

00504   {
00505     this->__getOptions(buildType);
00506 
00507     if (__buildCellToCells) {
00508       this->__cellToCellsConstruction();
00509     }
00510     if (__buildCellToFaces) {
00511       this->__cellToFacesConstruction();
00512     }
00513     if (__buildCellToEdges) {
00514       this->__cellToEdgesConstruction();
00515     }
00516     if (__buildCellToVertices) {
00517       throw ErrorHandler(__FILE__,__LINE__,
00518                          "not implemented",
00519                          ErrorHandler::unexpected);
00520     }
00521     if (__buildFaceToCells) {
00522       this->__faceToCellsConstruction();
00523     }
00524     if (__buildFaceToEdges) {
00525       throw ErrorHandler(__FILE__,__LINE__,
00526                          "not implemented",
00527                          ErrorHandler::unexpected);
00528     }
00529     if (__buildFaceToVertices) {
00530       throw ErrorHandler(__FILE__,__LINE__,
00531                          "not implemented",
00532                          ErrorHandler::unexpected);
00533     }
00534     if (__buildEdgeToCells) {
00535       throw ErrorHandler(__FILE__,__LINE__,
00536                          "not implemented",
00537                          ErrorHandler::unexpected);
00538     }
00539     if (__buildEdgeToFaces) {
00540       throw ErrorHandler(__FILE__,__LINE__,
00541                          "not implemented",
00542                          ErrorHandler::unexpected);
00543     }
00544     if (__buildEdgeToVertices) {
00545       throw ErrorHandler(__FILE__,__LINE__,
00546                          "not implemented",
00547                          ErrorHandler::unexpected);
00548     }
00549     if (__buildVertexToCell) {
00550       this->__vertexToCellConstruction();
00551     }
00552     if (__buildVertexToFaces) {
00553       throw ErrorHandler(__FILE__,__LINE__,
00554                          "not implemented",
00555                          ErrorHandler::unexpected);
00556     }
00557     if (__buildVertexToEdges) {
00558       throw ErrorHandler(__FILE__,__LINE__,
00559                          "not implemented",
00560                          ErrorHandler::unexpected);
00561     }
00562     if (__buildVertexToVertices) {
00563       throw ErrorHandler(__FILE__,__LINE__,
00564                          "not implemented",
00565                          ErrorHandler::unexpected);
00566     }
00567     if (__buildVertexToVerticesGeneralized) {
00568       this->__vertexToVerticesGeneralizedConstruction();
00569     }

template<typename MeshType>
void ConnectivityBuilder< MeshType >::borderMesh ( ReferenceCounting< typename MeshType::BorderMeshType > &  border  )  [inline]

Definition at line 571 of file ConnectivityBuilder.hpp.

References ConnectivityBuilder< MeshType >::__mesh.

Referenced by MeshOfHexahedra::buildLocalizationTools(), and MeshOfTetrahedra::MeshOfTetrahedra().

00573   {
00574     BorderLinker<MeshType::family>(__mesh, *this, border);

Friends And Related Function Documentation

template<typename MeshType>
friend struct BorderLinker< MeshType::family > [friend]

Definition at line 75 of file ConnectivityBuilder.hpp.

Member Data Documentation

template<typename MeshType>
MeshType& ConnectivityBuilder< MeshType >::__mesh [private]

Definition at line 57 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::borderMesh().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildCellToCells [private]

Definition at line 59 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildCellToFaces [private]

Definition at line 60 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildCellToEdges [private]

Definition at line 61 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildCellToVertices [private]

Definition at line 62 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildFaceToCells [private]

Definition at line 63 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildFaceToEdges [private]

Definition at line 64 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildFaceToVertices [private]

Definition at line 65 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildEdgeToCells [private]

Definition at line 66 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildEdgeToFaces [private]

Definition at line 67 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildEdgeToVertices [private]

Definition at line 68 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildVertexToCell [private]

Definition at line 69 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildVertexToFaces [private]

Definition at line 70 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildVertexToEdges [private]

Definition at line 71 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildVertexToVertices [private]

Connected by Edges

Definition at line 72 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
bool ConnectivityBuilder< MeshType >::__buildVertexToVerticesGeneralized [private]

Connected by elements

Definition at line 73 of file ConnectivityBuilder.hpp.

Referenced by ConnectivityBuilder< MeshType >::__getOptions().

template<typename MeshType>
FaceToCellMapping ConnectivityBuilder< MeshType >::__faceToCells [private]

Definition at line 131 of file ConnectivityBuilder.hpp.

Referenced by BorderLinker< Mesh::volume >::BorderLinker().

The documentation for this class was generated from the following file:
Generated on Wed Nov 19 00:05:11 2008 for FreeFEM3D (aka ff3d) by  doxygen 1.5.6