src/foam/interpolations/MixingPlaneInterpolation/MixingPlaneInterpolationTemplate.H

   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 Class
  25     MixingPlaneInterpolation
  26
  27 Description
  28     The mixingPlaneInterplation class is implementing the interpolation of face
  29     data between two primitivePatches using mixing plane averaging.
  30
  31     Some overview of this development can be found here:
  32
  33     OpenFOAM TURBO TOOLS: FROM GENERAL PURPOSE CFD TO TURBOMACHINERY
  34     SIMULATIONS
  35     H. Jasak, M. Beaudoin, Proceedings of ASME-JSME-KSME Joint Fluids
  36     Engineering Conference 2011, AJK2011-FED, July 24-29, 2011, Hamamatsu,
  37     Shizuoka, JAPAN
  38
  39     Steady-state capabilities for hydroturbines with OpenFOAM,
  40     M. Page, M. Beaudoin, A.-M. Giroux, Internationnal Journal of Fluid
  41     Machinery and Systems, 4(1):160–170, Jan-Mar 2011.
  42
  43     Development of a General Grid Interface for Turbomachinery simulations with
  44     OpenFOAM, M. Beaudoin, H. Jasak, Open Source CFD International Conference,
  45     December 2008
  46
  47 Author
  48     Martin Beaudoin, Hydro-Quebec, 2009.  All rights reserved
  49
  50 Contributor
  51     Hrvoje Jasak, Wikki Ltd.
  52
  53
  54 Giving credit where credit is due:
  55     1: Hakan Nilsson from the Chalmers University of Technology came up with
  56         the initial idea of using a combination of 2 GGI interfaces sharing a
  57         common single-face 360 degree ribbons patch in order to compute the
  58         circumferential average of fields. This implementation of the
  59         mixingPlane interpolation algorithm is an exploration of this simple
  60         but rather powerful idea.
  61
  62     2: Maryse Page from Hydro-Quebec provided many test cases and many
  63        simulation runs for testing this interpolation algorithm. Testing is
  64        obviously an essential part of any new development.
  65
  66     3: The authors also want to acknowledge the useful comments from many
  67        colleagues in the OpenFOAM Turbomachinery Special Interest Group.
  68
  69
  70 Nomenclature
  71     ribbon = face object over which we are averaging
  72
  73     direction = axis in which ribbon width is measured
  74
  75     span = axis in which ribbon length is measured
  76            All ribbons have identical length in the chosen coordinate system
  77
  78 SourceFiles
  79     MixingPlaneInterpolation.C
  80     MixingPlaneProfile.C
  81     MixingPlaneInterpolationPatches.C
  82     MixingPlaneInterpolationAddressing.C
  83     MixingPlaneInterpolate.C
  84
  85 \*---------------------------------------------------------------------------*/
  86
  87 #ifndef MixingPlaneInterpolation_H
  88 #define MixingPlaneInterpolation_H
  89
  90 #include "Pstream.H"
  91 #include "className.H"
  92 #include "labelList.H"
  93 #include "scalarField.H"
  94 #include "pointField.H"
  95 #include "FieldFields.H"
  96 #include "faceList.H"
  97 #include "intersection.H"
  98 #include "point2D.H"
  99 #include "NamedEnum.H"
 100 #include "coordinateSystem.H"
 101 #include "boundBox.H"
 102 #include "ggiInterpolation.H"
 103 #include "cylindricalCS.H"
 104 #include "primitivePatch.H"
 105 #include "standAlonePatch.H"
 106 #include <map>
 107 #include <list>
 108
 109 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 110
 111 namespace Foam
 112 {
 113
 114 /*---------------------------------------------------------------------------*\
 115                 Class MixingPlaneInterpolationName Declaration
 116 \*---------------------------------------------------------------------------*/
 117
 118 class MixingPlaneInterpolationName
 119 {
 120 public:
 121
 122     // Public enumerations
 123
 124         //- Define profile discretisation rule
 125         enum discretisation
 126         {
 127             MASTER_PATCH,
 128             SLAVE_PATCH,
 129             BOTH_PATCHES,
 130             UNIFORM,
 131             USER_DEFINED // User-defined through a file
 132         };
 133
 134         //- Define the sweepAxis used to generate the mixing ribbon patch
 135         enum sweepAxis
 136         {
 137             // Cartesian coordinate system
 138             SWEEP_X,
 139             SWEEP_Y,
 140             SWEEP_Z,
 141
 142             // Cylindrical coordinate system
 143             SWEEP_R,
 144             SWEEP_THETA,
 145             // SWEEP_Z is already defined for the Cartesian coordinate system
 146             SWEEP_UNKNOWN
 147         };
 148
 149         //- Define the stackAxis used to generate the mixing ribbon patch
 150         enum stackAxis
 151         {
 152             // Cartesian coordinate system
 153             STACK_X,
 154             STACK_Y,
 155             STACK_Z,
 156
 157             // Cylindrical coordinate system
 158             STACK_R,
 159             STACK_THETA,
 160             // STACK_Z is already defined for the Cartesian coordinate system
 161             STACK_UNKNOWN
 162         };
 163
 164         //- Define type of mixing for field over patch
 165         enum mixingType
 166         {
 167             AREA_AVERAGING,
 168             FLUX_AVERAGING,
 169             UNIFORM_VALUE,
 170             UNIFORM_GRADIENT,
 171             ZERO_GRADIENT,
 172             MIXING_UNKNOWN
 173         };
 174
 175
 176     // Static data
 177
 178         ClassName("MixingPlaneInterpolation");
 179
 180
 181        //- Discretisation names
 182        static const NamedEnum<discretisation, 5> discretisationNames_;
 183
 184        //- Sweep axis names
 185        static const NamedEnum<sweepAxis, 6> sweepAxisNames_;
 186
 187        //- Stack axis names
 188        static const NamedEnum<stackAxis, 6> stackAxisNames_;
 189
 190        //- Mixing names
 191        static const NamedEnum<mixingType, 6> mixingTypeNames_;
 192
 193
 194     // Constructors
 195
 196         //- Construct null
 197         MixingPlaneInterpolationName()
 198         {}
 199 };
 200
 201
 202 /*---------------------------------------------------------------------------*\
 203                     Class MixingPlaneInterpolation Declaration
 204 \*---------------------------------------------------------------------------*/
 205
 206 template<class MasterPatch, class SlavePatch>
 207 class MixingPlaneInterpolation
 208 :
 209     public MixingPlaneInterpolationName
 210 {
 211     // Private data types
 212
 213     typedef std::map<Foam::scalar, std::list<Foam::point> > profileHistogram;
 214
 215
 216     // Private data
 217
 218         //- Reference to the master patch
 219         const MasterPatch& masterPatch_;
 220
 221         //- Reference to the slave patch
 222         const SlavePatch& slavePatch_;
 223
 224         // We need to get some patches identification for debugging purposes
 225         // Since we are currently using primitive patches for the interpolator
 226         // we need to memorize this information when using the constructor
 227
 228         //- Coordinate system for averaging
 229         const coordinateSystem& cs_;
 230
 231         //- Type of mixing plane discretisation algorithm
 232         discretisation discretisationType_;
 233
 234         //- Orientation of the mixing plane ribbon patch
 235         //  sweepAxis = axis in which ribbon length is measured
 236         //  stackAxis = axis in which ribbon width/height is measured
 237         sweepAxis sweepAxisType_;
 238         stackAxis stackAxisType_;
 239
 240         //- Interpolation profile
 241         //  This list of points defines the profile generating the 'n'
 242         //  circular bands we are going to use for
 243         //  the circumferential averaging algorithm. For for 'n'
 244         //  circular bands, we need 'n + 1' points.
 245         mutable pointField interpolationProfile_;
 246
 247         //- Slave-to-master transformation tensor.  Transforms slave data to
 248         //  master plane.  Size equals number of slave faces; zero length
 249         //  indicates no transform.  Size 1 indicates constant transform
 250         const tensorField forwardT_;
 251
 252         //- Master-to-slave transformation tensor.  Transforms slave data to
 253         //  master plane.  Size equals number of master faces; zero length
 254         //  indicates no transform.  Size 1 indicates constant transform
 255         const tensorField reverseT_;
 256
 257         //- Slave-to-master separation vector. Translation of slave data to
 258         //  master plane.  Size equals number of slave faces; zero length
 259         //  indicates no translation.
 260         const vectorField forwardSep_;
 261
 262
 263     // Demand-driven data
 264
 265         //- Transformed master patch
 266         mutable standAlonePatch* transformedMasterPatchPtr_;
 267
 268         //- Transformed shadow patch
 269         mutable standAlonePatch* transformedShadowPatchPtr_;
 270
 271         //- Interpolating patch: strips of the mixing plane
 272         mutable standAlonePatch* mixingPlanePatchPtr_;
 273
 274
 275         //- Tensors for transforming the fields onto a single profile
 276         //  before averaging
 277         mutable tensorField* masterPatchToProfileTPtr_;
 278         mutable tensorField* masterProfileToPatchTPtr_;
 279         mutable tensorField* slavePatchToProfileTPtr_;
 280         mutable tensorField* slaveProfileToPatchTPtr_;
 281
 282
 283         // Master patch-to-profile interpolation
 284
 285             //- Master addressing
 286             mutable labelListList* masterPatchToProfileAddrPtr_;
 287             mutable labelListList* masterProfileToPatchAddrPtr_;
 288
 289             //- Master weights
 290             mutable scalarListList* masterPatchToProfileWeightsPtr_;
 291             mutable scalarListList* masterProfileToPatchWeightsPtr_;
 292
 293
 294         // Slave patch-to-profile interpolation
 295
 296             //- Slave addressing
 297             mutable labelListList* slavePatchToProfileAddrPtr_;
 298             mutable labelListList* slaveProfileToPatchAddrPtr_;
 299
 300             //- Slave weights
 301             mutable scalarListList* slavePatchToProfileWeightsPtr_;
 302             mutable scalarListList* slaveProfileToPatchWeightsPtr_;
 303
 304
 305     // Private Member Functions
 306
 307         //- Disallow default bitwise copy construct
 308         MixingPlaneInterpolation
 309         (
 310             const MixingPlaneInterpolation&
 311         );
 312
 313         //- Disallow default bitwise assignment
 314         void operator=(const MixingPlaneInterpolation&);
 315
 316
 317     // Helper functions for demand-driven data
 318
 319         //- Return ribbon sweep direction
 320         direction sweepAxisSwitch() const;
 321
 322         //- Return ribbon stack direction
 323         direction stackAxisSwitch() const;
 324
 325         //- Construct profile histogram
 326         void updateProfileHistogram
 327         (
 328             profileHistogram& histo,
 329             const point& profileCoord,  // 3D point
 330             const direction dir,        // Sorting dimension 0: x, 1: y, 2: z
 331             const scalar halfSizeBin    // half size of min histogram bin width
 332         ) const;
 333
 334         //- Create an interpolation profile from histograms
 335         //  Note: histograms are adjusted to achieve full overlap
 336         //  HJ, 6/Nov/2009
 337         tmp<pointField> computeProfileFromHistograms
 338         (
 339             const profileHistogram& masterHisto,
 340             const profileHistogram& slaveHisto,
 341             const scalar halfSizeBin   // half size of min histogram bin width
 342         ) const;
 343
 344         //- Remove interpolationProfile_ points located outside of either
 345         //  master/slave patch boundingBox,
 346         //  with the exception of the first and last profile points
 347         void removeNonOverlappedProfilePoints
 348         (
 349             boundBox& masterBB,
 350             boundBox& slaveBB
 351         ) const;
 352
 353         //- Find and modify patch faces straddling the histogram span
 354         //  eg. -180,+180 angle cylindrical coordinate system
 355         void correctStraddlingFaces
 356         (
 357             faceList& cylCoordFaces,
 358             pointField& cylCoordFacesPoint
 359         ) const;
 360
 361
 362         //- Calculate transformed patches
 363         void calcTransformedPatches() const;
 364
 365         //- Calculate mixing patch
 366         void calcMixingPlanePatch() const;
 367
 368
 369         //- Calculate addressing and weights
 370         void calcAddressing() const;
 371
 372         //- Calculate Cartesian to cylindrical tranformation tensor field for
 373         //  master and slave patches
 374         void calcTransforms() const;
 375
 376         //- Create an interpolation profile from histograms
 377         tmp<pointField> calcProfile() const;
 378
 379
 380         //- Clear transformed patches
 381         void clearTransfomedPatches();
 382
 383         //- Calculate mixing patch
 384         void clearMixingPlanePatch();
 385
 386         //- Clear addressing
 387         void clearAddressing();
 388
 389         //- Clear transforms
 390         void clearTransforms();
 391
 392         //- Clear all geometry and addressing
 393         void clearOut();
 394
 395
 396     // Interpolation data access
 397
 398         //- Distribute to profile given addressing and weights
 399         template<class Type>
 400         static void toProfile
 401         (
 402             const Field<Type>& srcF,
 403             const labelListList& srcAddr,
 404             const scalarListList& srcWeights,
 405             Field<Type>& profileBandValues
 406         );
 407
 408         //- Collect from profile given addressing and weights
 409         template<class Type>
 410         static void fromProfile
 411         (
 412             const Field<Type>& profileBandValues,
 413             const labelListList& dstAddr,
 414             const scalarListList& dstWeights,
 415             Field<Type>& dstResultF
 416         );
 417
 418         //- Collect from profile given addressing and weights
 419         //  for masked faces only
 420         template<class Type>
 421         static void maskedFromProfile
 422         (
 423             const Field<Type>& profileBandValues,
 424             const labelListList& dstAddr,
 425             const scalarListList& dstWeights,
 426             Field<Type>& dstResultF,
 427             const labelList& mask
 428         );
 429
 430         //- Execute transform for masked faces only
 431         template<class Type>
 432         static void maskedTransform
 433         (
 434             Field<Type>& transField,
 435             const tensorField& t,
 436             const Field<Type>& inField,
 437             const labelList& mask
 438         );
 439
 440         //- Interpolate given source and target, addressing and weights
 441         template<class Type>
 442         void interpolate
 443         (
 444             const Field<Type>& srcF,
 445             const labelListList& srcAddr,
 446             const scalarListList& srcWeights,
 447             const labelListList& dstAddr,
 448             const scalarListList& dstWeights,
 449             Field<Type>& dstResultF
 450         ) const;
 451
 452
 453         //- Is a transform required?
 454         inline bool doTransform() const
 455         {
 456             return false;
 457         }
 458
 459         //- Is a separation required?
 460         inline bool doSeparation() const
 461         {
 462             return false;
 463         }
 464
 465
 466 public:
 467
 468     // Constructors
 469
 470         //- Construct from components
 471         MixingPlaneInterpolation
 472         (
 473             const MasterPatch& masterPatch,
 474             const SlavePatch& slavePatch,
 475             const coordinateSystem& cs,
 476             const discretisation& discretisationType,
 477             const sweepAxis& sweepAxisType,
 478             const stackAxis& stackAxisType,
 479             const pointField& interpolationProfile
 480         );
 481
 482
 483     // Destructor
 484
 485         ~MixingPlaneInterpolation();
 486
 487
 488     // Member Functions
 489
 490         // Access
 491
 492             //- Return master patch
 493             const MasterPatch& masterPatch() const
 494             {
 495                 return masterPatch_;
 496             }
 497
 498             //- Return slave patch
 499             const SlavePatch& slavePatch() const
 500             {
 501                 return slavePatch_;
 502             }
 503
 504             //- Return number of profile bands
 505             label nProfileBands() const
 506             {
 507                 return interpolationProfile().size() - 1;
 508             }
 509
 510             //- Return interpolation profile
 511             const pointField& interpolationProfile() const;
 512
 513
 514             //- Return mixing plane patch
 515             const standAlonePatch& mixingPlanePatch() const;
 516
 517             //- Return transformed patch
 518             const standAlonePatch& transformedMasterPatch() const;
 519
 520             //- Return transformed patch
 521             const standAlonePatch& transformedShadowPatch() const;
 522
 523
 524             //- Return reference to master addressing
 525             const labelListList& masterPatchToProfileAddr() const;
 526             const labelListList& masterProfileToPatchAddr() const;
 527
 528             //- Return reference to master weights
 529             const scalarListList& masterPatchToProfileWeights() const;
 530             const scalarListList& masterProfileToPatchWeights() const;
 531
 532             //- Return reference to slave addressing
 533             const labelListList& slavePatchToProfileAddr() const;
 534             const labelListList& slaveProfileToPatchAddr() const;
 535
 536             //- Return reference to slave weights
 537             const scalarListList& slavePatchToProfileWeights() const;
 538             const scalarListList& slaveProfileToPatchWeights() const;
 539
 540             //- Return reference to masterPatchToProfile tensor field
 541             const tensorField& masterPatchToProfileT() const;
 542
 543             //- Return reference to masterProfileToPatchT tensor field
 544             const tensorField& masterProfileToPatchT() const;
 545
 546             //- Return reference to slavePatchToProfileT tensor field
 547             const tensorField& slavePatchToProfileT() const;
 548
 549             //- Return reference to slaveProfileToPatchT tensor field
 550             const tensorField& slaveProfileToPatchT() const;
 551
 552
 553         // Interpolation functions
 554
 555             //- Interpolate from master to slave
 556             template<class Type>
 557             tmp<Field<Type> > masterToSlave
 558             (
 559                 const Field<Type>& pf
 560             ) const;
 561
 562             template<class Type>
 563             tmp<Field<Type> > masterToSlave
 564             (
 565                 const tmp<Field<Type> >& tpf
 566             ) const;
 567
 568
 569             //- Interpolate from slave to master
 570             template<class Type>
 571             tmp<Field<Type> > slaveToMaster
 572             (
 573                 const Field<Type>& pf
 574             ) const;
 575
 576             template<class Type>
 577             tmp<Field<Type> > slaveToMaster
 578             (
 579                 const tmp<Field<Type> >& tpf
 580             ) const;
 581
 582
 583             //- Interpolate from master to profile
 584             template<class Type>
 585             tmp<Field<Type> > masterToProfile
 586             (
 587                 const Field<Type>& pf
 588             ) const;
 589
 590             template<class Type>
 591             tmp<Field<Type> > masterToProfile
 592             (
 593                 const tmp<Field<Type> >& tpf
 594             ) const;
 595
 596             //- Interpolate from slave to profile
 597             template<class Type>
 598             tmp<Field<Type> > slaveToProfile
 599             (
 600                 const Field<Type>& pf
 601             ) const;
 602
 603             template<class Type>
 604             tmp<Field<Type> > slaveToProfile
 605             (
 606                 const tmp<Field<Type> >& tpf
 607             ) const;
 608
 609
 610             //- Interpolate from profile to master
 611             template<class Type>
 612             tmp<Field<Type> > profileToMaster
 613             (
 614                 const Field<Type>& pf
 615             ) const;
 616
 617             template<class Type>
 618             tmp<Field<Type> > profileToMaster
 619             (
 620                 const tmp<Field<Type> >& tpf
 621             ) const;
 622
 623             template<class Type>
 624             void maskedProfileToMaster
 625             (
 626                 const Field<Type>& profileFF,
 627                 Field<Type>& result,
 628                 const labelList& mask
 629             ) const;
 630
 631             //- Interpolate from profile to slave
 632             template<class Type>
 633             tmp<Field<Type> > profileToSlave
 634             (
 635                 const Field<Type>& pf
 636             ) const;
 637
 638             template<class Type>
 639             tmp<Field<Type> > profileToSlave
 640             (
 641                 const tmp<Field<Type> >& tpf
 642             ) const;
 643
 644
 645             template<class Type>
 646             void maskedProfileToSlave
 647             (
 648                 const Field<Type>& profileFF,
 649                 Field<Type>& result,
 650                 const labelList& mask
 651             ) const;
 652
 653             //- Interpolate from master to master
 654             //- (self circumferential averaging)
 655             template<class Type>
 656             tmp<Field<Type> > masterToMaster
 657             (
 658                 const Field<Type>& pf
 659             ) const;
 660
 661             template<class Type>
 662             tmp<Field<Type> > masterToMaster
 663             (
 664                 const tmp<Field<Type> >& tpf
 665             ) const;
 666
 667             //- Interpolate from slave to slave
 668             //- (self circumferential averaging)
 669             template<class Type>
 670             tmp<Field<Type> > slaveToSlave
 671             (
 672                 const Field<Type>& pf
 673             ) const;
 674
 675             template<class Type>
 676             tmp<Field<Type> > slaveToSlave
 677             (
 678                 const tmp<Field<Type> >& tpf
 679             ) const;
 680
 681
 682         // Edit
 683
 684             //- Correct weighting factors for moving mesh.
 685             bool movePoints();
 686 };
 687
 688
 689 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 690
 691 } // End namespace Foam
 692
 693 #ifdef NoRepository
 694 #   include "MixingPlaneInterpolationTemplate.C"
 695 #   include "MixingPlaneProfile.C"
 696 #   include "MixingPlaneInterpolationPatches.C"
 697 #   include "MixingPlaneInterpolationAddressing.C"
 698 #   include "MixingPlaneInterpolate.C"
 699 #endif
 700
 701 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 702
 703 #endif
 704
 705 // ************************************************************************* //