applications/test/router/processorRouter.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Description
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "argList.H"
  30 #include "label.H"
  31 #include "labelList.H"
  32 #include "OStringStream.H"
  33 #include "IStringStream.H"
  34 #include "OFstream.H"
  35 #include "IFstream.H"
  36 #include "point.H"
  37 #include "Time.H"
  38 #include "fvMesh.H"
  39 #include "router.H"
  40 #include "processorPolyPatch.H"
  41 #include "typeInfo.H"
  42 #include "Gather.H"
  43
  44
  45 using namespace Foam;
  46
  47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  48
  49 // Get list of my processor neighbours
  50 labelList procNeighbours(const polyMesh& mesh)
  51 {
  52     word procLabel = '[' + word(name(Pstream::myProcNo())) + "]-";
  53
  54     label nNeighbours = 0;
  55
  56     forAll (mesh.boundaryMesh(), patchI)
  57     {
  58         if (typeid(mesh.boundaryMesh()[patchI]) == typeid(processorPolyPatch))
  59         {
  60             nNeighbours++;
  61         }
  62     }
  63
  64     labelList neighbours(nNeighbours);
  65
  66     nNeighbours = 0;
  67
  68     forAll (mesh.boundaryMesh(), patchI)
  69     {
  70         if (typeid(mesh.boundaryMesh()[patchI]) == typeid(processorPolyPatch))
  71         {
  72             const polyPatch& patch = mesh.boundaryMesh()[patchI];
  73
  74             const processorPolyPatch& procPatch =
  75                 refCast<const processorPolyPatch>(patch);
  76
  77             label procId = procPatch.neighbProcNo() - Pstream::firstSlave() + 1;
  78
  79             neighbours[nNeighbours++] = procId;
  80         }
  81     }
  82
  83     return neighbours;
  84 }
  85
  86
  87 // Calculate some average position for mesh.
  88 point meshCentre(const polyMesh& mesh)
  89 {
  90     return average(mesh.points());
  91 }
  92
  93
  94 // Main program:
  95
  96
  97 int main(int argc, char *argv[])
  98 {
  99 #   include "setRootCase.H"
 100 #   include "createTime.H"
 101 #   include "createMesh.H"
 102
 103     word procLabel = '[' + word(name(Pstream::myProcNo())) + "]-";
 104
 105     if (!Pstream::parRun())
 106     {
 107         FatalErrorIn(args.executable())
 108             << "Please run in parallel" << exit(FatalError);
 109     }
 110
 111     // 'Gather' processor-processor topology
 112     Gather<labelList> connections
 113     (
 114         static_cast<const labelList&>(procNeighbours(mesh))
 115     );
 116
 117     // Collect centres of individual meshes (for visualization only)
 118     Gather<point> meshCentres(meshCentre(mesh));
 119
 120     if (!Pstream::master())
 121     {
 122         return 0;
 123     }
 124
 125
 126     //
 127     // At this point we have the connections between processors and the
 128     // processor-mesh centres.
 129     //
 130
 131     Info<< "connections:" << connections << endl;
 132     Info<< "meshCentres:" << meshCentres << endl;
 133
 134
 135     //
 136     // Dump connections and meshCentres to OBJ file
 137     //
 138
 139     fileName fName("decomposition.obj");
 140
 141     Info<< "Writing decomposition to " << fName << endl;
 142
 143     OFstream objFile(fName);
 144
 145     // Write processors as single vertex in centre of mesh
 146     forAll(meshCentres, procI)
 147     {
 148         const point& pt = meshCentres[procI];
 149
 150         objFile << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
 151     }
 152     // Write connections as lines between processors (duplicated)
 153     forAll(connections, procI)
 154     {
 155         const labelList& nbs = connections[procI];
 156
 157         forAll(nbs, nbI)
 158         {
 159             objFile << "l " << procI + 1 << ' ' << nbs[nbI] + 1 << endl;
 160         }
 161     }
 162
 163
 164     //
 165     // Read paths to route from dictionary
 166     //
 167
 168     IFstream dictFile("routerDict");
 169
 170     dictionary routeDict(dictFile);
 171
 172     labelListList paths(routeDict.lookup("paths"));
 173
 174
 175
 176     //
 177     // Iterate over routing. Route as much as possible during each iteration
 178     // and stop if all paths have been routed. No special ordering to maximize
 179     // routing during one iteration.
 180     //
 181
 182     boolList routeOk(paths.size(), false);
 183     label nOk = 0;
 184
 185     label iter = 0;
 186
 187     while (nOk < paths.size())
 188     {
 189         Info<< "Iteration:" << iter << endl;
 190         Info<< "---------------" << endl;
 191
 192
 193         // Dump to OBJ file
 194
 195         fileName fName("route_" + name(iter) + ".obj");
 196         Info<< "Writing route to " << fName << endl;
 197
 198         OFstream objFile(fName);
 199
 200         forAll(meshCentres, procI)
 201         {
 202             const point& pt = meshCentres[procI];
 203
 204             objFile << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z()
 205                     << endl;
 206         }
 207
 208
 209         // Router
 210         router cellRouter(connections, meshCentres);
 211
 212         // Try to route as many paths possible during this iteration.
 213         forAll(paths, pathI)
 214         {
 215             if (!routeOk[pathI])
 216             {
 217                 const labelList& path = paths[pathI];
 218
 219                 Info<< "Trying to route path " << pathI
 220                     << " nodes " << path << endl;
 221
 222                 routeOk[pathI] = cellRouter.route(path, -(pathI + 1));
 223
 224                 Info<< "Result of routing:" << routeOk[pathI] << endl;
 225
 226                 if (routeOk[pathI])
 227                 {
 228                     nOk++;
 229
 230                     // Dump route as lines.
 231                     labelList route(cellRouter.getRoute(-(pathI + 1)));
 232
 233                     for(label elemI = 1; elemI < route.size(); elemI++)
 234                     {
 235                         objFile
 236                             << "l " << route[elemI-1]+1 << ' '
 237                             << route[elemI]+1 << endl;
 238                     }
 239                     Info<< "route:" << route << endl;
 240                 }
 241             }
 242         }
 243         Info<< endl;
 244
 245         iter++;
 246     }
 247
 248     Info<< "End\n" << endl;
 249
 250     return 0;
 251 }
 252
 253
 254 // ************************************************************************* //