applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMesh.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25
  26 \*---------------------------------------------------------------------------*/
  27
  28 #include "vtkPV3Foam.H"
  29
  30 // Foam includes
  31 #include "cellSet.H"
  32 #include "faceSet.H"
  33 #include "pointSet.H"
  34 #include "fvMeshSubset.H"
  35 #include "vtkPV3FoamReader.h"
  36
  37 // VTK includes
  38 #include "vtkDataArraySelection.h"
  39 #include "vtkMultiBlockDataSet.h"
  40 #include "vtkPolyData.h"
  41 #include "vtkUnstructuredGrid.h"
  42
  43 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  44
  45 void Foam::vtkPV3Foam::convertMeshVolume
  46 (
  47     vtkMultiBlockDataSet* output,
  48     int& blockNo
  49 )
  50 {
  51     partInfo& selector = partInfoVolume_;
  52     selector.block(blockNo);   // set output block
  53     label datasetNo = 0;       // restart at dataset 0
  54     const fvMesh& mesh = *meshPtr_;
  55
  56     // resize for decomposed polyhedra
  57     regionPolyDecomp_.setSize(selector.size());
  58
  59     if (debug)
  60     {
  61         Info<< "<beg> Foam::vtkPV3Foam::convertMeshVolume" << endl;
  62         printMemory();
  63     }
  64
  65     // Convert the internalMesh
  66     // this looks like more than one part, but it isn't
  67     for (int partId = selector.start(); partId < selector.end(); ++partId)
  68     {
  69         const word partName = "internalMesh";
  70
  71         if (!partStatus_[partId])
  72         {
  73             continue;
  74         }
  75
  76         vtkUnstructuredGrid* vtkmesh = volumeVTKMesh
  77         (
  78             mesh,
  79             regionPolyDecomp_[datasetNo]
  80         );
  81
  82         if (vtkmesh)
  83         {
  84             AddToBlock(output, vtkmesh, selector, datasetNo, partName);
  85             vtkmesh->Delete();
  86
  87             partDataset_[partId] = datasetNo++;
  88         }
  89     }
  90
  91     // anything added?
  92     if (datasetNo)
  93     {
  94         ++blockNo;
  95     }
  96
  97     if (debug)
  98     {
  99         Info<< "<end> Foam::vtkPV3Foam::convertMeshVolume" << endl;
 100         printMemory();
 101     }
 102 }
 103
 104
 105 void Foam::vtkPV3Foam::convertMeshLagrangian
 106 (
 107     vtkMultiBlockDataSet* output,
 108     int& blockNo
 109 )
 110 {
 111     partInfo& selector = partInfoLagrangian_;
 112     selector.block(blockNo);   // set output block
 113     label datasetNo = 0;       // restart at dataset 0
 114     const fvMesh& mesh = *meshPtr_;
 115
 116     if (debug)
 117     {
 118         Info<< "<beg> Foam::vtkPV3Foam::convertMeshLagrangian" << endl;
 119         printMemory();
 120     }
 121
 122     for (int partId = selector.start(); partId < selector.end(); ++partId)
 123     {
 124         const word cloudName = getPartName(partId);
 125
 126         if (!partStatus_[partId])
 127         {
 128             continue;
 129         }
 130
 131         vtkPolyData* vtkmesh = lagrangianVTKMesh(mesh, cloudName);
 132
 133         if (vtkmesh)
 134         {
 135             AddToBlock(output, vtkmesh, selector, datasetNo, cloudName);
 136             vtkmesh->Delete();
 137
 138             partDataset_[partId] = datasetNo++;
 139         }
 140     }
 141
 142     // anything added?
 143     if (datasetNo)
 144     {
 145         ++blockNo;
 146     }
 147
 148     if (debug)
 149     {
 150         Info<< "<end> Foam::vtkPV3Foam::convertMeshLagrangian" << endl;
 151         printMemory();
 152     }
 153 }
 154
 155
 156 void Foam::vtkPV3Foam::convertMeshPatches
 157 (
 158     vtkMultiBlockDataSet* output,
 159     int& blockNo
 160 )
 161 {
 162     partInfo& selector = partInfoPatches_;
 163     selector.block(blockNo);   // set output block
 164     label datasetNo = 0;       // restart at dataset 0
 165     const fvMesh& mesh = *meshPtr_;
 166     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 167
 168     if (debug)
 169     {
 170         Info<< "<beg> Foam::vtkPV3Foam::convertMeshPatches" << endl;
 171         printMemory();
 172     }
 173
 174     for (int partId = selector.start(); partId < selector.end(); ++partId)
 175     {
 176         const word patchName = getPartName(partId);
 177         const label  patchId = patches.findPatchID(patchName);
 178
 179         if (!partStatus_[partId] || patchId < 0)
 180         {
 181             continue;
 182         }
 183
 184         if (debug)
 185         {
 186             Info<< "Creating VTK mesh for patch[" << patchId <<"] "
 187                 << patchName  << endl;
 188         }
 189
 190         vtkPolyData* vtkmesh = patchVTKMesh(patches[patchId]);
 191
 192         if (vtkmesh)
 193         {
 194             AddToBlock(output, vtkmesh, selector, datasetNo, patchName);
 195             vtkmesh->Delete();
 196
 197             partDataset_[partId] = datasetNo++;
 198         }
 199     }
 200
 201     // anything added?
 202     if (datasetNo)
 203     {
 204         ++blockNo;
 205     }
 206
 207     if (debug)
 208     {
 209         Info<< "<end> Foam::vtkPV3Foam::convertMeshPatches" << endl;
 210         printMemory();
 211     }
 212 }
 213
 214
 215 void Foam::vtkPV3Foam::convertMeshCellZones
 216 (
 217     vtkMultiBlockDataSet* output,
 218     int& blockNo
 219 )
 220 {
 221     partInfo& selector = partInfoCellZones_;
 222     selector.block(blockNo);   // set output block
 223     label datasetNo = 0;       // restart at dataset 0
 224     const fvMesh& mesh = *meshPtr_;
 225
 226     // resize for decomposed polyhedra
 227     zonePolyDecomp_.setSize(selector.size());
 228
 229     if (!selector.size())
 230     {
 231         return;
 232     }
 233
 234     if (debug)
 235     {
 236         Info<< "<beg> Foam::vtkPV3Foam::convertMeshCellZones" << endl;
 237         printMemory();
 238     }
 239
 240     const cellZoneMesh& zMesh = mesh.cellZones();
 241     for (int partId = selector.start(); partId < selector.end(); ++partId)
 242     {
 243         const word zoneName = getPartName(partId);
 244         const label  zoneId = zMesh.findZoneID(zoneName);
 245
 246         if (!partStatus_[partId] || zoneId < 0)
 247         {
 248             continue;
 249         }
 250
 251         if (debug)
 252         {
 253             Info<< "Creating VTK mesh for cellZone[" << zoneId << "] "
 254                 << zoneName << endl;
 255         }
 256
 257         fvMeshSubset subsetMesh
 258         (
 259             IOobject
 260             (
 261                 "set",
 262                 mesh.time().constant(),
 263                 mesh,
 264                 IOobject::NO_READ,
 265                 IOobject::NO_WRITE
 266             ),
 267             mesh
 268         );
 269
 270         subsetMesh.setLargeCellSubset(labelHashSet(zMesh[zoneId]));
 271
 272         vtkUnstructuredGrid* vtkmesh = volumeVTKMesh
 273         (
 274             subsetMesh.subMesh(),
 275             zonePolyDecomp_[datasetNo]
 276         );
 277
 278         if (vtkmesh)
 279         {
 280             // superCells + addPointCellLabels must contain global cell ids
 281             inplaceRenumber
 282             (
 283                 subsetMesh.cellMap(),
 284                 zonePolyDecomp_[datasetNo].superCells()
 285             );
 286             inplaceRenumber
 287             (
 288                 subsetMesh.cellMap(),
 289                 zonePolyDecomp_[datasetNo].addPointCellLabels()
 290             );
 291
 292             // copy pointMap as well, otherwise pointFields fail
 293             zonePolyDecomp_[datasetNo].pointMap() = subsetMesh.pointMap();
 294
 295             AddToBlock(output, vtkmesh, selector, datasetNo, zoneName);
 296             vtkmesh->Delete();
 297
 298             partDataset_[partId] = datasetNo++;
 299         }
 300     }
 301
 302     // anything added?
 303     if (datasetNo)
 304     {
 305         ++blockNo;
 306     }
 307
 308     if (debug)
 309     {
 310         Info<< "<end> Foam::vtkPV3Foam::convertMeshCellZones" << endl;
 311         printMemory();
 312     }
 313 }
 314
 315
 316 void Foam::vtkPV3Foam::convertMeshCellSets
 317 (
 318     vtkMultiBlockDataSet* output,
 319     int& blockNo
 320 )
 321 {
 322     partInfo& selector = partInfoCellSets_;
 323     selector.block(blockNo);   // set output block
 324     label datasetNo = 0;       // restart at dataset 0
 325     const fvMesh& mesh = *meshPtr_;
 326
 327     // resize for decomposed polyhedra
 328     csetPolyDecomp_.setSize(selector.size());
 329
 330     if (debug)
 331     {
 332         Info<< "<beg> Foam::vtkPV3Foam::convertMeshCellSets" << endl;
 333         printMemory();
 334     }
 335
 336     for (int partId = selector.start(); partId < selector.end(); ++partId)
 337     {
 338         const word partName = getPartName(partId);
 339
 340         if (!partStatus_[partId])
 341         {
 342             continue;
 343         }
 344
 345         if (debug)
 346         {
 347             Info<< "Creating VTK mesh for cellSet=" << partName << endl;
 348         }
 349
 350         const cellSet cSet(mesh, partName);
 351
 352         fvMeshSubset subsetMesh
 353         (
 354             IOobject
 355             (
 356                 "set",
 357                 mesh.time().constant(),
 358                 mesh,
 359                 IOobject::NO_READ,
 360                 IOobject::NO_WRITE
 361             ),
 362             mesh
 363         );
 364
 365         subsetMesh.setLargeCellSubset(cSet);
 366
 367         vtkUnstructuredGrid* vtkmesh = volumeVTKMesh
 368         (
 369             subsetMesh.subMesh(),
 370             csetPolyDecomp_[datasetNo]
 371         );
 372
 373         if (vtkmesh)
 374         {
 375             // superCells + addPointCellLabels must contain global cell ids
 376             inplaceRenumber
 377             (
 378                 subsetMesh.cellMap(),
 379                 csetPolyDecomp_[datasetNo].superCells()
 380             );
 381             inplaceRenumber
 382             (
 383                 subsetMesh.cellMap(),
 384                 csetPolyDecomp_[datasetNo].addPointCellLabels()
 385             );
 386
 387             // copy pointMap as well, otherwise pointFields fail
 388             csetPolyDecomp_[datasetNo].pointMap() = subsetMesh.pointMap();
 389
 390             AddToBlock(output, vtkmesh, selector, datasetNo, partName);
 391             vtkmesh->Delete();
 392
 393             partDataset_[partId] = datasetNo++;
 394         }
 395     }
 396
 397     // anything added?
 398     if (datasetNo)
 399     {
 400         ++blockNo;
 401     }
 402
 403     if (debug)
 404     {
 405         Info<< "<end> Foam::vtkPV3Foam::convertMeshCellSets" << endl;
 406         printMemory();
 407     }
 408 }
 409
 410
 411 void Foam::vtkPV3Foam::convertMeshFaceZones
 412 (
 413     vtkMultiBlockDataSet* output,
 414     int& blockNo
 415 )
 416 {
 417     partInfo& selector = partInfoFaceZones_;
 418     selector.block(blockNo);   // set output block
 419     label datasetNo = 0;       // restart at dataset 0
 420     const fvMesh& mesh = *meshPtr_;
 421
 422     if (!selector.size())
 423     {
 424         return;
 425     }
 426
 427     if (debug)
 428     {
 429         Info<< "<beg> Foam::vtkPV3Foam::convertMeshFaceZones" << endl;
 430         printMemory();
 431     }
 432
 433     const faceZoneMesh& zMesh = mesh.faceZones();
 434     for (int partId = selector.start(); partId < selector.end(); ++partId)
 435     {
 436         const word zoneName = getPartName(partId);
 437         const label  zoneId = zMesh.findZoneID(zoneName);
 438
 439         if (!partStatus_[partId] || zoneId < 0)
 440         {
 441             continue;
 442         }
 443
 444         if (debug)
 445         {
 446             Info<< "Creating VTKmesh for faceZone[" << zoneId << "] "
 447                 << zoneName << endl;
 448         }
 449
 450         vtkPolyData* vtkmesh = faceZoneVTKMesh(mesh, zMesh[zoneId]);
 451         if (vtkmesh)
 452         {
 453             AddToBlock(output, vtkmesh, selector, datasetNo, zoneName);
 454             vtkmesh->Delete();
 455
 456             partDataset_[partId] = datasetNo++;
 457         }
 458     }
 459
 460     // anything added?
 461     if (datasetNo)
 462     {
 463         ++blockNo;
 464     }
 465
 466     if (debug)
 467     {
 468         Info<< "<end> Foam::vtkPV3Foam::convertMeshFaceZones" << endl;
 469         printMemory();
 470     }
 471 }
 472
 473
 474 void Foam::vtkPV3Foam::convertMeshFaceSets
 475 (
 476     vtkMultiBlockDataSet* output,
 477     int& blockNo
 478 )
 479 {
 480     partInfo& selector = partInfoFaceSets_;
 481     selector.block(blockNo);   // set output block
 482     label datasetNo = 0;       // restart at dataset 0
 483     const fvMesh& mesh = *meshPtr_;
 484
 485     if (debug)
 486     {
 487         Info<< "<beg> Foam::vtkPV3Foam::convertMeshFaceSets" << endl;
 488         printMemory();
 489     }
 490
 491     for (int partId = selector.start(); partId < selector.end(); ++partId)
 492     {
 493         const word partName = getPartName(partId);
 494
 495         if (!partStatus_[partId])
 496         {
 497             continue;
 498         }
 499
 500         if (debug)
 501         {
 502             Info<< "Creating VTK mesh for faceSet=" << partName << endl;
 503         }
 504
 505         const faceSet fSet(mesh, partName);
 506
 507         vtkPolyData* vtkmesh = faceSetVTKMesh(mesh, fSet);
 508         if (vtkmesh)
 509         {
 510             AddToBlock(output, vtkmesh, selector, datasetNo, partName);
 511             vtkmesh->Delete();
 512
 513             partDataset_[partId] = datasetNo++;
 514         }
 515     }
 516
 517     // anything added?
 518     if (datasetNo)
 519     {
 520         ++blockNo;
 521     }
 522
 523     if (debug)
 524     {
 525         Info<< "<end> Foam::vtkPV3Foam::convertMeshFaceSets" << endl;
 526         printMemory();
 527     }
 528 }
 529
 530
 531 void Foam::vtkPV3Foam::convertMeshPointZones
 532 (
 533     vtkMultiBlockDataSet* output,
 534     int& blockNo
 535 )
 536 {
 537     partInfo& selector = partInfoPointZones_;
 538     selector.block(blockNo);   // set output block
 539     label datasetNo = 0;       // restart at dataset 0
 540     const fvMesh& mesh = *meshPtr_;
 541
 542     if (debug)
 543     {
 544         Info<< "<beg> Foam::vtkPV3Foam::convertMeshPointZones" << endl;
 545         printMemory();
 546     }
 547
 548     if (selector.size())
 549     {
 550         const pointZoneMesh& zMesh = mesh.pointZones();
 551         for (int partId = selector.start(); partId < selector.end(); ++partId)
 552         {
 553             word zoneName = getPartName(partId);
 554             label zoneId = zMesh.findZoneID(zoneName);
 555
 556             if (!partStatus_[partId] || zoneId < 0)
 557             {
 558                 continue;
 559             }
 560
 561             vtkPolyData* vtkmesh = pointZoneVTKMesh(mesh, zMesh[zoneId]);
 562             if (vtkmesh)
 563             {
 564                 AddToBlock(output, vtkmesh, selector, datasetNo, zoneName);
 565                 vtkmesh->Delete();
 566
 567                 partDataset_[partId] = datasetNo++;
 568             }
 569         }
 570     }
 571
 572     // anything added?
 573     if (datasetNo)
 574     {
 575         ++blockNo;
 576     }
 577
 578     if (debug)
 579     {
 580         Info<< "<end> Foam::vtkPV3Foam::convertMeshPointZones" << endl;
 581         printMemory();
 582     }
 583 }
 584
 585
 586
 587 void Foam::vtkPV3Foam::convertMeshPointSets
 588 (
 589     vtkMultiBlockDataSet* output,
 590     int& blockNo
 591 )
 592 {
 593     partInfo& selector = partInfoPointSets_;
 594     selector.block(blockNo);   // set output block
 595     label datasetNo = 0;       // restart at dataset 0
 596     const fvMesh& mesh = *meshPtr_;
 597
 598     if (debug)
 599     {
 600         Info<< "<beg> Foam::vtkPV3Foam::convertMeshPointSets" << endl;
 601         printMemory();
 602     }
 603
 604     for (int partId = selector.start(); partId < selector.end(); ++partId)
 605     {
 606         word partName = getPartName(partId);
 607
 608         if (!partStatus_[partId])
 609         {
 610             continue;
 611         }
 612
 613         if (debug)
 614         {
 615             Info<< "Creating VTK mesh for pointSet=" << partName << endl;
 616         }
 617
 618         const pointSet pSet(mesh, partName);
 619
 620         vtkPolyData* vtkmesh = pointSetVTKMesh(mesh, pSet);
 621         if (vtkmesh)
 622         {
 623             AddToBlock(output, vtkmesh, selector, datasetNo, partName);
 624             vtkmesh->Delete();
 625
 626             partDataset_[partId] = datasetNo++;
 627         }
 628     }
 629
 630     // anything added?
 631     if (datasetNo)
 632     {
 633         ++blockNo;
 634     }
 635
 636     if (debug)
 637     {
 638         Info<< "<end> Foam::vtkPV3Foam::convertMeshPointSets" << endl;
 639         printMemory();
 640     }
 641 }
 642
 643 // ************************************************************************* //