advancingFrontAMI.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2013-2016 OpenFOAM Foundation
    Copyright (C) 2016-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.
 
    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.
 
    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
Class
    Foam::advancingFrontAMI
 
Description
    Base class for Arbitrary Mesh Interface (AMI) methods
 
SourceFiles
    advancingFrontAMI.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef advancingFrontAMI_H
#define advancingFrontAMI_H
 
#include "className.H"
#include "DynamicList.H"
#include "faceAreaIntersect.H"
#include "pointList.H"
#include "AMIInterpolation.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                      Class advancingFrontAMI Declaration
\*---------------------------------------------------------------------------*/
 
class advancingFrontAMI
:
    public AMIInterpolation
{
public:
 
    //- Area normalisation mode
    enum class areaNormalisationMode
    {
        project,
        mag
    };
 
    static const Enum<areaNormalisationMode> areaNormalisationModeNames_;
 
 
private:
 
    // Private Member Functions
 
        //- No copy assignment
        void operator=(const advancingFrontAMI&) = delete;
 
 
        // Parallel operations
 
            label calcOverlappingProcs
            (
                const List<treeBoundBoxList>& procBb,
                const treeBoundBox& bb,
                boolList& overlaps
            ) const;
 
            void distributePatches
            (
                const mapDistribute& map,
                const primitivePatch& pp,
                const globalIndex& gi,
                List<faceList>& faces,
                List<pointField>& points,
                List<labelList>& tgtFaceIDs
            ) const;
 
            void distributeAndMergePatches
            (
                const mapDistribute& map,
                const primitivePatch& tgtPatch,
                const globalIndex& gi,
                faceList& tgtFaces,
                pointField& tgtPoints,
                labelList& tgtFaceIDs
            ) const;
 
            autoPtr<mapDistribute> calcProcMap
            (
                const primitivePatch& srcPatch,
                const primitivePatch& tgtPatch
            ) const;
 
 
protected:
 
    // Protected data
 
        //- Maximum squared distance
        const scalar maxDistance2_;
 
        //- Minimum (cos of) angle. 1 for perfectly matching.
        const scalar minCosAngle_;
 
        //- Storage for src-side triangle decomposition
        List<DynamicList<face>> srcTris_;
 
        //- Storage for tgt-side triangle decomposition
        List<DynamicList<face>> tgtTris_;
 
        //- Demand-driven extended target mesh (distributed parallel usage)
        autoPtr<primitivePatch> extendedTgtPatchPtr_;
 
        //- Extended patch faces
        faceList extendedTgtFaces_;
 
        //- Extended patch points
        pointField extendedTgtPoints_;
 
        //- Extended patch face IDs
        labelList extendedTgtFaceIDs_;
 
        //- Extended patch map
        autoPtr<mapDistribute> extendedTgtMapPtr_;
 
        //- Labels of faces that are not overlapped by any target faces
        //- (should be empty for correct functioning for fully covered AMIs)
        labelList srcNonOverlap_;
 
        //- Octree used to find face seeds
        autoPtr<indexedOctree<treeType>> treePtr_;
 
        //- Face triangulation mode
        const faceAreaIntersect::triangulationMode triMode_;
 
        //- Area normalisation mode; default = project
        areaNormalisationMode areaNormalisationMode_;
 
 
    // Protected Member Functions
 
        // Helper functions
 
            //- Create a map that extends tgtPatch so that it covers srcPatch
            void createExtendedTgtPatch();
 
            //- Check AMI patch coupling
            void checkPatches() const;
 
            //- Is source/target a valid pair (i.e. not too far/different
            //  orientation). Used for prefiltering before e.g. area overlap
            bool isCandidate(const label srcFacei, const label tgtFacei) const;
 
            virtual bool calculate
            (
                const primitivePatch& srcPatch,
                const primitivePatch& tgtPatch,
                const autoPtr<searchableSurface>& surfPtr = nullptr
            );
 
            //- Initialise walk and return true if all ok
            bool initialiseWalk
            (
                label& srcFacei,
                label& tgtFacei
            );
 
            //- Write triangle intersection to OBJ file
            void writeIntersectionOBJ
            (
                const scalar area,
                const face& f1,
                const face& f2,
                const pointField& f1Points,
                const pointField& f2Points
            ) const;
 
 
        // Common AMI method functions
 
            label findTargetFace
            (
                const label srcFacei,
                const UList<label>& excludeFaces = UList<label>::null(),
                const label srcFacePti = -1
            ) const;
 
            //- Add faces neighbouring facei to the ID list
            void appendNbrFaces
            (
                const label facei,
                const primitivePatch& patch,
                const labelUList& visitedFaces,
                DynamicList<label>& faceIDs
            ) const;
 
            //- Helper function to decompose a patch
            void triangulatePatch
            (
                const primitivePatch& patch,
                List<DynamicList<face>>& tris,
                List<scalar>& magSf
            ) const;
 
            //- Correction for non-conformal interpolations, e.g. for ACMI
            virtual void nonConformalCorrection();
 
 
public:
 
    //- Runtime type information
    TypeName("advancingFrontAMI");
 
    // Constructors
 
        //- Construct from components
        advancingFrontAMI
        (
            const dictionary& dict,
            const bool reverseTarget
        );
 
        //- Construct from components
        advancingFrontAMI
        (
            const bool requireMatch = true,
            const bool reverseTarget = false,
            const scalar lowWeightCorrection = -1,
            const faceAreaIntersect::triangulationMode triMode =
                faceAreaIntersect::tmMesh
        );
 
        //- Construct as copy
        advancingFrontAMI(const advancingFrontAMI& ami);
 
        //- Construct and return a clone
        virtual autoPtr<AMIInterpolation> clone() const
        {
            return autoPtr<AMIInterpolation>(new advancingFrontAMI(*this));
        }
 
 
    //- Destructor
    virtual ~advancingFrontAMI() = default;
 
 
    // Member Functions
 
        //- Return const access to the source patch
        inline const primitivePatch& srcPatch() const;
 
        //- Return const access to the target patch
        inline const primitivePatch& tgtPatch() const;
 
        //- Labels of faces that are not overlapped by any target faces
        //  Note: this should be empty for correct functioning
        inline const labelList& srcNonOverlap() const;
 
 
        // I-O
 
            //- Write
            virtual void write(Ostream& os) const;
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#include "advancingFrontAMII.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //