src/mesh/cfMesh/meshLibrary/utilities/checkMeshDict/checkMeshDict.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | cfMesh: A library for mesh generation
   4    \\    /   O peration     |
   5     \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
   6      \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of cfMesh.
  10
  11     cfMesh 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     cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25
  26 \*---------------------------------------------------------------------------*/
  27
  28 #include "checkMeshDict.H"
  29 #include "patchRefinementList.H"
  30 #include "PtrList.H"
  31 #include "LongList.H"
  32 #include "objectRefinement.H"
  33
  34 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  35
  36 namespace Foam
  37 {
  38
  39 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  40
  41 void checkMeshDict::checkPatchCellSize() const
  42 {
  43     if( meshDict_.found("patchCellSize") )
  44     {
  45         if( meshDict_.isDict("patchCellSize") )
  46         {
  47             const dictionary& dict = meshDict_.subDict("patchCellSize");
  48
  49             const wordList patchNames = dict.toc();
  50             patchNames.size();
  51         }
  52         else
  53         {
  54             patchRefinementList prl(meshDict_.lookup("patchCellSize"));
  55             prl.size();
  56         }
  57     }
  58 }
  59
  60 void checkMeshDict::checkSubsetCellSize() const
  61 {
  62     if( meshDict_.found("subsetCellSize") )
  63     {
  64         if( meshDict_.isDict("subsetCellSize") )
  65         {
  66             const dictionary& dict = meshDict_.subDict("subsetCellSize");
  67
  68             const wordList subsetNames = dict.toc();
  69             subsetNames.size();
  70         }
  71         else
  72         {
  73             patchRefinementList prl(meshDict_.lookup("patchCellSize"));
  74         }
  75     }
  76 }
  77
  78 void checkMeshDict::checkLocalRefinementLevel() const
  79 {
  80     if( meshDict_.found("localRefinement") )
  81     {
  82         if( meshDict_.isDict("localRefinement") )
  83         {
  84             const dictionary& refDict = meshDict_.subDict("localRefinement");
  85             const wordList entries = refDict.toc();
  86
  87             forAll(entries, dictI)
  88             {
  89                 const dictionary& dict = refDict.subDict(entries[dictI]);
  90
  91                 if( dict.found("cellSize") )
  92                 {
  93                     const scalar cs = readScalar(dict.lookup("cellSize"));
  94
  95                     if( cs > 0.0 )
  96                         continue;
  97
  98                     WarningIn
  99                     (
 100                         "void checkMeshDict::checkLocalRefinementLevel() const"
 101                     ) << "Cell size for " << entries[dictI]
 102                          << " is negative" << endl;
 103                 }
 104                 else if( dict.found("additionalRefinementLevels") )
 105                 {
 106                     const label nLevels =
 107                         readLabel(dict.lookup("additionalRefinementLevels"));
 108
 109                     if( nLevels > 0 )
 110                         continue;
 111
 112                     WarningIn
 113                     (
 114                         "void checkMeshDict::checkLocalRefinementLevel() const"
 115                     ) << "Refinement level for " << entries[dictI]
 116                          << " is negative" << endl;
 117                 }
 118                 else
 119                 {
 120                     FatalErrorIn
 121                     (
 122                         "void checkMeshDict::checkLocalRefinementLevel() const"
 123                     ) << "Cannot read keyword"
 124                       << " additionalRefinementLevels or cellSize"
 125                       << "for " << entries[dictI] << exit(FatalError);
 126                 }
 127             }
 128         }
 129         else
 130         {
 131             FatalErrorIn
 132             (
 133                 "void checkMeshDict::checkLocalRefinementLevel() const"
 134             ) << "Cannot read localRefinement" << exit(FatalError);
 135         }
 136     }
 137 }
 138
 139 void checkMeshDict::checkKeepCellsIntersectingPatches() const
 140 {
 141     if( meshDict_.found("keepCellsIntersectingPatches") )
 142     {
 143         if( meshDict_.isDict("keepCellsIntersectingPatches") )
 144         {
 145             const dictionary& dict =
 146                 meshDict_.subDict("keepCellsIntersectingPatches");
 147
 148             const wordList patchNames = dict.toc();
 149             patchNames.size();
 150         }
 151         else
 152         {
 153             wordList kcip(meshDict_.lookup("keepCellsIntersectingPatches"));
 154         }
 155     }
 156 }
 157
 158 void checkMeshDict::checkRemoveCellsIntersectingPatches() const
 159 {
 160     if( meshDict_.found("removeCellsIntersectingPatches") )
 161     {
 162         if( meshDict_.isDict("removeCellsIntersectingPatches") )
 163         {
 164             const dictionary& dict =
 165                 meshDict_.subDict("removeCellsIntersectingPatches");
 166
 167             const wordList patchNames = dict.toc();
 168             patchNames.size();
 169         }
 170         else
 171         {
 172             wordList kcip(meshDict_.lookup("removeCellsIntersectingPatches"));
 173         }
 174     }
 175 }
 176
 177 void checkMeshDict::checkObjectRefinements() const
 178 {
 179     if( meshDict_.found("objectRefinements") )
 180     {
 181         PtrList<objectRefinement> refObjects;
 182
 183         if( meshDict_.isDict("objectRefinements") )
 184         {
 185             const dictionary& dict = meshDict_.subDict("objectRefinements");
 186             const wordList objectNames = dict.toc();
 187
 188             refObjects.setSize(objectNames.size());
 189
 190             forAll(refObjects, objectI)
 191             {
 192                 const entry& objectEntry =
 193                     dict.lookupEntry(objectNames[objectI], false, false);
 194
 195                 refObjects.set
 196                 (
 197                     objectI,
 198                     objectRefinement::New
 199                     (
 200                         objectEntry.keyword(),
 201                         objectEntry.dict()
 202                     )
 203                 );
 204             }
 205         }
 206         else
 207         {
 208             Istream& is = meshDict_.lookup("objectRefinements");
 209
 210             PtrList<entry> objectEntries(is);
 211             refObjects.setSize(objectEntries.size());
 212
 213             forAll(refObjects, objectI)
 214             {
 215                 refObjects.set
 216                 (
 217                     objectI,
 218                     objectRefinement::New
 219                     (
 220                         objectEntries[objectI].keyword(),
 221                         objectEntries[objectI].dict()
 222                     )
 223                 );
 224             }
 225         }
 226     }
 227 }
 228
 229 void checkMeshDict::checkBoundaryLayers() const
 230 {
 231     if( meshDict_.found("boundaryLayers") )
 232     {
 233         const dictionary& bndLayers = meshDict_.subDict("boundaryLayers");
 234
 235         //- read global properties
 236         if( bndLayers.found("nLayers") )
 237         {
 238             readLabel(bndLayers.lookup("nLayers"));
 239         }
 240         if( bndLayers.found("thicknessRatio") )
 241         {
 242             readScalar(bndLayers.lookup("thicknessRatio"));
 243         }
 244         if( bndLayers.found("maxFirstLayerThickness") )
 245         {
 246             readScalar(bndLayers.lookup("maxFirstLayerThickness"));
 247         }
 248
 249         //- patch-based properties
 250         if( bndLayers.isDict("patchBoundaryLayers") )
 251         {
 252             const dictionary& patchBndLayers =
 253                 bndLayers.subDict("patchBoundaryLayers");
 254             const wordList patchNames = patchBndLayers.toc();
 255
 256             forAll(patchNames, patchI)
 257             {
 258                 const word pName = patchNames[patchI];
 259
 260                 if( patchBndLayers.isDict(pName) )
 261                 {
 262                     const dictionary& patchDict =
 263                         patchBndLayers.subDict(pName);
 264
 265                     if( patchDict.found("nLayers") )
 266                     {
 267                         readLabel(patchDict.lookup("nLayers"));
 268                     }
 269                     if( patchDict.found("thicknessRatio") )
 270                     {
 271                         readScalar(patchDict.lookup("thicknessRatio"));
 272                     }
 273                     if( patchDict.found("maxFirstLayerThickness") )
 274                     {
 275                         readScalar(patchDict.lookup("maxFirstLayerThickness"));
 276                     }
 277                     if( patchDict.found("allowDiscontinuity") )
 278                     {
 279                         readBool(patchDict.lookup("allowDiscontinuity"));
 280                     }
 281                 }
 282                 else
 283                 {
 284                     Warning << "Cannot refine layer for patch "
 285                         << patchNames[patchI] << endl;
 286                 }
 287             }
 288         }
 289     }
 290 }
 291
 292 void checkMeshDict::checkRenameBoundary() const
 293 {
 294     if( meshDict_.found("renameBoundary") )
 295     {
 296         const dictionary& dict = meshDict_.subDict("renameBoundary");
 297         if( dict.found("newPatchNames") )
 298         {
 299             if( dict.isDict("newPatchNames") )
 300             {
 301                 const dictionary& patchDicts = dict.subDict("newPatchNames");
 302
 303                 const wordList patchNames = patchDicts.toc();
 304
 305                 forAll(patchNames, patchI)
 306                 {
 307                     const word& pName = patchNames[patchI];
 308
 309                     if( !patchDicts.isDict(pName) )
 310                         FatalErrorIn
 311                         (
 312                             "void checkMeshDict::checkRenameBoundary() const"
 313                         ) << "Entry " << pName
 314                           << " is not a dictionary" << exit(FatalError);
 315
 316                     const dictionary dict = patchDicts.subDict(pName);
 317
 318                     if( !dict.found("newName") )
 319                         FatalErrorIn
 320                         (
 321                             "void checkMeshDict::checkRenameBoundary() const"
 322                         ) << "Dictionary " << pName
 323                           << " does not contain a newName keyword"
 324                           << exit(FatalError);
 325                 }
 326             }
 327             else
 328             {
 329                 const PtrList<entry> patchesToRename
 330                 (
 331                     dict.lookup("newPatchNames")
 332                 );
 333
 334                 forAll(patchesToRename, patchI)
 335                 {
 336                     const word& pName = patchesToRename[patchI].keyword();
 337
 338                     const dictionary dict = patchesToRename[patchI].dict();
 339
 340                     if( !dict.found("newName") )
 341                         FatalErrorIn
 342                         (
 343                             "void checkMeshDict::checkRenameBoundary() const"
 344                         ) << "Dictionary " << pName
 345                           << " does not contain a newName keyword"
 346                           << exit(FatalError);
 347                 }
 348             }
 349         }
 350     }
 351 }
 352
 353 void checkMeshDict::checkEntries() const
 354 {
 355     checkPatchCellSize();
 356
 357     checkSubsetCellSize();
 358
 359     checkKeepCellsIntersectingPatches();
 360
 361     checkRemoveCellsIntersectingPatches();
 362
 363     checkObjectRefinements();
 364
 365     checkBoundaryLayers();
 366
 367     checkRenameBoundary();
 368 }
 369
 370 void checkMeshDict::updatePatchCellSize
 371 (
 372     const std::map<word, wordList>& patchesFromPatch
 373 )
 374 {
 375     if( meshDict_.found("patchCellSize") )
 376     {
 377         LongList<patchRefinement> updatedPatchRefinement;
 378
 379         if( meshDict_.isDict("patchCellSize") )
 380         {
 381             const dictionary dict = meshDict_.subDict("patchCellSize");
 382
 383             const wordList patchNames = dict.toc();
 384
 385             forAll(patchNames, patchI)
 386             {
 387                 const word& pName = patchNames[patchI];
 388
 389                 std::map<word, wordList>::const_iterator it =
 390                     patchesFromPatch.find(pName);
 391                 if( it == patchesFromPatch.end() )
 392                     continue;
 393
 394                 const wordList& updatedPatchNames = it->second;
 395
 396                 const dictionary& pDict = dict.subDict(pName);
 397                 const scalar cellSize = readScalar(pDict.lookup("cellSize"));
 398
 399                 forAll(updatedPatchNames, nameI)
 400                     updatedPatchRefinement.append
 401                     (
 402                         patchRefinement
 403                         (
 404                             updatedPatchNames[nameI],
 405                             cellSize
 406                         )
 407                     );
 408             }
 409         }
 410         else
 411         {
 412             patchRefinementList prl(meshDict_.lookup("patchCellSize"));
 413             forAll(prl, prlI)
 414             {
 415                 const word& pName = prl[prlI].patchName();
 416                 const scalar cellSize = prl[prlI].cellSize();
 417
 418                 std::map<word, wordList>::const_iterator it =
 419                     patchesFromPatch.find(pName);
 420
 421                 if( it == patchesFromPatch.end() )
 422                     continue;
 423
 424                 const wordList& updatedPatchNames = it->second;
 425                 forAll(updatedPatchNames, nameI)
 426                     updatedPatchRefinement.append
 427                     (
 428                         patchRefinement
 429                         (
 430                             updatedPatchNames[nameI],
 431                             cellSize
 432                         )
 433                     );
 434             }
 435         }
 436
 437         meshDict_.add("patchCellSize", updatedPatchRefinement, true);
 438     }
 439 }
 440
 441 void checkMeshDict::updateSubsetCellSize
 442 (
 443     const std::map<word, wordList>& patchesFromPatch
 444 )
 445 {
 446
 447 }
 448
 449 void checkMeshDict::updateLocalRefinementLevel
 450 (
 451     const std::map<word, wordList>& patchesFromPatch
 452 )
 453 {
 454     if( meshDict_.found("localRefinement") )
 455     {
 456         if( meshDict_.isDict("localRefinement") )
 457         {
 458             dictionary& dict = meshDict_.subDict("localRefinement");
 459
 460             const wordList entries = dict.toc();
 461
 462             forAll(entries, dictI)
 463             {
 464                 const word& pName = entries[dictI];
 465
 466                 std::map<word, wordList>::const_iterator it =
 467                     patchesFromPatch.find(pName);
 468                 if( it == patchesFromPatch.end() )
 469                     continue;
 470
 471                 const wordList& updatedPatchNames = it->second;
 472
 473                 const dictionary& pDict = dict.subDict(pName);
 474                 dictionary copy;
 475                 if( pDict.found("additionalRefinementLevels") )
 476                 {
 477                     const label nLevels =
 478                         readLabel(pDict.lookup("additionalRefinementLevels"));
 479
 480                     copy.add("additionalRefinementLevels", nLevels);
 481                 }
 482                 else if( pDict.found("cellSize") )
 483                 {
 484                     const scalar cs = readScalar(pDict.lookup("cellSize"));
 485
 486                     copy.add("cellSize", cs);
 487                 }
 488
 489                 //- add new patches
 490                 forAll(updatedPatchNames, nameI)
 491                     dict.add(updatedPatchNames[nameI], copy);
 492
 493                 //- remove the current patch
 494                 dict.remove(pName);
 495             }
 496         }
 497     }
 498 }
 499
 500 void checkMeshDict::updateKeepCellsIntersectingPatches
 501 (
 502     const std::map<word, wordList>& patchesFromPatch
 503 )
 504 {
 505     if( meshDict_.found("keepCellsIntersectingPatches") )
 506     {
 507         LongList<word> updatedPatchNames;
 508         if( meshDict_.isDict("keepCellsIntersectingPatches") )
 509         {
 510             const dictionary& dict =
 511                 meshDict_.subDict("keepCellsIntersectingPatches");
 512
 513             const wordList patchNames = dict.toc();
 514             forAll(patchNames, patchI)
 515             {
 516                 const word& pName = patchNames[patchI];
 517
 518                 std::map<word, wordList>::const_iterator it =
 519                     patchesFromPatch.find(pName);
 520
 521                 if( it == patchesFromPatch.end() )
 522                     updatedPatchNames.append(pName);
 523
 524                 const wordList& newPatchNames = it->second;
 525
 526                 forAll(newPatchNames, nameI)
 527                     updatedPatchNames.append(newPatchNames[nameI]);
 528             }
 529         }
 530         else
 531         {
 532             wordList kcip(meshDict_.lookup("keepCellsIntersectingPatches"));
 533
 534             forAll(kcip, i)
 535             {
 536                 const word& pName = kcip[i];
 537
 538                 std::map<word, wordList>::const_iterator it =
 539                     patchesFromPatch.find(pName);
 540
 541                 if( it == patchesFromPatch.end() )
 542                     updatedPatchNames.append(pName);
 543
 544                 const wordList& newPatchNames = it->second;
 545
 546                 forAll(newPatchNames, nameI)
 547                     updatedPatchNames.append(newPatchNames[nameI]);
 548             }
 549         }
 550
 551         meshDict_.add("keepCellsIntersectingPatches", updatedPatchNames, true);
 552     }
 553 }
 554
 555
 556 void checkMeshDict::updateRemoveCellsIntersectingPatches
 557 (
 558     const std::map<word, wordList>& patchesFromPatch
 559 )
 560 {
 561     if( meshDict_.found("removeCellsIntersectingPatches") )
 562     {
 563         LongList<word> updatedPatchNames;
 564         if( meshDict_.isDict("removeCellsIntersectingPatches") )
 565         {
 566             const dictionary& dict =
 567                 meshDict_.subDict("removeCellsIntersectingPatches");
 568
 569             const wordList patchNames = dict.toc();
 570             forAll(patchNames, patchI)
 571             {
 572                 const word& pName = patchNames[patchI];
 573
 574                 std::map<word, wordList>::const_iterator it =
 575                     patchesFromPatch.find(pName);
 576
 577                 if( it == patchesFromPatch.end() )
 578                     updatedPatchNames.append(pName);
 579
 580                 const wordList& newPatchNames = it->second;
 581
 582                 forAll(newPatchNames, nameI)
 583                     updatedPatchNames.append(newPatchNames[nameI]);
 584             }
 585         }
 586         else
 587         {
 588             wordList kcip(meshDict_.lookup("removeCellsIntersectingPatches"));
 589
 590             forAll(kcip, i)
 591             {
 592                 const word& pName = kcip[i];
 593
 594                 std::map<word, wordList>::const_iterator it =
 595                     patchesFromPatch.find(pName);
 596
 597                 if( it == patchesFromPatch.end() )
 598                     updatedPatchNames.append(pName);
 599
 600                 const wordList& newPatchNames = it->second;
 601
 602                 forAll(newPatchNames, nameI)
 603                     updatedPatchNames.append(newPatchNames[nameI]);
 604             }
 605         }
 606
 607         meshDict_.add
 608         (
 609             "removeCellsIntersectingPatches",
 610             updatedPatchNames,
 611             true
 612         );
 613     }
 614 }
 615
 616 void checkMeshDict::updateObjectRefinements
 617 (
 618     const std::map<word, wordList>& patchesFromPatch
 619 )
 620 {
 621
 622 }
 623
 624 void checkMeshDict::updateBoundaryLayers
 625 (
 626     const std::map<word, wordList>& patchesFromPatch
 627 )
 628 {
 629     if( meshDict_.isDict("boundaryLayers") )
 630     {
 631         dictionary& bndLayersDict = meshDict_.subDict("boundaryLayers");
 632         if( bndLayersDict.isDict("patchBoundaryLayers") )
 633         {
 634             dictionary& patchBndLayers =
 635                 bndLayersDict.subDict("patchBoundaryLayers");
 636
 637             const wordList patchLayers = patchBndLayers.toc();
 638
 639             forAll(patchLayers, patchI)
 640             {
 641                 const word& pName = patchLayers[patchI];
 642
 643                 dictionary dict = patchBndLayers.subDict(pName);
 644
 645                 const std::map<word, wordList>::const_iterator it =
 646                     patchesFromPatch.find(pName);
 647                 const wordList& newNames = it->second;
 648
 649                 forAll(newNames, i)
 650                 {
 651                     patchBndLayers.add(newNames[i], dict);
 652                 }
 653
 654                 patchBndLayers.remove(pName);
 655             }
 656         }
 657     }
 658 }
 659
 660 void checkMeshDict::updateRenameBoundary
 661 (
 662     const std::map<word, wordList>& patchesFromPatch,
 663     const std::map<word, word>& patchTypes
 664 )
 665 {
 666     dictionary newDict;
 667
 668     newDict.add("newPatchNames", dictionary());
 669
 670     if( meshDict_.found("renameBoundary") )
 671     {
 672         const dictionary& dict = meshDict_.subDict("renameBoundary");
 673
 674         //- transfer or generate the default name entry
 675         if( dict.found("defaultName") )
 676         {
 677             const word name(dict.lookup("defaultName"));
 678             newDict.add("defaultName", name);
 679         }
 680         else
 681         {
 682             newDict.add("defaultName", "walls");
 683         }
 684
 685         //- transfer or generate the defaultType entry
 686         if( dict.found("defaultType") )
 687         {
 688             const word type(dict.lookup("defaultType"));
 689             newDict.add("defaultType", type);
 690         }
 691         else
 692         {
 693             newDict.add("defaultType", "wall");
 694         }
 695
 696         if( dict.found("newPatchNames") )
 697         {
 698             //- stores the updated dictionary
 699             dictionary& newPatchesDict = newDict.subDict("newPatchNames");
 700
 701             if( dict.isDict("newPatchNames") )
 702             {
 703                 //- current state of the dictionary
 704                 const dictionary& patchDicts = dict.subDict("newPatchNames");
 705
 706                 std::map<word, wordList>::const_iterator it;
 707                 for(it=patchesFromPatch.begin();it!=patchesFromPatch.end();++it)
 708                 {
 709                     const word& pName = it->first;
 710                     const wordList& newNames = it->second;
 711
 712                     if( patchDicts.found(pName) )
 713                     {
 714                         //- patch renaming is already requested by the user
 715                         //- use the new name for all newly created patches
 716                         const dictionary& patchDict = patchDicts.subDict(pName);
 717                         if( !patchDict.found("newName") )
 718                             continue;
 719                         if( !patchDict.found("type") )
 720                             continue;
 721
 722                         const word newName(patchDict.lookup("newName"));
 723                         const word newType(patchDict.lookup("type"));
 724
 725                         forAll(newNames, i)
 726                         {
 727                             dictionary newPatchDict;
 728                             newPatchDict.add("newName", newName);
 729                             newPatchDict.add("type", newType);
 730
 731                             newPatchesDict.add(newNames[i], newPatchDict);
 732                         }
 733                     }
 734                     else
 735                     {
 736                         //- rename all newly create patches
 737                         //- with the original name
 738                         forAll(newNames, i)
 739                         {
 740                             dictionary newPatchDict;
 741
 742                             newPatchDict.add("newName", it->first);
 743                             std::map<word, word>::const_iterator tIter =
 744                                 patchTypes.find(it->first);
 745                             newPatchDict.add("type", tIter->second);
 746
 747                             newPatchesDict.add(newNames[i], newPatchDict);
 748                         }
 749                     }
 750                 }
 751             }
 752             else
 753             {
 754                 const PtrList<entry> patchEntries(dict.lookup("newPatchNames"));
 755
 756                 forAll(patchEntries, entryI)
 757                 {
 758                     const word& pName = patchEntries[entryI].keyword();
 759                     dictionary patchDict(patchEntries[entryI].dict());
 760
 761                     std::map<word, wordList>::const_iterator it =
 762                         patchesFromPatch.find(pName);
 763
 764                     if( it == patchesFromPatch.end() )
 765                         continue;
 766
 767                     const wordList& newNames = it->second;
 768
 769                     forAll(newNames, i)
 770                         newPatchesDict.add(newNames[i], patchDict, true);
 771                 }
 772
 773                 std::map<word, wordList>::const_iterator it;
 774                 for(it=patchesFromPatch.begin();it!=patchesFromPatch.end();++it)
 775                 {
 776                     const word& pName = it->first;
 777                     const wordList& newNames = it->second;
 778
 779                     if( newPatchesDict.found(pName) )
 780                         continue;
 781
 782                     //- rename all newly created patches
 783                     //- with the original name
 784                     forAll(newNames, i)
 785                     {
 786                         dictionary newPatchDict;
 787
 788                         newPatchDict.add("newName", it->first);
 789                         std::map<word, word>::const_iterator tIter =
 790                             patchTypes.find(it->first);
 791                         newPatchDict.add("type", tIter->second);
 792
 793                         newPatchesDict.add(newNames[i], newPatchDict);
 794                     }
 795                 }
 796             }
 797         }
 798         else
 799         {
 800             //- newPatchNames is not used
 801             dictionary& newPatchesDict = newDict.subDict("newPatchNames");
 802
 803             std::map<word, wordList>::const_iterator it;
 804             for(it=patchesFromPatch.begin();it!=patchesFromPatch.end();++it)
 805             {
 806                 const wordList& newPatchNames = it->second;
 807
 808                 forAll(newPatchNames, i)
 809                 {
 810                     const word& pName = newPatchNames[i];
 811                     dictionary newPatchDict;
 812                     newPatchDict.add("newName", it->first);
 813                     std::map<word, word>::const_iterator tIter =
 814                         patchTypes.find(it->first);
 815                     newPatchDict.add("type", tIter->second);
 816
 817                     newPatchesDict.add(pName, newPatchDict);
 818                 }
 819             }
 820         }
 821
 822         //- delete all previus entries from the dictionary
 823         meshDict_.subDict("renameBoundary").clear();
 824     }
 825     else
 826     {
 827         //- create the dictionary if it has not existed before
 828         newDict.add("defaultName", "walls");
 829         newDict.add("defaultType", "wall");
 830
 831         dictionary& newPatchesDict = newDict.subDict("newPatchNames");
 832
 833         std::map<word, wordList>::const_iterator it;
 834         for(it=patchesFromPatch.begin();it!=patchesFromPatch.end();++it)
 835         {
 836             const wordList& newPatchNames = it->second;
 837
 838             forAll(newPatchNames, i)
 839             {
 840                 const word& pName = newPatchNames[i];
 841                 dictionary newPatchDict;
 842                 newPatchDict.add("newName", it->first);
 843                 std::map<word, word>::const_iterator tIter =
 844                     patchTypes.find(it->first);
 845                 newPatchDict.add("type", tIter->second);
 846
 847                 newPatchesDict.add(pName, newPatchDict);
 848             }
 849         }
 850     }
 851
 852     meshDict_.add("renameBoundary", newDict, true);
 853 }
 854
 855 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 856
 857 checkMeshDict::checkMeshDict
 858 (
 859     IOdictionary& meshDict
 860 )
 861 :
 862     meshDict_(meshDict)
 863 {
 864     checkEntries();
 865 }
 866
 867 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 868
 869 checkMeshDict::~checkMeshDict()
 870 {}
 871
 872 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 873
 874 void checkMeshDict::updateDictionaries
 875 (
 876     const std::map<word, wordList>& patchesFromPatch,
 877     const std::map<word, word>& patchTypes,
 878     const bool renamePatches
 879 )
 880 {
 881     updatePatchCellSize(patchesFromPatch);
 882
 883     updateSubsetCellSize(patchesFromPatch);
 884
 885     updateLocalRefinementLevel(patchesFromPatch);
 886
 887     updateKeepCellsIntersectingPatches(patchesFromPatch);
 888
 889     updateRemoveCellsIntersectingPatches(patchesFromPatch);
 890
 891     updateObjectRefinements(patchesFromPatch);
 892
 893     updateBoundaryLayers(patchesFromPatch);
 894
 895     if( renamePatches )
 896         updateRenameBoundary(patchesFromPatch, patchTypes);
 897 }
 898
 899 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 900
 901 } // End namespace Foam
 902
 903 // ************************************************************************* //