| /*---------------------------------------------------------------------------*\ | |
| ========= | | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | |
| \\ / O peration | Website: https://openfoam.org | |
| \\ / A nd | Copyright (C) 2011-2026 OpenFOAM Foundation | |
| \\/ M anipulation | | |
| ------------------------------------------------------------------------------- | |
| 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::FaceCellWave | |
| Description | |
| Wave propagation of information through grid. Every iteration | |
| information goes through one layer of cells. Templated on information | |
| that is transferred. | |
| Handles parallel and cyclics and non-parallel cyclics. | |
| Note: whether to propagate depends on the return value of Type::update | |
| which returns true (i.e. propagate) if the value changes by more than a | |
| certain tolerance. | |
| This tolerance can be very strict for normal face-cell and parallel | |
| cyclics (we use a value of 0.01 just to limit propagation of small changes) | |
| but for non-parallel cyclics this tolerance can be critical and if chosen | |
| too small can lead to non-convergence. | |
| SourceFiles | |
| FaceCellWave.C | |
| \*---------------------------------------------------------------------------*/ | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| namespace Foam | |
| { | |
| // Forward declaration of classes | |
| class polyMesh; | |
| class polyPatch; | |
| class transformer; | |
| /*---------------------------------------------------------------------------*\ | |
| Class FaceCellWaveName Declaration | |
| \*---------------------------------------------------------------------------*/ | |
| TemplateName(FaceCellWave); | |
| /*---------------------------------------------------------------------------*\ | |
| Class FaceCellWave Declaration | |
| \*---------------------------------------------------------------------------*/ | |
| template<class Type, class TrackingData = int> | |
| class FaceCellWave | |
| : | |
| public FaceCellWaveName | |
| { | |
| protected: | |
| // Protected static data | |
| //- ... | |
| static const scalar geomTol_; | |
| //- ... | |
| static scalar propagationTol_; | |
| // Protected data | |
| //- Reference to mesh | |
| const polyMesh& mesh_; | |
| //- Optional boundary faces that information should travel through | |
| const labelPairList explicitConnections_; | |
| //- Information for all faces | |
| UList<Type>& allFaceInfo_; | |
| //- Information for all cells | |
| UList<Type>& allCellInfo_; | |
| //- Additional data to be passed into container | |
| TrackingData& td_; | |
| //- Has face changed | |
| PackedBoolList changedFace_; | |
| //- List of changed faces | |
| DynamicList<label> changedFaces_; | |
| //- Has cell changed | |
| PackedBoolList changedCell_; | |
| // Cells that have changed | |
| DynamicList<label> changedCells_; | |
| //- Contains cyclics | |
| const bool hasCyclicPatches_; | |
| //- Number of evaluations | |
| label nEvals_; | |
| //- Number of unvisited cells | |
| label nUnvisitedCells_; | |
| //- Number of unvisited faces | |
| label nUnvisitedFaces_; | |
| // Protected Member Functions | |
| //- Updates cellInfo with information from neighbour. Updates all | |
| // statistics. | |
| bool updateCell | |
| ( | |
| const label celli, | |
| const label neighbourFacei, | |
| const Type& neighbourInfo, | |
| const scalar tol, | |
| Type& cellInfo | |
| ); | |
| //- Updates faceInfo with information from neighbour. Updates all | |
| // statistics. | |
| bool updateFace | |
| ( | |
| const label facei, | |
| const label neighbourCelli, | |
| const Type& neighbourInfo, | |
| const scalar tol, | |
| Type& faceInfo | |
| ); | |
| //- Updates faceInfo with information from same face. Updates all | |
| // statistics. | |
| bool updateFace | |
| ( | |
| const label facei, | |
| const Type& neighbourInfo, | |
| const scalar tol, | |
| Type& faceInfo | |
| ); | |
| // Parallel, cyclic | |
| //- Debugging: check info on both sides of cyclic | |
| void checkCyclic(const polyPatch& pPatch) const; | |
| //- Has cyclic patch? | |
| template<class PatchType> | |
| bool hasPatch() const; | |
| //- Merge received patch data into global data | |
| void mergeFaceInfo | |
| ( | |
| const polyPatch& patch, | |
| const label nFaces, | |
| const labelList&, | |
| const List<Type>& | |
| ); | |
| //- Extract info for single patch only | |
| label getChangedPatchFaces | |
| ( | |
| const polyPatch& patch, | |
| const label startFacei, | |
| const label nFaces, | |
| labelList& changedPatchFaces, | |
| List<Type>& changedPatchFacesInfo | |
| ) const; | |
| //- Transform across an interface. Implementation referred to Type | |
| void transform | |
| ( | |
| const polyPatch& patch, | |
| const label nFaces, | |
| const labelList& faceLabels, | |
| const transformer& transform, | |
| List<Type>& faceInfo | |
| ); | |
| //- Merge data from across processor boundaries | |
| void handleProcPatches(); | |
| //- Merge data from across cyclics | |
| void handleCyclicPatches(); | |
| //- Merge data across explicitly provided local connections (usually | |
| // baffles) | |
| void handleExplicitConnections(); | |
| public: | |
| // Static Data | |
| //- Default tracking data to go with default template argument | |
| static int defaultTrackingData_; | |
| // Static Functions | |
| //- Access to tolerance | |
| static scalar propagationTol() | |
| { | |
| return propagationTol_; | |
| } | |
| //- Change tolerance | |
| static void setPropagationTol(const scalar tol) | |
| { | |
| propagationTol_ = tol; | |
| } | |
| // Constructors | |
| // Construct from mesh. Use setFaceInfo and iterate() to do actual | |
| // calculation. | |
| FaceCellWave | |
| ( | |
| const polyMesh&, | |
| UList<Type>& allFaceInfo, | |
| UList<Type>& allCellInfo, | |
| TrackingData& td = defaultTrackingData_ | |
| ); | |
| //- Construct from mesh and list of changed faces with the Type | |
| // for these faces. Iterates until nothing changes or maxIter reached. | |
| // (maxIter can be 0) | |
| FaceCellWave | |
| ( | |
| const polyMesh&, | |
| const labelList& initialChangedFaces, | |
| const List<Type>& changedFacesInfo, | |
| UList<Type>& allFaceInfo, | |
| UList<Type>& allCellInfo, | |
| const label maxIter, | |
| TrackingData& td = defaultTrackingData_, | |
| const bool global = true | |
| ); | |
| //- Construct from mesh and explicitly connected boundary faces | |
| // and list of changed faces with the Type | |
| // for these faces. Iterates until nothing changes or maxIter reached. | |
| // (maxIter can be 0) | |
| FaceCellWave | |
| ( | |
| const polyMesh&, | |
| const labelPairList& explicitConnections, | |
| const labelList& initialChangedFaces, | |
| const List<Type>& changedFacesInfo, | |
| UList<Type>& allFaceInfo, | |
| UList<Type>& allCellInfo, | |
| const label maxIter, | |
| TrackingData& td = defaultTrackingData_, | |
| const bool global = true | |
| ); | |
| //- Disallow default bitwise copy construction | |
| FaceCellWave(const FaceCellWave&) = delete; | |
| //- Destructor | |
| virtual ~FaceCellWave() | |
| {} | |
| // Member Functions | |
| // Access | |
| //- Access allFaceInfo | |
| UList<Type>& allFaceInfo() | |
| { | |
| return allFaceInfo_; | |
| } | |
| //- Access allCellInfo | |
| UList<Type>& allCellInfo() | |
| { | |
| return allCellInfo_; | |
| } | |
| //- Additional data to be passed into container | |
| const TrackingData& data() const | |
| { | |
| return td_; | |
| } | |
| //- Additional data to be passed into container | |
| TrackingData& data() | |
| { | |
| return td_; | |
| } | |
| //- Access mesh | |
| const polyMesh& mesh() const | |
| { | |
| return mesh_; | |
| } | |
| //- Get number of unvisited cells, i.e. cells that were not (yet) | |
| // reached from walking across mesh. This can happen from | |
| // - not enough iterations done | |
| // - a disconnected mesh | |
| // - a mesh without walls in it | |
| label getUnsetCells() const; | |
| //- Get number of unvisited faces | |
| label getUnsetFaces() const; | |
| // Edit | |
| //- Set initial changed faces | |
| void setFaceInfo | |
| ( | |
| const labelList& changedFaces, | |
| const List<Type>& changedFacesInfo | |
| ); | |
| //- Propagate from face to cell. Returns total number of cells | |
| // (over all processors) changed. | |
| virtual label faceToCell(); | |
| //- Propagate from cell to face. Returns total number of faces | |
| // (over all processors) changed. (Faces on processor patches are | |
| // counted double) | |
| virtual label cellToFace(const bool global = true); | |
| //- Iterate until no changes or maxIter reached. Returns actual | |
| // number of iterations. | |
| label iterate(const label maxIter, const bool global = true); | |
| // Member Operators | |
| //- Disallow default bitwise assignment | |
| void operator=(const FaceCellWave&) = delete; | |
| }; | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| } // End namespace Foam | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| // ************************************************************************* // | |