applications/test/primitivePatch/testPrimitivePatch.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2010 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25     Test new primitive patches.
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "argList.H"
  30 #include "Time.H"
  31 #include "polyMesh.H"
  32 #include "primitivePatch.H"
  33 #include "faceIOList.H"
  34 #include "IFstream.H"
  35 #include "OFstream.H"
  36
  37 using namespace Foam;
  38
  39 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  40
  41 typedef PrimitivePatch<face, List, const pointField&> myPrimitivePatch;
  42
  43
  44 void writeObj(Ostream& os,const pointField& points)
  45 {
  46     forAll(points, pointI)
  47     {
  48         const point& pt = points[pointI];
  49
  50         os << "v " << pt.x() << ' ' << pt.y()
  51             << ' ' << pt.z() << endl;
  52     }
  53 }
  54
  55
  56 void checkFaceEdges
  57 (
  58     const faceList& localFaces,
  59     const edgeList& edges,
  60     const labelListList& faceEdges
  61 )
  62 {
  63     forAll(faceEdges, faceI)
  64     {
  65         const face& f = localFaces[faceI];
  66
  67         const labelList& myEdges = faceEdges[faceI];
  68
  69         forAll(f, fp)
  70         {
  71             label fp1 = f.fcIndex(fp);
  72
  73             if (edges[myEdges[fp]] != edge(f[fp], f[fp1]))
  74             {
  75                 FatalErrorIn("checkFaceEdges")
  76                     << "Edges of face not in face point order:"
  77                     << "face:" << faceI << " localF:" << f
  78                     << " faceEdges:" << myEdges
  79                     << abort(FatalError);
  80             }
  81         }
  82     }
  83 }
  84
  85
  86 void writeEdges
  87 (
  88     const pointField& localPoints,
  89     const edgeList& edges,
  90     const label nInternalEdges
  91 )
  92 {
  93     Info<< "Writing internal edges to internalEdges.obj" << nl << endl;
  94
  95     OFstream intStream("internalEdges.obj");
  96
  97     writeObj(intStream, localPoints);
  98
  99     for (label edgeI = 0; edgeI < nInternalEdges; edgeI++)
 100     {
 101         const edge& e = edges[edgeI];
 102
 103         intStream << "l " << e.start()+1 << ' ' << e.end()+1 << endl;
 104     }
 105
 106     Info<< "Writing boundary edges to boundaryEdges.obj" << nl << endl;
 107
 108     OFstream bndStream("boundaryEdges.obj");
 109
 110     writeObj(bndStream, localPoints);
 111
 112     for (label edgeI = nInternalEdges; edgeI < edges.size(); edgeI++)
 113     {
 114         const edge& e = edges[edgeI];
 115
 116         bndStream << "l " << e.start()+1 << ' ' << e.end()+1 << endl;
 117     }
 118 }
 119
 120
 121 void writeFaceEdges
 122 (
 123     const pointField& localPoints,
 124     const edgeList& edges,
 125     const labelListList& faceEdges
 126 )
 127 {
 128     Info<< "Writing faceEdges per face to faceEdges.obj" << nl << endl;
 129
 130     OFstream feStream("faceEdges.obj");
 131
 132     writeObj(feStream, localPoints);
 133
 134     forAll(faceEdges, faceI)
 135     {
 136         const labelList& myEdges = faceEdges[faceI];
 137
 138         forAll(myEdges, i)
 139         {
 140             const edge& e = edges[myEdges[i]];
 141
 142             feStream<< "l " << e.start()+1 << ' ' << e.end()+1 << endl;
 143         }
 144     }
 145 }
 146
 147
 148 void writeEdgeFaces
 149 (
 150     const pointField& localPoints,
 151     const faceList& localFaces,
 152     const edgeList& edges,
 153     const labelListList& edgeFaces
 154 )
 155 {
 156     Info<< "Writing edgeFaces per face to edgeFaces.obj" << nl << endl;
 157
 158     OFstream efStream("edgeFaces.obj");
 159
 160     pointField ctrs(localFaces.size(), vector::zero);
 161
 162     forAll(localFaces, faceI)
 163     {
 164         ctrs[faceI] = localFaces[faceI].centre(localPoints);
 165     }
 166     writeObj(efStream, ctrs);
 167
 168
 169     forAll(edgeFaces, edgeI)
 170     {
 171         const labelList& myFaces = edgeFaces[edgeI];
 172
 173         forAll(myFaces, i)
 174         {
 175             efStream<< "l " << myFaces[0]+1 << ' ' << myFaces[i]+1 << endl;
 176         }
 177     }
 178 }
 179
 180
 181 void writeFaceFaces
 182 (
 183     const pointField& localPoints,
 184     const faceList& localFaces,
 185     const labelListList& faceFaces
 186 )
 187 {
 188     Info<< "Writing faceFaces per face to faceFaces.obj" << nl << endl;
 189
 190     OFstream ffStream("faceFaces.obj");
 191
 192     pointField ctrs(localFaces.size(), vector::zero);
 193
 194     forAll(localFaces, faceI)
 195     {
 196         ctrs[faceI] = localFaces[faceI].centre(localPoints);
 197     }
 198     writeObj(ffStream, ctrs);
 199
 200     forAll(faceFaces, faceI)
 201     {
 202         const labelList& nbrs = faceFaces[faceI];
 203
 204         forAll(nbrs, nbI)
 205         {
 206             ffStream << "l " << faceI+1 << ' ' << nbrs[nbI]+1 << endl;
 207         }
 208     }
 209 }
 210
 211
 212 // Main program:
 213
 214 int main(int argc, char *argv[])
 215 {
 216     argList::noParallel();
 217     argList::validArgs.append("patch");
 218
 219 #   include "setRootCase.H"
 220 #   include "createTime.H"
 221 #   include "createPolyMesh.H"
 222
 223     word patchName(args.additionalArgs()[0]);
 224
 225     label patchI = mesh.boundaryMesh().findPatchID(patchName);
 226
 227     const polyPatch& patch = mesh.boundaryMesh()[patchI];
 228
 229     Info<< "Patch:" << patch.name() << endl;
 230
 231     PrimitivePatch<face, List, const pointField&> pp(patch, patch.points());
 232
 233     const pointField& localPoints = pp.localPoints();
 234     const faceList& localFaces = pp.localFaces();
 235     const labelListList& faceFaces = pp.faceFaces();
 236     const edgeList& edges = pp.edges();
 237     const labelListList& edgeFaces = pp.edgeFaces();
 238     const labelListList& faceEdges = pp.faceEdges();
 239
 240
 241     checkFaceEdges(localFaces, edges, faceEdges);
 242
 243     writeEdges(localPoints, edges, pp.nInternalEdges());
 244
 245     writeFaceEdges(localPoints, edges, faceEdges);
 246
 247     writeEdgeFaces(localPoints, localFaces, edges, edgeFaces);
 248
 249     writeFaceFaces(localPoints, localFaces, faceFaces);
 250
 251     Info << "End\n" << endl;
 252
 253     return 0;
 254 }
 255
 256
 257 // ************************************************************************* //