FreeFOAM The Cross-Platform CFD Toolkit
Hosted by SourceForge:
Get FreeFOAM at SourceForge.net.
            Fast, secure and Free Open Source software downloads

primitiveMesh.H

Go to the documentation of this file.
00001 /*---------------------------------------------------------------------------*\
00002   =========                 |
00003   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
00004    \\    /   O peration     |
00005     \\  /    A nd           | Copyright (C) 1991-2010 OpenCFD Ltd.
00006      \\/     M anipulation  |
00007 -------------------------------------------------------------------------------
00008 License
00009     This file is part of OpenFOAM.
00010 
00011     OpenFOAM is free software: you can redistribute it and/or modify it
00012     under the terms of the GNU General Public License as published by
00013     the Free Software Foundation, either version 3 of the License, or
00014     (at your option) any later version.
00015 
00016     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
00017     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00018     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
00019     for more details.
00020 
00021     You should have received a copy of the GNU General Public License
00022     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
00023 
00024 Class
00025     Foam::primitiveMesh
00026 
00027 Description
00028     Cell-face mesh analysis engine
00029 
00030 SourceFiles
00031     primitiveMeshI.H
00032     primitiveMesh.C
00033     primitiveMeshClear.C
00034     primitiveMeshCellCells.C
00035     primitiveMeshEdgeCells.C
00036     primitiveMeshPointCells.C
00037     primitiveMeshCells.C
00038     primitiveMeshEdgeFaces.C
00039     primitiveMeshPointFaces.C
00040     primitiveMeshCellEdges.C
00041     primitiveMeshPointEdges.C
00042     primitiveMeshPointPoints.C
00043     primitiveMeshEdges.C
00044     primitiveMeshCellCentresAndVols.C
00045     primitiveMeshFaceCentresAndAreas.C
00046     primitiveMeshEdgeVectors.C
00047     primitiveMeshCheck.C
00048     primitiveMeshCheckMotion.C
00049     primitiveMeshFindCell.C
00050 
00051 \*---------------------------------------------------------------------------*/
00052 
00053 #ifndef primitiveMesh_H
00054 #define primitiveMesh_H
00055 
00056 #include <OpenFOAM/DynamicList.H>
00057 #include <OpenFOAM/edgeList.H>
00058 #include <OpenFOAM/pointField.H>
00059 #include <OpenFOAM/SubField.H>
00060 #include <OpenFOAM/SubList.H>
00061 #include <OpenFOAM/faceList.H>
00062 #include <OpenFOAM/cellList.H>
00063 #include <OpenFOAM/cellShapeList.H>
00064 #include <OpenFOAM/labelList.H>
00065 #include <OpenFOAM/boolList.H>
00066 #include <OpenFOAM/HashSet.H>
00067 #include <OpenFOAM/Map.H>
00068 #include <OpenFOAM/EdgeMap.H>
00069 
00070 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00071 
00072 namespace Foam
00073 {
00074 
00075 /*---------------------------------------------------------------------------*\
00076                       Class primitiveMesh Declaration
00077 \*---------------------------------------------------------------------------*/
00078 
00079 class primitiveMesh
00080 {
00081     // Permanent data
00082 
00083         // Primitive size data
00084 
00085             //- Number of internal points (or -1 if points not sorted)
00086             label nInternalPoints_;
00087 
00088             //- Number of points
00089             label nPoints_;
00090 
00091             //- Number of internal edges using 0 boundary points
00092             mutable label nInternal0Edges_;
00093 
00094             //- Number of internal edges using 0 or 1 boundary points
00095             mutable label nInternal1Edges_;
00096 
00097             //- Number of internal edges using 0,1 or 2boundary points
00098             mutable label nInternalEdges_;
00099 
00100             //- Number of edges
00101             mutable label nEdges_;
00102 
00103             //- Number of internal faces
00104             label nInternalFaces_;
00105 
00106             //- Number of faces
00107             label nFaces_;
00108 
00109             //- Number of cells
00110             label nCells_;
00111 
00112 
00113         // Shapes
00114 
00115             //- Cell shapes
00116             mutable cellShapeList* cellShapesPtr_;
00117 
00118             //- Edges
00119             mutable edgeList* edgesPtr_;
00120 
00121 
00122         // Connectivity
00123 
00124             //- Cell-cells
00125             mutable labelListList* ccPtr_;
00126 
00127             //- Edge-cells
00128             mutable labelListList* ecPtr_;
00129 
00130             //- Point-cells
00131             mutable labelListList* pcPtr_;
00132 
00133             //- Cell-faces
00134             mutable cellList* cfPtr_;
00135 
00136             //- Edge-faces
00137             mutable labelListList* efPtr_;
00138 
00139             //- Point-faces
00140             mutable labelListList* pfPtr_;
00141 
00142             //- Cell-edges
00143             mutable labelListList* cePtr_;
00144 
00145             //- Face-edges
00146             mutable labelListList* fePtr_;
00147 
00148             //- Point-edges
00149             mutable labelListList* pePtr_;
00150 
00151             //- Point-points
00152             mutable labelListList* ppPtr_;
00153 
00154             //- Cell-points
00155             mutable labelListList* cpPtr_;
00156 
00157 
00158         // On-the-fly edge addresing storage
00159 
00160             //- Temporary storage for addressing.
00161             mutable DynamicList<label> labels_;
00162 
00163             //- Temporary storage for addressing
00164             mutable labelHashSet labelSet_;
00165 
00166 
00167         // Geometric data
00168 
00169             //- Cell centres
00170             mutable vectorField* cellCentresPtr_;
00171 
00172             //- Face centres
00173             mutable vectorField* faceCentresPtr_;
00174 
00175             //- Cell volumes
00176             mutable scalarField* cellVolumesPtr_;
00177 
00178             //- Face areas
00179             mutable vectorField* faceAreasPtr_;
00180 
00181 
00182     // Private member functions
00183 
00184         //- Disallow construct as copy
00185         primitiveMesh(const primitiveMesh&);
00186 
00187         //- Disallow default bitwise assignment
00188         void operator=(const primitiveMesh&);
00189 
00190 
00191         // Topological calculations
00192 
00193             //- Calculate cell shapes
00194             void calcCellShapes() const;
00195 
00196             //- Calculate cell-cell addressing
00197             void calcCellCells() const;
00198 
00199             //- Calculate point-cell addressing
00200             void calcPointCells() const;
00201 
00202             //- Calculate cell-face addressing
00203             void calcCells() const;
00204 
00205             //- Calculate edge list
00206             void calcCellEdges() const;
00207 
00208             //- Calculate point-point addressing
00209             void calcPointPoints() const;
00210 
00211             //- Calculate edges, pointEdges and faceEdges (if doFaceEdges=true)
00212             //  During edge calculation, a larger set of data is assembled.
00213             //  Create and destroy as a set, using clearOutEdges()
00214             void calcEdges(const bool doFaceEdges) const;
00215             void clearOutEdges();
00216             //- Helper: return (after optional creation) edge between two points
00217             static label getEdge
00218             (
00219                 List<DynamicList<label> >&,
00220                 DynamicList<edge>&,
00221                 const label,
00222                 const label
00223             );
00224             //- For on-the-fly addressing calculation
00225             static label findFirstCommonElementFromSortedLists
00226             ( 
00227                 const labelList&,
00228                 const labelList&
00229             );
00230 
00231 
00232         // Geometrical calculations
00233 
00234             //- Calculate face centres and areas
00235             void calcFaceCentresAndAreas() const;
00236             void makeFaceCentresAndAreas
00237             (
00238                 const pointField& p,
00239                 vectorField& fCtrs,
00240                 vectorField& fAreas
00241             ) const;
00242 
00243             //- Calculate cell centres and volumes
00244             void calcCellCentresAndVols() const;
00245             void makeCellCentresAndVols
00246             (
00247                 const vectorField& fCtrs,
00248                 const vectorField& fAreas,
00249                 vectorField& cellCtrs,
00250                 scalarField& cellVols
00251             ) const;
00252 
00253             //- Calculate edge vectors
00254             void calcEdgeVectors() const;
00255 
00256 
00257         // Helper functions for mesh checking
00258 
00259             //- Check if all points on face are shared with another face.
00260             bool checkDuplicateFaces
00261             (
00262                 const label,
00263                 const Map<label>&,
00264                 label& nBaffleFaces,
00265                 labelHashSet*
00266             ) const;
00267 
00268             //- Check that shared points are in consecutive order.
00269             bool checkCommonOrder
00270             (
00271                 const label,
00272                 const Map<label>&,
00273                 labelHashSet*
00274             ) const;
00275 
00276 
00277     // Static data members
00278 
00279         //- Static data to control mesh checking
00280 
00281             //- Cell closedness warning threshold
00282             //  set as the fraction of un-closed area to closed area
00283             static scalar closedThreshold_;
00284 
00285             //- Aspect ratio warning threshold
00286             static scalar aspectThreshold_;
00287 
00288             //- Non-orthogonality warning threshold in deg
00289             static scalar nonOrthThreshold_;
00290 
00291             //- Skewness warning threshold
00292             static scalar skewThreshold_;
00293 
00294 
00295 protected:
00296 
00297         //- Construct null
00298         primitiveMesh();
00299 
00300 
00301 public:
00302 
00303         // Static data
00304 
00305             ClassName("primitiveMesh");
00306 
00307             //- Estimated number of cells per edge
00308             static const unsigned cellsPerEdge_ = 4;
00309 
00310             //- Estimated number of cells per point
00311             static const unsigned cellsPerPoint_ = 8;
00312 
00313             //- Estimated number of faces per cell
00314             static const unsigned facesPerCell_ = 6;
00315 
00316             //- Estimated number of faces per edge
00317             static const unsigned facesPerEdge_ = 4;
00318 
00319             //- Estimated number of faces per point
00320             static const unsigned facesPerPoint_ = 12;
00321 
00322             //- Estimated number of edges per cell
00323             static const unsigned edgesPerCell_ = 12;
00324 
00325             //- Estimated number of edges per cell
00326             static const unsigned edgesPerFace_ = 4;
00327 
00328             //- Estimated number of edges per point
00329             static const unsigned edgesPerPoint_ = 6;
00330 
00331             //- Estimated number of points per cell
00332             static const unsigned pointsPerCell_ = 8;
00333 
00334             //- Estimated number of points per face
00335             static const unsigned pointsPerFace_ = 4;
00336 
00337 
00338     // Constructors
00339 
00340         //- Construct from components
00341         primitiveMesh
00342         (
00343             const label nPoints,
00344             const label nInternalFaces,
00345             const label nFaces,
00346             const label nCells
00347         );
00348 
00349 
00350     // Destructor
00351 
00352         virtual ~primitiveMesh();
00353 
00354 
00355     // Member Functions
00356 
00357         //- Reset this primitiveMesh given the primitive array sizes
00358         void reset
00359         (
00360             const label nPoints,
00361             const label nInternalFaces,
00362             const label nFaces,
00363             const label nCells
00364         );
00365 
00366         //- Reset this primitiveMesh given the primitive array sizes and cells
00367         void reset
00368         (
00369             const label nPoints,
00370             const label nInternalFaces,
00371             const label nFaces,
00372             const label nCells,
00373             cellList& cells
00374         );
00375 
00376 
00377         //- Reset this primitiveMesh given the primitive array sizes and cells
00378         void reset
00379         (
00380             const label nPoints,
00381             const label nInternalFaces,
00382             const label nFaces,
00383             const label nCells,
00384             const Xfer<cellList>& cells
00385         );
00386 
00387 
00388         // Access
00389 
00390             // Mesh size parameters
00391 
00392                 inline label nPoints() const;
00393                 inline label nEdges() const;
00394                 inline label nInternalFaces() const;
00395                 inline label nFaces() const;
00396                 inline label nCells() const;
00397 
00398                 // If points are ordered (nInternalPoints != -1):
00399 
00400                     //- Points not on boundary
00401                     inline label nInternalPoints() const;
00402 
00403                     //- Internal edges (i.e. not on boundary face) using
00404                     //  no boundary point
00405                     inline label nInternal0Edges() const;
00406                     //- Internal edges using 0 or 1 boundary point
00407                     inline label nInternal1Edges() const;
00408                     //- Internal edges using 0,1 or 2 boundary points
00409                     inline label nInternalEdges() const;
00410 
00411 
00412             // Primitive mesh data
00413 
00414                 //- Return mesh points
00415                 virtual const pointField& points() const = 0;
00416 
00417                 //- Return faces
00418                 virtual const faceList& faces() const = 0;
00419 
00420                 //- Face face-owner addresing
00421                 virtual const labelList& faceOwner() const = 0;
00422 
00423                 //- Face face-neighbour addressing
00424                 virtual const labelList& faceNeighbour() const = 0;
00425 
00426                 //- Return old points for mesh motion
00427                 virtual const pointField& oldPoints() const = 0;
00428 
00429 
00430             // Derived mesh data
00431 
00432                 //- Return cell shapes
00433                 const cellShapeList& cellShapes() const;
00434 
00435                 //- Return mesh edges. Uses calcEdges.
00436                 const edgeList& edges() const;
00437 
00438                 //- Helper function to calculate cell-face addressing from
00439                 //  face-cell addressing. If nCells is not provided it will
00440                 //  scan for the maximum.
00441                 static void calcCells
00442                 (
00443                     cellList&,
00444                     const unallocLabelList& own,
00445                     const unallocLabelList& nei,
00446                     const label nCells = -1
00447                 );
00448 
00449                 //- Helper function to calculate point ordering. Returns true
00450                 //  if points already ordered, false and fills pointMap (old to
00451                 //  new). Map splits points into those not used by any boundary
00452                 //  face and those that are.
00453                 static bool calcPointOrder
00454                 (
00455                     label& nInternalPoints,
00456                     labelList& pointMap,
00457                     const faceList&,
00458                     const label nInternalFaces,
00459                     const label nPoints
00460                 );
00461 
00462             // Return mesh connectivity
00463 
00464                 const labelListList& cellCells() const;
00465                 // faceCells given as owner and neighbour
00466                 const labelListList& edgeCells() const;
00467                 const labelListList& pointCells() const;
00468 
00469                 const cellList& cells() const;
00470                 // faceFaces considered unnecessary
00471                 const labelListList& edgeFaces() const;
00472                 const labelListList& pointFaces() const;
00473 
00474                 const labelListList& cellEdges() const;
00475                 const labelListList& faceEdges() const;
00476                 // edgeEdges considered unnecessary
00477                 const labelListList& pointEdges() const;
00478                 const labelListList& pointPoints() const;
00479                 const labelListList& cellPoints() const;
00480 
00481 
00482             // Geometric data (raw!)
00483 
00484                 const vectorField& cellCentres() const;
00485                 const vectorField& faceCentres() const;
00486                 const scalarField& cellVolumes() const;
00487                 const vectorField& faceAreas() const;
00488 
00489 
00490             // Mesh motion
00491 
00492                 //- Move points, returns volumes swept by faces in motion
00493                 tmp<scalarField> movePoints
00494                 (
00495                     const pointField& p,
00496                     const pointField& oldP
00497                 );
00498 
00499 
00500             //- Return true if given face label is internal to the mesh
00501             inline bool isInternalFace(const label faceIndex) const;
00502 
00503 
00504             // Topological checks
00505 
00506                 //- Check cell zip-up
00507                 bool checkCellsZipUp
00508                 (
00509                     const bool report = false,
00510                     labelHashSet* setPtr = NULL
00511                 ) const;
00512 
00513                 //- Check uniqueness of face vertices
00514                 bool checkFaceVertices
00515                 (
00516                     const bool report = false,
00517                     labelHashSet* setPtr = NULL
00518                 ) const;
00519 
00520                 //- Check face-face connectivity
00521                 bool checkFaceFaces
00522                 (
00523                     const bool report = false,
00524                     labelHashSet* setPtr = NULL
00525                 ) const;
00526 
00527                 //- Check face ordering
00528                 bool checkUpperTriangular
00529                 (
00530                     const bool report = false,
00531                     labelHashSet* setPtr = NULL
00532                 ) const;
00533 
00534 
00535             // Geometric checks
00536 
00537                 //- Check boundary for closedness
00538                 bool checkClosedBoundary(const bool report = false) const;
00539 
00540                 //- Check cells for closedness
00541                 bool checkClosedCells
00542                 (
00543                     const bool report = false,
00544                     labelHashSet* setPtr = NULL,
00545                     labelHashSet* highAspectSetPtr = NULL,
00546                     const Vector<label>& solutionD = Vector<label>::one
00547                 ) const;
00548 
00549                 //- Check for negative face areas
00550                 bool checkFaceAreas
00551                 (
00552                     const bool report = false,
00553                     labelHashSet* setPtr = NULL
00554                 ) const;
00555 
00556                 //- Check for negative cell volumes
00557                 bool checkCellVolumes
00558                 (
00559                     
00560                     const bool report = false,
00561                     labelHashSet* setPtr = NULL
00562                 ) const;
00563 
00564                 //- Check for non-orthogonality
00565                 bool checkFaceOrthogonality
00566                 (
00567                     const bool report = false,
00568                     labelHashSet* setPtr = NULL
00569                 ) const;
00570 
00571                 //- Check face pyramid volume
00572                 bool checkFacePyramids
00573                 (
00574                     const bool report = false,
00575                     const scalar minPyrVol = -SMALL,
00576                     labelHashSet* setPtr = NULL
00577                 ) const;
00578 
00579                 //- Check face skewness
00580                 bool checkFaceSkewness
00581                 (
00582                     const bool report = false,
00583                     labelHashSet* setPtr = NULL
00584                 ) const;
00585 
00586                 //- Check face angles
00587                 bool checkFaceAngles
00588                 (
00589                     const bool report = false,
00590                     const scalar maxSin = 10,    // In degrees
00591                     labelHashSet* setPtr = NULL
00592                 ) const;
00593 
00594                 //- Check face warpage: decompose face and check ratio between
00595                 //  magnitude of sum of triangle areas and sum of magnitude of
00596                 //  triangle areas.
00597                 bool checkFaceFlatness
00598                 (
00599                     const bool report,
00600                     const scalar warnFlatness,  // When to include in set.
00601                     labelHashSet* setPtr
00602                 ) const;
00603 
00604                 //- Check edge alignment for 1D/2D cases
00605                 bool checkEdgeAlignment
00606                 (
00607                     const bool report,
00608                     const Vector<label>& directions,
00609                     labelHashSet* setPtr = NULL
00610                 ) const;
00611 
00612                 //- Check for unused points
00613                 bool checkPoints
00614                 (
00615                     const bool report = false,
00616                     labelHashSet* setPtr = NULL
00617                 ) const;
00618 
00619                 //- Check for point-point-nearness,
00620                 //  e.g. colocated points which may be part of baffles.
00621                 bool checkPointNearness
00622                 (
00623                     const bool report,
00624                     const scalar reportDistSqr,
00625                     labelHashSet* setPtr = NULL
00626                 ) const;
00627 
00628                 //- Check edge length
00629                 bool checkEdgeLength
00630                 (
00631                     const bool report,
00632                     const scalar minLenSqr,
00633                     labelHashSet* setPtr = NULL
00634                 ) const;
00635 
00636                 //- Check cell determinant
00637                 bool checkCellDeterminant
00638                 (
00639                     const bool report = false,
00640                     labelHashSet* setPtr = NULL,
00641                     const Vector<label>& solutionD = Vector<label>::one
00642                 ) const;
00643 
00644 
00645             //- Check mesh topology for correctness.
00646             //  Returns false for no error.
00647             bool checkTopology(const bool report = false) const;
00648 
00649             //- Check mesh geometry (& implicitly topology) for correctness. 
00650             //  Returns false for no error.
00651             bool checkGeometry(const bool report = false) const;
00652 
00653             //- Check mesh for correctness. Returns false for no error.
00654             bool checkMesh(const bool report = false) const;
00655 
00656             //- Check mesh motion for correctness given motion points
00657             bool checkMeshMotion
00658             (
00659                 const pointField& newPoints,
00660                 const bool report = false
00661             ) const;
00662 
00663 
00664             //- Set the closedness ratio warning threshold
00665             static scalar setClosedThreshold(const scalar);
00666 
00667             //- Set the aspect ratio warning threshold
00668             static scalar setAspectThreshold(const scalar);
00669 
00670             //- Set the non-orthogonality warning threshold in degrees
00671             static scalar setNonOrthThreshold(const scalar);
00672 
00673             //- Set the skewness warning threshold as percentage
00674             //  of the face area vector
00675             static scalar setSkewThreshold(const scalar);
00676 
00677 
00678         // Useful derived info
00679 
00680             //- Is the point in the cell bounding box
00681             bool pointInCellBB(const point& p, label celli) const;
00682 
00683             //- Is the point in the cell
00684             bool pointInCell(const point& p, label celli) const;
00685 
00686             //- Find the cell with the nearest cell centre to location
00687             label findNearestCell(const point& location) const;
00688 
00689             //- Find cell enclosing this location (-1 if not in mesh)
00690             label findCell(const point& location) const;
00691 
00692 
00693         //  Storage management
00694 
00695             //- Print a list of all the currently allocated mesh data
00696             void printAllocated() const;
00697 
00698             // Per storage whether allocated
00699             inline bool hasCellShapes() const;
00700             inline bool hasEdges() const;
00701             inline bool hasCellCells() const;
00702             inline bool hasEdgeCells() const;
00703             inline bool hasPointCells() const;
00704             inline bool hasCells() const;
00705             inline bool hasEdgeFaces() const;
00706             inline bool hasPointFaces() const;
00707             inline bool hasCellEdges() const;
00708             inline bool hasFaceEdges() const;
00709             inline bool hasPointEdges() const;
00710             inline bool hasPointPoints() const;
00711             inline bool hasCellPoints() const;
00712             inline bool hasCellCentres() const;
00713             inline bool hasFaceCentres() const;
00714             inline bool hasCellVolumes() const;
00715             inline bool hasFaceAreas() const;
00716 
00717             // On-the-fly addressing calculation. These functions return either
00718             // a reference to the full addressing (if already calculated) or
00719             // a reference to the supplied storage. The one-argument ones
00720             // use member DynamicList labels_ so be careful when not storing
00721             // result.
00722 
00723             //- cellCells using cells.
00724             const labelList& cellCells
00725             (
00726                 const label cellI,
00727                 DynamicList<label>&
00728             ) const;
00729 
00730             const labelList& cellCells(const label cellI) const;
00731 
00732             //- cellPoints using cells
00733             const labelList& cellPoints
00734             (
00735                 const label cellI,
00736                 DynamicList<label>&
00737             ) const;
00738 
00739             const labelList& cellPoints(const label cellI) const;
00740 
00741             //- pointCells using pointFaces
00742             const labelList& pointCells
00743             (
00744                 const label pointI,
00745                 DynamicList<label>&
00746             ) const;
00747 
00748             const labelList& pointCells(const label pointI) const;
00749 
00750             //- pointPoints using edges, pointEdges
00751             const labelList& pointPoints
00752             (
00753                 const label pointI,
00754                 DynamicList<label>&
00755             ) const;
00756 
00757             const labelList& pointPoints(const label pointI) const;
00758 
00759             //- faceEdges using pointFaces, edges, pointEdges
00760             const labelList& faceEdges
00761             (
00762                 const label faceI,
00763                 DynamicList<label>&
00764             ) const;
00765 
00766             const labelList& faceEdges(const label faceI) const;
00767 
00768             //- edgeFaces using pointFaces, edges, pointEdges
00769             const labelList& edgeFaces
00770             (
00771                 const label edgeI,
00772                 DynamicList<label>&
00773             ) const;
00774 
00775             const labelList& edgeFaces(const label edgeI) const;
00776 
00777             //- edgeCells using pointFaces, edges, pointEdges
00778             const labelList& edgeCells
00779             (
00780                 const label edgeI,
00781                 DynamicList<label>&
00782             ) const;
00783 
00784             const labelList& edgeCells(const label edgeI) const;
00785 
00786             //- cellEdges using cells, pointFaces, edges, pointEdges
00787             const labelList& cellEdges
00788             (
00789                 const label cellI,
00790                 DynamicList<label>&
00791             ) const;
00792 
00793             const labelList& cellEdges(const label cellI) const;
00794 
00795 
00796             //- Clear geometry
00797             void clearGeom();
00798 
00799             //- Clear topological data
00800             void clearAddressing();
00801 
00802             //- Clear all geometry and addressing unnecessary for CFD
00803             void clearOut();
00804 };
00805 
00806 
00807 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00808 
00809 } // End namespace Foam
00810 
00811 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00812 
00813 #include "primitiveMeshI.H"
00814 
00815 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00816 
00817 #endif
00818 
00819 // ************************ vim: set sw=4 sts=4 et: ************************ //
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines