diff --git a/src/OpenFOAM/fields/pointPatchFields/basic/fixedValue/fixedValuePointPatchField.H b/src/OpenFOAM/fields/pointPatchFields/basic/fixedValue/fixedValuePointPatchField.H index c325c85529..e8f269edbb 100644 --- a/src/OpenFOAM/fields/pointPatchFields/basic/fixedValue/fixedValuePointPatchField.H +++ b/src/OpenFOAM/fields/pointPatchFields/basic/fixedValue/fixedValuePointPatchField.H @@ -30,6 +30,8 @@ Class Description A FixedValue boundary condition for pointField. + The "value" entry is normally MUST_READ. + SourceFiles fixedValuePointPatchField.C @@ -92,13 +94,13 @@ public: const pointPatch& p, const DimensionedField& iF, const dictionary& dict, - const bool valueReqd + const bool needValue ) : fixedValuePointPatchField ( p, iF, dict, - (valueReqd? IOobjectOption::MUST_READ : IOobjectOption::NO_READ) + (needValue? IOobjectOption::MUST_READ : IOobjectOption::NO_READ) ) {} diff --git a/src/OpenFOAM/fields/pointPatchFields/basic/value/valuePointPatchField.H b/src/OpenFOAM/fields/pointPatchFields/basic/value/valuePointPatchField.H index 377be79930..a4f7c2b205 100644 --- a/src/OpenFOAM/fields/pointPatchFields/basic/value/valuePointPatchField.H +++ b/src/OpenFOAM/fields/pointPatchFields/basic/value/valuePointPatchField.H @@ -123,13 +123,13 @@ public: const pointPatch& p, const DimensionedField& iF, const dictionary& dict, - const bool valueReqd + const bool needValue ) : valuePointPatchField ( p, iF, dict, - (valueReqd? IOobjectOption::MUST_READ : IOobjectOption::NO_READ) + (needValue? IOobjectOption::MUST_READ : IOobjectOption::NO_READ) ) {} diff --git a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointBoundaryMeshMapper.H b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointBoundaryMeshMapper.H index 6c155b5401..f45bc5942a 100644 --- a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointBoundaryMeshMapper.H +++ b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointBoundaryMeshMapper.H @@ -31,8 +31,8 @@ Description \*---------------------------------------------------------------------------*/ -#ifndef pointBoundaryMeshMapper_H -#define pointBoundaryMeshMapper_H +#ifndef Foam_pointBoundaryMeshMapper_H +#define Foam_pointBoundaryMeshMapper_H #include "PtrList.H" #include "pointPatchMapper.H" diff --git a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.C b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.C index 3fba1b2c16..2daa81872c 100644 --- a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.C +++ b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.C @@ -6,6 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011-2016 OpenFOAM Foundation + Copyright (C) 2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -26,7 +27,6 @@ License \*---------------------------------------------------------------------------*/ #include "pointMapper.H" -#include "demandDrivenData.H" #include "pointMesh.H" #include "mapPolyMesh.H" @@ -37,9 +37,9 @@ void Foam::pointMapper::calcAddressing() const if ( directAddrPtr_ - || interpolationAddrPtr_ + || interpAddrPtr_ || weightsPtr_ - || insertedPointLabelsPtr_ + || insertedObjectsPtr_ ) { FatalErrorInFunction @@ -51,160 +51,226 @@ void Foam::pointMapper::calcAddressing() const { // Direct addressing, no weights - directAddrPtr_ = new labelList(mpm_.pointMap()); - labelList& directAddr = *directAddrPtr_; + directAddrPtr_ = std::make_unique + ( + // No retired points, so pointMap().size() == mapperLen_ anyhow + labelList::subList(mpm_.pointMap(), mapperLen_) + ); + auto& directAddr = *directAddrPtr_; - // Not necessary to resize the list as there are no retired points - // directAddr.setSize(pMesh_.size()); + insertedObjectsPtr_ = std::make_unique(); + auto& inserted = *insertedObjectsPtr_; - insertedPointLabelsPtr_ = new labelList(pMesh_.size()); - labelList& insertedPoints = *insertedPointLabelsPtr_; - - label nInsertedPoints = 0; - - forAll(directAddr, pointi) + // The nInsertedObjects_ already counted in the constructor + if (nInsertedObjects_) { - if (directAddr[pointi] < 0) - { - // Found inserted point - directAddr[pointi] = 0; - insertedPoints[nInsertedPoints] = pointi; - nInsertedPoints++; - } - } + inserted.resize(nInsertedObjects_); - insertedPoints.setSize(nInsertedPoints); + label nInserted = 0; + forAll(directAddr, i) + { + if (directAddr[i] < 0) + { + // Found inserted + directAddr[i] = 0; + inserted[nInserted] = i; + ++nInserted; + + // TBD: check (nInsertedObjects_ < nInserted)? + #ifdef FULLDEBUG + if (nInsertedObjects_ < nInserted) + { + FatalErrorInFunction + << "Unexpected insert of more than " + << nInsertedObjects_ << " items\n" + << abort(FatalError); + } + #endif + } + } + // TBD: check (nInserted < nInsertedObjects_)? + #ifdef FULLDEBUG + if (nInserted < nInsertedObjects_) + { + WarningInFunction + << "Found " << nInserted << " instead of " + << nInsertedObjects_ << " items to insert\n"; + } + #endif + // The resize should be unnecessary + inserted.resize(nInserted); + } } else { // Interpolative addressing - interpolationAddrPtr_ = new labelListList(pMesh_.size()); - labelListList& addr = *interpolationAddrPtr_; + interpAddrPtr_ = std::make_unique(mapperLen_); + auto& addr = *interpAddrPtr_; + + weightsPtr_ = std::make_unique(mapperLen_); + auto& wght = *weightsPtr_; + + + // Set the addressing and uniform weight + const auto setAddrWeights = [&] + ( + const List& maps, + const char * const nameOfMap + ) + { + for (const objectMap& map : maps) + { + // Get index, addressing + const label pointi = map.index(); + const labelList& mo = map.masterObjects(); + if (mo.empty()) continue; // safety + + if (addr[pointi].size()) + { + FatalErrorInFunction + << "Master point " << pointi + << " already mapped, cannot apply " + << nameOfMap + << flatOutput(mo) << abort(FatalError); + } + + // Map from masters, uniform weights + addr[pointi] = mo; + wght[pointi] = scalarList(mo.size(), 1.0/mo.size()); + } + }; - weightsPtr_ = new scalarListList(pMesh_.size()); - scalarListList& w = *weightsPtr_; // Points created from other points (i.e. points merged into it). - const List& cfc = mpm_.pointsFromPointsMap(); - forAll(cfc, cfcI) + setAddrWeights(mpm_.pointsFromPointsMap(), "point points"); + + + // Do mapped points. + // - may already have been set, so check if addressing still empty(). + { - // Get addressing - const labelList& mo = cfc[cfcI].masterObjects(); + const labelList& map = mpm_.pointMap(); - label pointi = cfc[cfcI].index(); - - if (addr[pointi].size()) + for (label pointi = 0; pointi < mapperLen_; ++pointi) { - FatalErrorInFunction - << "Master point " << pointi - << " mapped from points " << mo - << " already destination of mapping." << abort(FatalError); - } + const label mappedi = map[pointi]; - // Map from masters, uniform weights - addr[pointi] = mo; - w[pointi] = scalarList(mo.size(), 1.0/mo.size()); - } - - - // Do mapped points. Note that can already be set from pointsFromPoints - // so check if addressing size still zero. - - const labelList& cm = mpm_.pointMap(); - - forAll(cm, pointi) - { - if (cm[pointi] > -1 && addr[pointi].empty()) - { - // Mapped from a single point - addr[pointi] = labelList(1, cm[pointi]); - w[pointi] = scalarList(1, scalar(1)); + if (mappedi >= 0 && addr[pointi].empty()) + { + // Mapped from a single point + addr[pointi].resize(1, mappedi); + wght[pointi].resize(1, 1.0); + } } } // Grab inserted points (for them the size of addressing is still zero) - insertedPointLabelsPtr_ = new labelList(pMesh_.size()); - labelList& insertedPoints = *insertedPointLabelsPtr_; + insertedObjectsPtr_ = std::make_unique(); + auto& inserted = *insertedObjectsPtr_; - label nInsertedPoints = 0; - - forAll(addr, pointi) + // The nInsertedObjects_ already counted in the constructor + if (nInsertedObjects_) { - if (addr[pointi].empty()) + inserted.resize(nInsertedObjects_); + + label nInserted = 0; + forAll(addr, i) { - // Mapped from a dummy point. Take point 0 with weight 1. - addr[pointi] = labelList(1, Zero); - w[pointi] = scalarList(1, scalar(1)); + if (addr[i].empty()) + { + // Mapped from dummy point 0 + addr[i].resize(1, 0); + wght[i].resize(1, 1.0); - insertedPoints[nInsertedPoints] = pointi; - nInsertedPoints++; + inserted[nInserted] = i; + ++nInserted; + + // TBD: check (nInsertedObjects_ < nInserted)? + #ifdef FULLDEBUG + if (nInsertedObjects_ < nInserted) + { + FatalErrorInFunction + << "Unexpected insert of more than " + << nInsertedObjects_ << " items\n" + << abort(FatalError); + } + #endif + } } + // TBD: check (nInserted < nInsertedObjects_)? + #ifdef FULLDEBUG + if (nInserted < nInsertedObjects_) + { + WarningInFunction + << "Found " << nInserted << " instead of " + << nInsertedObjects_ << " items to insert\n"; + } + #endif + // The resize should be unnecessary + inserted.resize(nInserted); } - - insertedPoints.setSize(nInsertedPoints); } } -void Foam::pointMapper::clearOut() -{ - deleteDemandDrivenData(directAddrPtr_); - deleteDemandDrivenData(interpolationAddrPtr_); - deleteDemandDrivenData(weightsPtr_); - deleteDemandDrivenData(insertedPointLabelsPtr_); -} +// void Foam::pointMapper::clearOut() +// { +// directAddrPtr_.reset(nullptr); +// interpAddrPtr_.reset(nullptr); +// weightsPtr_.reset(nullptr); +// insertedObjectsPtr_.reset(nullptr); +// } // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // Foam::pointMapper::pointMapper(const pointMesh& pMesh, const mapPolyMesh& mpm) : - pMesh_(pMesh), mpm_(mpm), - insertedPoints_(true), - direct_(false), - directAddrPtr_(nullptr), - interpolationAddrPtr_(nullptr), - weightsPtr_(nullptr), - insertedPointLabelsPtr_(nullptr) + mapperLen_(pMesh.size()), + nInsertedObjects_(0), + direct_ + ( + // Mapping without interpolation? + mpm.pointsFromPointsMap().empty() + ) { - // Check for possibility of direct mapping - if (mpm_.pointsFromPointsMap().empty()) + const auto& directMap = mpm_.pointMap(); + + if (!mapperLen_) { + // Empty mesh direct_ = true; + nInsertedObjects_ = 0; + } + else if (direct_) + { + // Number of inserted points (-ve values) + nInsertedObjects_ = std::count_if + ( + directMap.cbegin(), + directMap.cbegin(mapperLen_), + [](label i) { return (i < 0); } + ); } else { - direct_ = false; - } + // Check if there are inserted points with no owner + // (check all lists) - // Check for inserted points - if (direct_ && (mpm_.pointMap().empty() || min(mpm_.pointMap()) > -1)) - { - insertedPoints_ = false; - } - else - { - //Check if there are inserted points with no owner + bitSet unmapped(mapperLen_, true); - // Make a copy of the point map, add the entries for points from points - // and check for left-overs - labelList cm(pMesh_.size(), -1); + unmapped.unset(directMap); // direct mapped - const List& cfc = mpm_.pointsFromPointsMap(); - - forAll(cfc, cfcI) + for (const objectMap& map : mpm_.pointsFromPointsMap()) { - cm[cfc[cfcI].index()] = 0; + if (!map.empty()) unmapped.unset(map.index()); } - if (min(cm) < 0) - { - insertedPoints_ = true; - } + nInsertedObjects_ = label(unmapped.count()); } } @@ -212,15 +278,14 @@ Foam::pointMapper::pointMapper(const pointMesh& pMesh, const mapPolyMesh& mpm) // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // Foam::pointMapper::~pointMapper() -{ - clearOut(); -} +{} // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // Foam::label Foam::pointMapper::size() const { + // OR: return mapperLen_; return mpm_.pointMap().size(); } @@ -266,12 +331,12 @@ const Foam::labelListList& Foam::pointMapper::addressing() const << abort(FatalError); } - if (!interpolationAddrPtr_) + if (!interpAddrPtr_) { calcAddressing(); } - return *interpolationAddrPtr_; + return *interpAddrPtr_; } @@ -295,30 +360,19 @@ const Foam::scalarListList& Foam::pointMapper::weights() const const Foam::labelList& Foam::pointMapper::insertedObjectLabels() const { - if (!insertedPointLabelsPtr_) + if (!insertedObjectsPtr_) { - if (!insertedObjects()) + if (!nInsertedObjects_) { - // There are no inserted points - insertedPointLabelsPtr_ = new labelList(0); - } - else - { - calcAddressing(); + // No inserted objects will be created + return labelList::null(); } + + calcAddressing(); } - return *insertedPointLabelsPtr_; + return *insertedObjectsPtr_; } -// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // - - -// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * // - - -// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // - - // ************************************************************************* // diff --git a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.H b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.H index 1e33711871..7783e6b361 100644 --- a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.H +++ b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.H @@ -6,6 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011-2013 OpenFOAM Foundation + Copyright (C) 2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -36,8 +37,8 @@ SourceFiles \*---------------------------------------------------------------------------*/ -#ifndef pointMapper_H -#define pointMapper_H +#ifndef Foam_pointMapper_H +#define Foam_pointMapper_H #include "morphFieldMapper.H" @@ -46,10 +47,9 @@ SourceFiles namespace Foam { -// Forward declaration of classes -class pointMesh; +// Forward Declarations class mapPolyMesh; -class polyMesh; +class pointMesh; /*---------------------------------------------------------------------------*\ Class pointMapper Declaration @@ -59,38 +59,45 @@ class pointMapper : public morphFieldMapper { - // Private data - - //- Reference to pointMesh - const pointMesh& pMesh_; + // Private Data //- Reference to mapPolyMesh const mapPolyMesh& mpm_; - //- Are there any inserted (unmapped) points - bool insertedPoints_; + //- The size of the mapper = pointMesh::size() + const label mapperLen_; + + //- Number of inserted (unmapped) points + label nInsertedObjects_; //- Is the mapping direct bool direct_; - // Demand-driven private data + // Demand-Driven Data //- Direct addressing (only one for of addressing is used) - mutable labelList* directAddrPtr_; + mutable std::unique_ptr directAddrPtr_; //- Interpolated addressing (only one for of addressing is used) - mutable labelListList* interpolationAddrPtr_; + mutable std::unique_ptr interpAddrPtr_; //- Interpolation weights - mutable scalarListList* weightsPtr_; + mutable std::unique_ptr weightsPtr_; //- Inserted points - mutable labelList* insertedPointLabelsPtr_; + mutable std::unique_ptr insertedObjectsPtr_; // Private Member Functions + //- Calculate addressing for mapping with inserted points + void calcAddressing() const; + +public: + + // Generated Methods + //- No copy construct pointMapper(const pointMapper&) = delete; @@ -98,28 +105,20 @@ class pointMapper void operator=(const pointMapper&) = delete; - //- Calculate addressing for mapping with inserted points - void calcAddressing() const; - - //- Clear out local storage - void clearOut(); - - -public: - // Constructors //- Construct from mapPolyMesh pointMapper(const pointMesh&, const mapPolyMesh& mpm); + //- Destructor virtual ~pointMapper(); // Member Functions - //- Return size + //- The mapper size virtual label size() const; //- Return size before mapping @@ -131,8 +130,7 @@ public: return direct_; } - //- Are there unmapped values? I.e. do all size() elements get - // get value + //- Are there unmapped values? i.e. do all size() elements get value virtual bool hasUnmapped() const { return insertedObjects(); @@ -148,9 +146,9 @@ public: virtual const scalarListList& weights() const; //- Are there any inserted points - bool insertedObjects() const + bool insertedObjects() const noexcept { - return insertedPoints_; + return bool(nInsertedObjects_); } //- Return list of inserted points diff --git a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMeshMapper.H b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMeshMapper.H index 54e18c664e..f6cb259262 100644 --- a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMeshMapper.H +++ b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMeshMapper.H @@ -35,8 +35,8 @@ SourceFiles \*---------------------------------------------------------------------------*/ -#ifndef pointMeshMapper_H -#define pointMeshMapper_H +#ifndef Foam_pointMeshMapper_H +#define Foam_pointMeshMapper_H #include "pointMapper.H" #include "pointBoundaryMeshMapper.H" @@ -46,7 +46,7 @@ SourceFiles namespace Foam { -// Forward declaration of classes +// Forward Declarations class pointMesh; class mapPolyMesh; @@ -56,7 +56,7 @@ class mapPolyMesh; class pointMeshMapper { - // Private data + // Private Data //- Reference to mesh const pointMesh& mesh_; @@ -92,28 +92,27 @@ public: // Member Functions - //- Return reference to mesh fields belong to - const pointMesh& mesh() const + const pointMesh& mesh() const noexcept { return mesh_; } //- Return reference to objectRegistry storing fields. Can be // removed once fields stored on pointMesh. - const objectRegistry& thisDb() const + const objectRegistry& thisDb() const noexcept { return mesh_(); } //- Return point mapper - const morphFieldMapper& pointMap() const + const morphFieldMapper& pointMap() const noexcept { return pointMap_; } //- Return boundary mapper - const pointBoundaryMeshMapper& boundaryMap() const + const pointBoundaryMeshMapper& boundaryMap() const noexcept { return boundaryMap_; } diff --git a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.C b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.C index e9a18985c0..2e6a2d7c4f 100644 --- a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.C +++ b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.C @@ -6,6 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011-2016 OpenFOAM Foundation + Copyright (C) 2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -29,7 +30,6 @@ License #include "pointPatch.H" #include "mapPolyMesh.H" #include "faceMapper.H" -#include "demandDrivenData.H" // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // @@ -38,7 +38,7 @@ void Foam::pointPatchMapper::calcAddressing() const if ( directAddrPtr_ - || interpolationAddrPtr_ + || interpAddrPtr_ || weightsPtr_ ) { @@ -52,8 +52,11 @@ void Foam::pointPatchMapper::calcAddressing() const if (direct()) { // Direct mapping. - directAddrPtr_ = new labelList(mpm_.patchPointMap()[patch_.index()]); - labelList& addr = *directAddrPtr_; + directAddrPtr_ = std::make_unique + ( + mpm_.patchPointMap()[patch_.index()] + ); + auto& addr = *directAddrPtr_; forAll(addr, i) { @@ -73,11 +76,11 @@ void Foam::pointPatchMapper::calcAddressing() const // patch points. Problem is we don't know what points were in the patch // for points that were merged. - interpolationAddrPtr_ = new labelListList(size()); - labelListList& addr = *interpolationAddrPtr_; + interpAddrPtr_ = std::make_unique(size()); + auto& addr = *interpAddrPtr_; - weightsPtr_ = new scalarListList(addr.size()); - scalarListList& w = *weightsPtr_; + weightsPtr_ = std::make_unique(addr.size()); + auto& wght = *weightsPtr_; const labelList& ppm = mpm_.patchPointMap()[patch_.index()]; @@ -85,15 +88,15 @@ void Foam::pointPatchMapper::calcAddressing() const { if (ppm[i] >= 0) { - addr[i] = labelList(1, ppm[i]); - w[i] = scalarList(1, scalar(1)); + addr[i].resize(1, ppm[i]); + wght[i].resize(1, 1.0); } else { // Inserted point. ///// Map from point0 (arbitrary choice) - //addr[i] = labelList(1, Zero); - //w[i] = scalarList(1, scalar(1)); + //addr[i].resize(1, 0); + //wght[i].resize(1, 1.0); hasUnmapped_ = true; } } @@ -101,13 +104,13 @@ void Foam::pointPatchMapper::calcAddressing() const } -void Foam::pointPatchMapper::clearOut() -{ - deleteDemandDrivenData(directAddrPtr_); - deleteDemandDrivenData(interpolationAddrPtr_); - deleteDemandDrivenData(weightsPtr_); - hasUnmapped_ = false; -} +// void Foam::pointPatchMapper::clearOut() +// { +// directAddrPtr_.reset(nullptr); +// interpAddrPtr_.reset(nullptr); +// weightsPtr_.reset(nullptr); +// hasUnmapped_ = false; +// } // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // @@ -129,19 +132,14 @@ Foam::pointPatchMapper::pointPatchMapper ? mpm_.oldPatchNMeshPoints()[patch_.index()] : 0 ), - hasUnmapped_(false), - directAddrPtr_(nullptr), - interpolationAddrPtr_(nullptr), - weightsPtr_(nullptr) + hasUnmapped_(false) {} // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // Foam::pointPatchMapper::~pointPatchMapper() -{ - clearOut(); -} +{} // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // @@ -173,12 +171,12 @@ const Foam::labelListList& Foam::pointPatchMapper::addressing() const << abort(FatalError); } - if (!interpolationAddrPtr_) + if (!interpAddrPtr_) { calcAddressing(); } - return *interpolationAddrPtr_; + return *interpAddrPtr_; } diff --git a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.H b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.H index c79491970f..e9570dbad3 100644 --- a/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.H +++ b/src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.H @@ -6,6 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011-2013 OpenFOAM Foundation + Copyright (C) 2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -34,8 +35,8 @@ SourceFiles \*---------------------------------------------------------------------------*/ -#ifndef pointPatchMapper_H -#define pointPatchMapper_H +#ifndef Foam_pointPatchMapper_H +#define Foam_pointPatchMapper_H #include "pointMapper.H" #include "pointPatchFieldMapper.H" @@ -47,7 +48,7 @@ SourceFiles namespace Foam { -// Forward declaration of classes +// Forward Declarations class pointPatch; class mapPolyMesh; @@ -59,7 +60,7 @@ class pointPatchMapper : public pointPatchFieldMapper { - // Private data + // Private Data //- Reference to patch const pointPatch& patch_; @@ -74,18 +75,18 @@ class pointPatchMapper const label sizeBeforeMapping_; - // Demand-driven private data + // Demand-driven Data mutable bool hasUnmapped_; //- Direct addressing (only one for of addressing is used) - mutable labelList* directAddrPtr_; + mutable std::unique_ptr directAddrPtr_; //- Interpolated addressing (only one for of addressing is used) - mutable labelListList* interpolationAddrPtr_; + mutable std::unique_ptr interpAddrPtr_; //- Interpolation weights - mutable scalarListList* weightsPtr_; + mutable std::unique_ptr weightsPtr_; // Private Member Functions @@ -100,9 +101,6 @@ class pointPatchMapper //- Calculate addressing for mapping with inserted cells void calcAddressing() const; - //- Clear out local storage - void clearOut(); - public: @@ -156,7 +154,6 @@ public: //- Return interpolaion weights virtual const scalarListList& weights() const; - }; diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.C b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.C index fd277b511d..4ac6c44ad1 100644 --- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.C +++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.C @@ -6,6 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011-2016 OpenFOAM Foundation + Copyright (C) 2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -26,7 +27,6 @@ License \*---------------------------------------------------------------------------*/ #include "cellMapper.H" -#include "demandDrivenData.H" #include "polyMesh.H" #include "mapPolyMesh.H" @@ -37,9 +37,9 @@ void Foam::cellMapper::calcAddressing() const if ( directAddrPtr_ - || interpolationAddrPtr_ + || interpAddrPtr_ || weightsPtr_ - || insertedCellLabelsPtr_ + || insertedObjectsPtr_ ) { FatalErrorInFunction @@ -51,129 +51,105 @@ void Foam::cellMapper::calcAddressing() const { // Direct addressing, no weights - directAddrPtr_ = new labelList(mpm_.cellMap()); - labelList& directAddr = *directAddrPtr_; + directAddrPtr_ = std::make_unique + ( + // No retired cells, so cellMap().size() == mapperLen_ anyhow + labelList::subList(mpm_.cellMap(), mapperLen_) + ); + auto& directAddr = *directAddrPtr_; - // Not necessary to resize the list as there are no retired cells - // directAddr.setSize(mesh_.nCells()); + insertedObjectsPtr_ = std::make_unique(); + auto& inserted = *insertedObjectsPtr_; - insertedCellLabelsPtr_ = new labelList(mesh_.nCells()); - labelList& insertedCells = *insertedCellLabelsPtr_; - - label nInsertedCells = 0; - - forAll(directAddr, celli) + // The nInsertedObjects_ already counted in the constructor + if (nInsertedObjects_) { - if (directAddr[celli] < 0) - { - // Found inserted cell - directAddr[celli] = 0; - insertedCells[nInsertedCells] = celli; - nInsertedCells++; - } - } + inserted.resize(nInsertedObjects_); - insertedCells.setSize(nInsertedCells); + label nInserted = 0; + forAll(directAddr, i) + { + if (directAddr[i] < 0) + { + // Found inserted + directAddr[i] = 0; + inserted[nInserted] = i; + ++nInserted; + + // TBD: check (nInsertedObjects_ < nInserted)? + #ifdef FULLDEBUG + if (nInsertedObjects_ < nInserted) + { + FatalErrorInFunction + << "Unexpected insert of more than " + << nInsertedObjects_ << " items\n" + << abort(FatalError); + } + #endif + } + } + // TBD: check (nInserted < nInsertedObjects_)? + #ifdef FULLDEBUG + if (nInserted < nInsertedObjects_) + { + WarningInFunction + << "Found " << nInserted << " instead of " + << nInsertedObjects_ << " items to insert\n"; + } + #endif + // The resize should be unnecessary + inserted.resize(nInserted); + } } else { // Interpolative addressing - interpolationAddrPtr_ = new labelListList(mesh_.nCells()); - labelListList& addr = *interpolationAddrPtr_; + interpAddrPtr_ = std::make_unique(mapperLen_); + auto& addr = *interpAddrPtr_; - weightsPtr_ = new scalarListList(mesh_.nCells()); - scalarListList& w = *weightsPtr_; + weightsPtr_ = std::make_unique(mapperLen_); + auto& wght = *weightsPtr_; - const List& cfp = mpm_.cellsFromPointsMap(); - forAll(cfp, cfpI) + // Set the addressing and uniform weight + const auto setAddrWeights = [&] + ( + const List& maps, + const char * const nameOfMap + ) { - // Get addressing - const labelList& mo = cfp[cfpI].masterObjects(); - - label celli = cfp[cfpI].index(); - - if (addr[celli].size()) + for (const objectMap& map : maps) { - FatalErrorInFunction - << "Master cell " << celli - << " mapped from point cells " << mo - << " already destination of mapping." << abort(FatalError); + // Get index, addressing + const label celli = map.index(); + const labelList& mo = map.masterObjects(); + if (mo.empty()) continue; // safety + + if (addr[celli].size()) + { + FatalErrorInFunction + << "Master cell " << celli + << " already mapped, cannot apply " + << nameOfMap + << flatOutput(mo) << abort(FatalError); + } + + // Map from masters, uniform weights + addr[celli] = mo; + wght[celli] = scalarList(mo.size(), 1.0/mo.size()); } + }; - // Map from masters, uniform weights - addr[celli] = mo; - w[celli] = scalarList(mo.size(), 1.0/mo.size()); - } - const List& cfe = mpm_.cellsFromEdgesMap(); - - forAll(cfe, cfeI) - { - // Get addressing - const labelList& mo = cfe[cfeI].masterObjects(); - - label celli = cfe[cfeI].index(); - - if (addr[celli].size()) - { - FatalErrorInFunction - << "Master cell " << celli - << " mapped from edge cells " << mo - << " already destination of mapping." << abort(FatalError); - } - - // Map from masters, uniform weights - addr[celli] = mo; - w[celli] = scalarList(mo.size(), 1.0/mo.size()); - } - - const List& cff = mpm_.cellsFromFacesMap(); - - forAll(cff, cffI) - { - // Get addressing - const labelList& mo = cff[cffI].masterObjects(); - - label celli = cff[cffI].index(); - - if (addr[celli].size()) - { - FatalErrorInFunction - << "Master cell " << celli - << " mapped from face cells " << mo - << " already destination of mapping." << abort(FatalError); - } - - // Map from masters, uniform weights - addr[celli] = mo; - w[celli] = scalarList(mo.size(), 1.0/mo.size()); - } + setAddrWeights(mpm_.cellsFromPointsMap(), "point cells"); + setAddrWeights(mpm_.cellsFromEdgesMap(), "edge cells"); + setAddrWeights(mpm_.cellsFromFacesMap(), "face cells"); // Volume conservative mapping if possible - const List& cfc = mpm_.cellsFromCellsMap(); - - forAll(cfc, cfcI) - { - // Get addressing - const labelList& mo = cfc[cfcI].masterObjects(); - - label celli = cfc[cfcI].index(); - - if (addr[celli].size()) - { - FatalErrorInFunction - << "Master cell " << celli - << " mapped from cell cells " << mo - << " already destination of mapping." - << abort(FatalError); - } - - // Map from masters - addr[celli] = mo; - } + const List& cellsFromCells = mpm_.cellsFromCellsMap(); + setAddrWeights(cellsFromCells, "cell cells"); if (mpm_.hasOldCellVolumes()) { @@ -185,182 +161,188 @@ void Foam::cellMapper::calcAddressing() const { FatalErrorInFunction << "cellVolumes size " << V.size() - << " is not the old number of cells " << sizeBeforeMapping() + << " != old number of cells " << sizeBeforeMapping() << ". Are your cellVolumes already mapped?" << " (new number of cells " << size() << ")" << abort(FatalError); } - forAll(cfc, cfcI) + for (const auto& map : cellsFromCells) { - const labelList& mo = cfc[cfcI].masterObjects(); + // Get index, addressing + const label celli = map.index(); + const labelList& mo = map.masterObjects(); + if (mo.empty()) continue; // safety - label celli = cfc[cfcI].index(); + // wght[celli] is already sized and uniform weighted + auto& wght_cell = wght[celli]; - w[celli].setSize(mo.size()); - - if (mo.size()) + scalar sumV = 0; + forAll(mo, ci) { - scalar sumV = 0; - forAll(mo, ci) + wght_cell[ci] = V[mo[ci]]; + sumV += V[mo[ci]]; + } + if (sumV > VSMALL) + { + for (auto& w : wght_cell) { - w[celli][ci] = V[mo[ci]]; - sumV += V[mo[ci]]; - } - if (sumV > VSMALL) - { - forAll(mo, ci) - { - w[celli][ci] /= sumV; - } - } - else - { - // Exception: zero volume. Use uniform mapping - w[celli] = scalarList(mo.size(), 1.0/mo.size()); + w /= sumV; } } + else + { + // Exception: zero volume. Use uniform mapping + wght_cell = (1.0/mo.size()); + } } } - else + + + // Do mapped cells. + // - may already have been set, so check if addressing still empty(). + { - // Uniform weighted + const labelList& map = mpm_.cellMap(); - forAll(cfc, cfcI) + // The cellMap.size() == nCells() anyhow + for (label celli = 0; celli < mapperLen_; ++celli) { - const labelList& mo = cfc[cfcI].masterObjects(); + const label mappedi = map[celli]; - label celli = cfc[cfcI].index(); - - w[celli] = scalarList(mo.size(), 1.0/mo.size()); + if (mappedi >= 0 && addr[celli].empty()) + { + // Mapped from a single cell + addr[celli].resize(1, mappedi); + wght[celli].resize(1, 1.0); + } } } - // Do mapped faces. Note that can already be set from cellsFromCells - // so check if addressing size still zero. - - const labelList& cm = mpm_.cellMap(); - - forAll(cm, celli) - { - if (cm[celli] > -1 && addr[celli].empty()) - { - // Mapped from a single cell - addr[celli] = labelList(1, cm[celli]); - w[celli] = scalarList(1, 1.0); - } - } - // Grab inserted points (for them the size of addressing is still zero) - insertedCellLabelsPtr_ = new labelList(mesh_.nCells()); - labelList& insertedCells = *insertedCellLabelsPtr_; + insertedObjectsPtr_ = std::make_unique(); + auto& inserted = *insertedObjectsPtr_; - label nInsertedCells = 0; - - forAll(addr, celli) + // The nInsertedObjects_ already counted in the constructor + if (nInsertedObjects_) { - if (addr[celli].empty()) + inserted.resize(nInsertedObjects_); + + label nInserted = 0; + forAll(addr, i) { - // Mapped from a dummy cell - addr[celli] = labelList(1, Zero); - w[celli] = scalarList(1, scalar(1)); + if (addr[i].empty()) + { + // Mapped from dummy cell 0 + addr[i].resize(1, 0); + wght[i].resize(1, 1.0); - insertedCells[nInsertedCells] = celli; - nInsertedCells++; + inserted[nInserted] = i; + ++nInserted; + + // TBD: check (nInsertedObjects_ < nInserted)? + #ifdef FULLDEBUG + if (nInsertedObjects_ < nInserted) + { + FatalErrorInFunction + << "Unexpected insert of more than " + << nInsertedObjects_ << " items\n" + << abort(FatalError); + } + #endif + } } + // TBD: check (nInserted < nInsertedObjects_)? + #ifdef FULLDEBUG + if (nInserted < nInsertedObjects_) + { + WarningInFunction + << "Found " << nInserted << " instead of " + << nInsertedObjects_ << " items to insert\n"; + } + #endif + // The resize should be unnecessary + inserted.resize(nInserted); } - - insertedCells.setSize(nInsertedCells); } } -void Foam::cellMapper::clearOut() -{ - deleteDemandDrivenData(directAddrPtr_); - deleteDemandDrivenData(interpolationAddrPtr_); - deleteDemandDrivenData(weightsPtr_); - deleteDemandDrivenData(insertedCellLabelsPtr_); -} +// void Foam::cellMapper::clearOut() +// { +// directAddrPtr_.reset(nullptr); +// interpAddrPtr_.reset(nullptr); +// weightsPtr_.reset(nullptr); +// insertedObjectsPtr_.reset(nullptr); +// } // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // Foam::cellMapper::cellMapper(const mapPolyMesh& mpm) : - mesh_(mpm.mesh()), mpm_(mpm), - insertedCells_(true), - direct_(false), - directAddrPtr_(nullptr), - interpolationAddrPtr_(nullptr), - weightsPtr_(nullptr), - insertedCellLabelsPtr_(nullptr) -{ - // Check for possibility of direct mapping - if + mapperLen_(mpm.mesh().nCells()), + nInsertedObjects_(0), + direct_ ( - mpm_.cellsFromPointsMap().empty() - && mpm_.cellsFromEdgesMap().empty() - && mpm_.cellsFromFacesMap().empty() - && mpm_.cellsFromCellsMap().empty() + // Mapping without interpolation? + mpm.cellsFromPointsMap().empty() + && mpm.cellsFromEdgesMap().empty() + && mpm.cellsFromFacesMap().empty() + && mpm.cellsFromCellsMap().empty() ) +{ + const auto& directMap = mpm_.cellMap(); + + if (!mapperLen_) { + // Empty mesh direct_ = true; + nInsertedObjects_ = 0; + } + else if (direct_) + { + // Number of inserted cells (-ve values) + nInsertedObjects_ = std::count_if + ( + directMap.cbegin(), + directMap.cbegin(mapperLen_), + [](label i) { return (i < 0); } + ); } else { - direct_ = false; - } + // Check if there are inserted cells with no owner + // (check all lists) - // Check for inserted cells - if (direct_ && (mpm_.cellMap().empty() || min(mpm_.cellMap()) > -1)) - { - insertedCells_ = false; - } - else - { - // Need to check all 3 lists to see if there are inserted cells - // with no owner + bitSet unmapped(mapperLen_, true); - // Make a copy of the cell map, add the entried for cells from points, - // cells from edges and cells from faces and check for left-overs - labelList cm(mesh_.nCells(), -1); + unmapped.unset(directMap); // direct mapped - const List& cfp = mpm_.cellsFromPointsMap(); - - forAll(cfp, cfpI) + for (const auto& map : mpm_.cellsFromPointsMap()) { - cm[cfp[cfpI].index()] = 0; + if (!map.empty()) unmapped.unset(map.index()); } - const List& cfe = mpm_.cellsFromEdgesMap(); - - forAll(cfe, cfeI) + for (const auto& map : mpm_.cellsFromEdgesMap()) { - cm[cfe[cfeI].index()] = 0; + if (!map.empty()) unmapped.unset(map.index()); } - const List& cff = mpm_.cellsFromFacesMap(); - - forAll(cff, cffI) + for (const auto& map : mpm_.cellsFromFacesMap()) { - cm[cff[cffI].index()] = 0; + if (!map.empty()) unmapped.unset(map.index()); } - const List& cfc = mpm_.cellsFromCellsMap(); - - forAll(cfc, cfcI) + for (const auto& map : mpm_.cellsFromCellsMap()) { - cm[cfc[cfcI].index()] = 0; + if (!map.empty()) unmapped.unset(map.index()); } - if (min(cm) < 0) - { - insertedCells_ = true; - } + nInsertedObjects_ = label(unmapped.count()); } } @@ -368,15 +350,14 @@ Foam::cellMapper::cellMapper(const mapPolyMesh& mpm) // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // Foam::cellMapper::~cellMapper() -{ - clearOut(); -} +{} // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // Foam::label Foam::cellMapper::size() const { + // OR: return mapperLen_; return mpm_.cellMap().size(); } @@ -422,12 +403,12 @@ const Foam::labelListList& Foam::cellMapper::addressing() const << abort(FatalError); } - if (!interpolationAddrPtr_) + if (!interpAddrPtr_) { calcAddressing(); } - return *interpolationAddrPtr_; + return *interpAddrPtr_; } @@ -451,20 +432,18 @@ const Foam::scalarListList& Foam::cellMapper::weights() const const Foam::labelList& Foam::cellMapper::insertedObjectLabels() const { - if (!insertedCellLabelsPtr_) + if (!insertedObjectsPtr_) { - if (!insertedObjects()) + if (!nInsertedObjects_) { - // There are no inserted cells - insertedCellLabelsPtr_ = new labelList(0); - } - else - { - calcAddressing(); + // No inserted objects will be created + return labelList::null(); } + + calcAddressing(); } - return *insertedCellLabelsPtr_; + return *insertedObjectsPtr_; } diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.H b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.H index 60eaedd82a..649b70dab9 100644 --- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.H +++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.H @@ -6,6 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011-2013 OpenFOAM Foundation + Copyright (C) 2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -36,8 +37,8 @@ SourceFiles \*---------------------------------------------------------------------------*/ -#ifndef cellMapper_H -#define cellMapper_H +#ifndef Foam_cellMapper_H +#define Foam_cellMapper_H #include "morphFieldMapper.H" @@ -46,8 +47,7 @@ SourceFiles namespace Foam { -// Forward declaration of classes -class polyMesh; +// Forward Declarations class mapPolyMesh; /*---------------------------------------------------------------------------*\ @@ -58,38 +58,45 @@ class cellMapper : public morphFieldMapper { - // Private data - - //- Reference to polyMesh - const polyMesh& mesh_; + // Private Data //- Reference to mapPolyMesh const mapPolyMesh& mpm_; - //- Are there any inserted (unmapped) cells - bool insertedCells_; + //- The size of the mapper = polyMesh::nCells() + const label mapperLen_; + + //- Number of inserted (unmapped) cells + label nInsertedObjects_; //- Is the mapping direct bool direct_; - // Demand-driven private data + // Demand-Driven Data //- Direct addressing (only one for of addressing is used) - mutable labelList* directAddrPtr_; + mutable std::unique_ptr directAddrPtr_; //- Interpolated addressing (only one for of addressing is used) - mutable labelListList* interpolationAddrPtr_; + mutable std::unique_ptr interpAddrPtr_; //- Interpolation weights - mutable scalarListList* weightsPtr_; + mutable std::unique_ptr weightsPtr_; //- Inserted cells - mutable labelList* insertedCellLabelsPtr_; + mutable std::unique_ptr insertedObjectsPtr_; // Private Member Functions + //- Calculate addressing for mapping with inserted cells + void calcAddressing() const; + +public: + + // Generated Methods + //- No copy construct cellMapper(const cellMapper&) = delete; @@ -97,21 +104,10 @@ class cellMapper void operator=(const cellMapper&) = delete; - //- Calculate addressing for mapping with inserted cells - void calcAddressing() const; - - //- Clear out local storage - void clearOut(); - - -public: - - // Static data members - // Constructors //- Construct from mapPolyMesh - cellMapper(const mapPolyMesh& mpm); + explicit cellMapper(const mapPolyMesh& mpm); //- Destructor @@ -120,7 +116,7 @@ public: // Member Functions - //- Return size + //- The mapper size virtual label size() const; //- Return size before mapping @@ -132,6 +128,7 @@ public: return direct_; } + //- Are there unmapped values? virtual bool hasUnmapped() const { return insertedObjects(); @@ -149,7 +146,7 @@ public: //- Are there any inserted cells virtual bool insertedObjects() const { - return insertedCells_; + return bool(nInsertedObjects_); } //- Return list of inserted cells diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.C b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.C index 7745f65904..d638fe3efc 100644 --- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.C +++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.C @@ -6,6 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011-2016 OpenFOAM Foundation + Copyright (C) 2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -26,7 +27,6 @@ License \*---------------------------------------------------------------------------*/ #include "faceMapper.H" -#include "demandDrivenData.H" #include "polyMesh.H" #include "mapPolyMesh.H" @@ -37,9 +37,9 @@ void Foam::faceMapper::calcAddressing() const if ( directAddrPtr_ - || interpolationAddrPtr_ + || interpAddrPtr_ || weightsPtr_ - || insertedFaceLabelsPtr_ + || insertedObjectsPtr_ ) { FatalErrorInFunction @@ -51,223 +51,240 @@ void Foam::faceMapper::calcAddressing() const { // Direct addressing, no weights - directAddrPtr_ = new labelList(mpm_.faceMap()); - labelList& directAddr = *directAddrPtr_; + // Restrict addressing list to contain only live faces + directAddrPtr_ = std::make_unique + ( + labelList::subList(mpm_.faceMap(), mapperLen_) + ); + auto& directAddr = *directAddrPtr_; - // Reset the size of addressing list to contain only live faces - directAddr.setSize(mesh_.nFaces()); + insertedObjectsPtr_ = std::make_unique(); + auto& inserted = *insertedObjectsPtr_; - insertedFaceLabelsPtr_ = new labelList(mesh_.nFaces()); - labelList& insertedFaces = *insertedFaceLabelsPtr_; - - label nInsertedFaces = 0; - - forAll(directAddr, facei) + // The nInsertedObjects_ already counted in the constructor + if (nInsertedObjects_) { - if (directAddr[facei] < 0) - { - // Found inserted face - directAddr[facei] = 0; - insertedFaces[nInsertedFaces] = facei; - nInsertedFaces++; - } - } + inserted.resize(nInsertedObjects_); - insertedFaces.setSize(nInsertedFaces); + label nInserted = 0; + forAll(directAddr, i) + { + if (directAddr[i] < 0) + { + // Found inserted + directAddr[i] = 0; + inserted[nInserted] = i; + ++nInserted; + + // TBD: check (nInsertedObjects_ < nInserted)? + #ifdef FULLDEBUG + if (nInsertedObjects_ < nInserted) + { + FatalErrorInFunction + << "Unexpected insert of more than " + << nInsertedObjects_ << " items\n" + << abort(FatalError); + } + #endif + } + } + // TBD: check (nInserted < nInsertedObjects_)? + #ifdef FULLDEBUG + if (nInserted < nInsertedObjects_) + { + WarningInFunction + << "Found " << nInserted << " instead of " + << nInsertedObjects_ << " items to insert\n"; + } + #endif + // The resize should be unnecessary + inserted.resize(nInserted); + } } else { // Interpolative addressing - interpolationAddrPtr_ = new labelListList(mesh_.nFaces()); - labelListList& addr = *interpolationAddrPtr_; + interpAddrPtr_ = std::make_unique(mapperLen_); + auto& addr = *interpAddrPtr_; - weightsPtr_ = new scalarListList(mesh_.nFaces()); - scalarListList& w = *weightsPtr_; + weightsPtr_ = std::make_unique(mapperLen_); + auto& wght = *weightsPtr_; - const List& ffp = mpm_.facesFromPointsMap(); - forAll(ffp, ffpI) + // Set the addressing and uniform weight + const auto setAddrWeights = [&] + ( + const List& maps, + const char * const nameOfMap + ) { - // Get addressing - const labelList& mo = ffp[ffpI].masterObjects(); - - label facei = ffp[ffpI].index(); - - if (addr[facei].size()) + for (const objectMap& map : maps) { - FatalErrorInFunction - << "Master face " << facei - << " mapped from point faces " << mo - << " already destination of mapping." << abort(FatalError); + // Get index, addressing + const label facei = map.index(); + const labelList& mo = map.masterObjects(); + if (mo.empty()) continue; // safety + + if (addr[facei].size()) + { + FatalErrorInFunction + << "Master face " << facei + << " already mapped, cannot apply " + << nameOfMap + << flatOutput(mo) << abort(FatalError); + } + + // Map from masters, uniform weights + addr[facei] = mo; + wght[facei] = scalarList(mo.size(), 1.0/mo.size()); } + }; - // Map from masters, uniform weights - addr[facei] = mo; - w[facei] = scalarList(mo.size(), 1.0/mo.size()); - } - const List& ffe = mpm_.facesFromEdgesMap(); + setAddrWeights(mpm_.facesFromPointsMap(), "point faces"); + setAddrWeights(mpm_.facesFromEdgesMap(), "edge faces"); + setAddrWeights(mpm_.facesFromFacesMap(), "face faces"); + + + // Do mapped faces. + // - may already have been set, so check if addressing still empty(). - forAll(ffe, ffeI) { - // Get addressing - const labelList& mo = ffe[ffeI].masterObjects(); + const labelList& map = mpm_.faceMap(); - label facei = ffe[ffeI].index(); - - if (addr[facei].size()) + // NB: faceMap can be longer than nFaces() + for (label facei = 0; facei < mapperLen_; ++facei) { - FatalErrorInFunction - << "Master face " << facei - << " mapped from edge faces " << mo - << " already destination of mapping." << abort(FatalError); - } + const label mappedi = map[facei]; - // Map from masters, uniform weights - addr[facei] = mo; - w[facei] = scalarList(mo.size(), 1.0/mo.size()); - } - - const List& fff = mpm_.facesFromFacesMap(); - - forAll(fff, fffI) - { - // Get addressing - const labelList& mo = fff[fffI].masterObjects(); - - label facei = fff[fffI].index(); - - if (addr[facei].size()) - { - FatalErrorInFunction - << "Master face " << facei - << " mapped from face faces " << mo - << " already destination of mapping." << abort(FatalError); - } - - // Map from masters, uniform weights - addr[facei] = mo; - w[facei] = scalarList(mo.size(), 1.0/mo.size()); - } - - - // Do mapped faces. Note that can already be set from facesFromFaces - // so check if addressing size still zero. - const labelList& fm = mpm_.faceMap(); - - forAll(fm, facei) - { - if (fm[facei] > -1 && addr[facei].empty()) - { - // Mapped from a single face - addr[facei] = labelList(1, fm[facei]); - w[facei] = scalarList(1, 1.0); + if (mappedi >= 0 && addr[facei].empty()) + { + // Mapped from a single face + addr[facei].resize(1, mappedi); + wght[facei].resize(1, 1.0); + } } } // Grab inserted faces (for them the size of addressing is still zero) - insertedFaceLabelsPtr_ = new labelList(mesh_.nFaces()); - labelList& insertedFaces = *insertedFaceLabelsPtr_; + insertedObjectsPtr_ = std::make_unique(); + auto& inserted = *insertedObjectsPtr_; - label nInsertedFaces = 0; - - forAll(addr, facei) + // The nInsertedObjects_ already counted in the constructor + if (nInsertedObjects_) { - if (addr[facei].empty()) + inserted.resize(nInsertedObjects_); + + label nInserted = 0; + forAll(addr, i) { - // Mapped from a dummy face - addr[facei] = labelList(1, Zero); - w[facei] = scalarList(1, scalar(1)); + if (addr[i].empty()) + { + // Mapped from dummy face 0 + addr[i].resize(1, 0); + wght[i].resize(1, 1.0); - insertedFaces[nInsertedFaces] = facei; - nInsertedFaces++; + inserted[nInserted] = i; + ++nInserted; + + // TBD: check (nInsertedObjects_ < nInserted)? + #ifdef FULLDEBUG + if (nInsertedObjects_ < nInserted) + { + FatalErrorInFunction + << "Unexpected insert of more than " + << nInsertedObjects_ << " items\n" + << abort(FatalError); + } + #endif + } } + // TBD: check (nInserted < nInsertedObjects_)? + #ifdef FULLDEBUG + if (nInserted < nInsertedObjects_) + { + WarningInFunction + << "Found " << nInserted << " instead of " + << nInsertedObjects_ << " items to insert\n"; + } + #endif + // The resize should be unnecessary + inserted.resize(nInserted); } - - insertedFaces.setSize(nInsertedFaces); } } -void Foam::faceMapper::clearOut() -{ - deleteDemandDrivenData(directAddrPtr_); - deleteDemandDrivenData(interpolationAddrPtr_); - deleteDemandDrivenData(weightsPtr_); - deleteDemandDrivenData(insertedFaceLabelsPtr_); -} +// void Foam::faceMapper::clearOut() +// { +// directAddrPtr_.reset(nullptr); +// interpAddrPtr_.reset(nullptr); +// weightsPtr_.reset(nullptr); +// insertedObjectsPtr_.reset(nullptr); +// } // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // Foam::faceMapper::faceMapper(const mapPolyMesh& mpm) : - mesh_(mpm.mesh()), mpm_(mpm), - insertedFaces_(true), - direct_(false), - directAddrPtr_(nullptr), - interpolationAddrPtr_(nullptr), - weightsPtr_(nullptr), - insertedFaceLabelsPtr_(nullptr) -{ - // Check for possibility of direct mapping - if + mapperLen_(mpm.mesh().nFaces()), + nInsertedObjects_(0), + direct_ ( - mpm_.facesFromPointsMap().empty() - && mpm_.facesFromEdgesMap().empty() - && mpm_.facesFromFacesMap().empty() + // Mapping without interpolation? + mpm.facesFromPointsMap().empty() + && mpm.facesFromEdgesMap().empty() + && mpm.facesFromFacesMap().empty() ) +{ + const auto& directMap = mpm_.faceMap(); + + if (!mapperLen_) { + // Empty mesh direct_ = true; + nInsertedObjects_ = 0; + } + else if (direct_) + { + // Number of inserted faces (-ve values) + nInsertedObjects_ = std::count_if + ( + directMap.cbegin(), + directMap.cbegin(mapperLen_), + [](label i) { return (i < 0); } + ); } else { - direct_ = false; - } + // Check if there are inserted faces with no owner + // (check all lists) - // Check for inserted faces - if (direct_ && (mpm_.faceMap().empty() || min(mpm_.faceMap()) > -1)) - { - insertedFaces_ = false; - } - else - { - // Need to check all 3 lists to see if there are inserted faces - // with no owner + bitSet unmapped(mapperLen_, true); - // Make a copy of the face map, add the entries for faces from points - // and faces from edges and check for left-overs - labelList fm(mesh_.nFaces(), -1); + unmapped.unset(directMap); // direct mapped - const List& ffp = mpm_.facesFromPointsMap(); - - forAll(ffp, ffpI) + for (const auto& map : mpm_.facesFromPointsMap()) { - fm[ffp[ffpI].index()] = 0; + if (!map.empty()) unmapped.unset(map.index()); } - const List& ffe = mpm_.facesFromEdgesMap(); - - forAll(ffe, ffeI) + for (const auto& map : mpm_.facesFromEdgesMap()) { - fm[ffe[ffeI].index()] = 0; + if (!map.empty()) unmapped.unset(map.index()); } - const List& fff = mpm_.facesFromFacesMap(); - - forAll(fff, fffI) + for (const auto& map : mpm_.facesFromFacesMap()) { - fm[fff[fffI].index()] = 0; + if (!map.empty()) unmapped.unset(map.index()); } - if (min(fm) < 0) - { - insertedFaces_ = true; - } + nInsertedObjects_ = label(unmapped.count()); } } @@ -275,16 +292,14 @@ Foam::faceMapper::faceMapper(const mapPolyMesh& mpm) // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // Foam::faceMapper::~faceMapper() -{ - clearOut(); -} +{} // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // Foam::label Foam::faceMapper::size() const { - return mesh_.nFaces(); + return mapperLen_; } @@ -335,12 +350,12 @@ const Foam::labelListList& Foam::faceMapper::addressing() const << abort(FatalError); } - if (!interpolationAddrPtr_) + if (!interpAddrPtr_) { calcAddressing(); } - return *interpolationAddrPtr_; + return *interpAddrPtr_; } @@ -364,20 +379,18 @@ const Foam::scalarListList& Foam::faceMapper::weights() const const Foam::labelList& Foam::faceMapper::insertedObjectLabels() const { - if (!insertedFaceLabelsPtr_) + if (!insertedObjectsPtr_) { - if (!insertedObjects()) + if (!nInsertedObjects_) { - // There are no inserted faces - insertedFaceLabelsPtr_ = new labelList(0); - } - else - { - calcAddressing(); + // No inserted objects will be created + return labelList::null(); } + + calcAddressing(); } - return *insertedFaceLabelsPtr_; + return *insertedObjectsPtr_; } diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.H b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.H index b5f43bad23..a1b331835d 100644 --- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.H +++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.H @@ -6,6 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011-2013 OpenFOAM Foundation + Copyright (C) 2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -36,8 +37,8 @@ SourceFiles \*---------------------------------------------------------------------------*/ -#ifndef faceMapper_H -#define faceMapper_H +#ifndef Foam_faceMapper_H +#define Foam_faceMapper_H #include "morphFieldMapper.H" #include "HashSet.H" @@ -47,8 +48,7 @@ SourceFiles namespace Foam { -// Forward declaration of classes -class polyMesh; +// Forward Declarations class mapPolyMesh; /*---------------------------------------------------------------------------*\ @@ -59,38 +59,45 @@ class faceMapper : public morphFieldMapper { - // Private data - - //- Reference to polyMesh - const polyMesh& mesh_; + // Private Data //- Reference to mapPolyMesh const mapPolyMesh& mpm_; - //- Are there any inserted (unmapped) faces - bool insertedFaces_; + //- The size of the mapper = polyMesh::nFaces() + const label mapperLen_; + + //- Number of inserted (unmapped) faces + label nInsertedObjects_; //- Is the mapping direct bool direct_; - // Demand-driven private data + // Demand-Driven Data //- Direct addressing (only one for of addressing is used) - mutable labelList* directAddrPtr_; + mutable std::unique_ptr directAddrPtr_; //- Interpolated addressing (only one for of addressing is used) - mutable labelListList* interpolationAddrPtr_; + mutable std::unique_ptr interpAddrPtr_; //- Interpolation weights - mutable scalarListList* weightsPtr_; + mutable std::unique_ptr weightsPtr_; //- Inserted faces - mutable labelList* insertedFaceLabelsPtr_; + mutable std::unique_ptr insertedObjectsPtr_; // Private Member Functions + //- Calculate addressing for mapping with inserted faces + void calcAddressing() const; + +public: + + // Generated Methods + //- No copy construct faceMapper(const faceMapper&) = delete; @@ -98,21 +105,10 @@ class faceMapper void operator=(const faceMapper&) = delete; - //- Calculate addressing for mapping with inserted faces - void calcAddressing() const; - - //- Clear out local storage - void clearOut(); - - -public: - - // Static data members - // Constructors //- Construct from mapPolyMesh - faceMapper(const mapPolyMesh& mpm); + explicit faceMapper(const mapPolyMesh& mpm); //- Destructor @@ -121,7 +117,7 @@ public: // Member Functions - //- Return size + //- The mapper size virtual label size() const; //- Return size of field before mapping @@ -165,7 +161,7 @@ public: //- Are there any inserted faces virtual bool insertedObjects() const { - return insertedFaces_; + return bool(nInsertedObjects_); } //- Return list of inserted faces diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapPolyMesh.C b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapPolyMesh.C index ee7694bb11..5baa1ac33f 100644 --- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapPolyMesh.C +++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapPolyMesh.C @@ -257,7 +257,7 @@ Foam::mapPolyMesh::mapPolyMesh oldCellVolumesPtr_ = oldCellVolumesPtr.clone(); } - if (oldPatchStarts_.size() > 0) + if (oldPatchStarts_.size()) { // Calculate old patch sizes for (label patchi = 0; patchi < oldPatchStarts_.size() - 1; patchi++) diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapPolyMesh.H b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapPolyMesh.H index a7b8f955a5..38bb76e580 100644 --- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapPolyMesh.H +++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapPolyMesh.H @@ -6,7 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011-2016 OpenFOAM Foundation - Copyright (C) 2020 OpenCFD Ltd. + Copyright (C) 2020-2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -153,6 +153,7 @@ SourceFiles namespace Foam { +// Forward Declarations class polyMesh; /*---------------------------------------------------------------------------*\ @@ -161,7 +162,7 @@ class polyMesh; class mapPolyMesh { - // Private data + // Private Data //- Reference to polyMesh const polyMesh& mesh_; @@ -273,7 +274,9 @@ class mapPolyMesh autoPtr oldCellVolumesPtr_; - // Private Member Functions +public: + + // Generated Methods //- No copy construct mapPolyMesh(const mapPolyMesh&) = delete; @@ -282,14 +285,13 @@ class mapPolyMesh void operator=(const mapPolyMesh&) = delete; -public: - // Constructors //- Construct from mesh mapPolyMesh(const polyMesh& mesh); - //- Construct from components. Copy (except for oldCellVolumes). + //- Copy construct from components, + //- except for oldCellVolumes which is move construct mapPolyMesh ( const polyMesh& mesh, @@ -356,18 +358,19 @@ public: const bool reuse ); + // Member Functions // Access //- Return polyMesh - const polyMesh& mesh() const + const polyMesh& mesh() const noexcept { return mesh_; } //- Number of old points - label nOldPoints() const + label nOldPoints() const noexcept { return nOldPoints_; } @@ -379,13 +382,13 @@ public: } //- Number of old faces - label nOldFaces() const + label nOldFaces() const noexcept { return nOldFaces_; } //- Number of old cells - label nOldCells() const + label nOldCells() const noexcept { return nOldCells_; } @@ -394,13 +397,13 @@ public: // Contains the old point label for all new points. // For preserved points this is the old point label. // For added points this is the master point ID - const labelList& pointMap() const + const labelList& pointMap() const noexcept { return pointMap_; } //- Points originating from points - const List& pointsFromPointsMap() const + const List& pointsFromPointsMap() const noexcept { return pointsFromPointsMap_; } @@ -408,56 +411,56 @@ public: //- Old face map. // Contains a list of old face labels for every new face. // Warning: this map contains invalid entries for new faces - const labelList& faceMap() const + const labelList& faceMap() const noexcept { return faceMap_; } //- Faces inflated from points - const List& facesFromPointsMap() const + const List& facesFromPointsMap() const noexcept { return facesFromPointsMap_; } //- Faces inflated from edges - const List& facesFromEdgesMap() const + const List& facesFromEdgesMap() const noexcept { return facesFromEdgesMap_; } //- Faces originating from faces - const List& facesFromFacesMap() const + const List& facesFromFacesMap() const noexcept { return facesFromFacesMap_; } //- Old cell map. // Contains old cell label for all preserved cells. - const labelList& cellMap() const + const labelList& cellMap() const noexcept { return cellMap_; } //- Cells inflated from points - const List& cellsFromPointsMap() const + const List& cellsFromPointsMap() const noexcept { return cellsFromPointsMap_; } //- Cells inflated from edges - const List& cellsFromEdgesMap() const + const List& cellsFromEdgesMap() const noexcept { return cellsFromEdgesMap_; } //- Cells inflated from faces - const List& cellsFromFacesMap() const + const List& cellsFromFacesMap() const noexcept { return cellsFromFacesMap_; } //- Cells originating from cells - const List& cellsFromCellsMap() const + const List& cellsFromCellsMap() const noexcept { return cellsFromCellsMap_; } @@ -467,7 +470,7 @@ public: //- Reverse point map // Contains new point label for all old and added points - const labelList& reversePointMap() const + const labelList& reversePointMap() const noexcept { return reversePointMap_; } @@ -499,7 +502,7 @@ public: //- Reverse face map // Contains new face label for all old and added faces - const labelList& reverseFaceMap() const + const labelList& reverseFaceMap() const noexcept { return reverseFaceMap_; } @@ -530,7 +533,7 @@ public: //- Reverse cell map // Contains new cell label for all old and added cells - const labelList& reverseCellMap() const + const labelList& reverseCellMap() const noexcept { return reverseCellMap_; } @@ -560,7 +563,7 @@ public: } //- Map of flipped face flux faces - const labelHashSet& flipFaceFlux() const + const labelHashSet& flipFaceFlux() const noexcept { return flipFaceFlux_; } @@ -568,7 +571,7 @@ public: //- Patch point renumbering // For every preserved point on a patch give the old position. // For added points, the index is set to -1 - const labelListList& patchPointMap() const + const labelListList& patchPointMap() const noexcept { return patchPointMap_; } @@ -579,7 +582,7 @@ public: //- Point zone renumbering // For every preserved point in zone give the old position. // For added points, the index is set to -1 - const labelListList& pointZoneMap() const + const labelListList& pointZoneMap() const noexcept { return pointZoneMap_; } @@ -587,7 +590,7 @@ public: //- Face zone point renumbering // For every preserved point in zone give the old position. // For added points, the index is set to -1 - const labelListList& faceZonePointMap() const + const labelListList& faceZonePointMap() const noexcept { return faceZonePointMap_; } @@ -595,7 +598,7 @@ public: //- Face zone face renumbering // For every preserved face in zone give the old position. // For added faces, the index is set to -1 - const labelListList& faceZoneFaceMap() const + const labelListList& faceZoneFaceMap() const noexcept { return faceZoneFaceMap_; } @@ -603,7 +606,7 @@ public: //- Cell zone renumbering // For every preserved cell in zone give the old position. // For added cells, the index is set to -1 - const labelListList& cellZoneMap() const + const labelListList& cellZoneMap() const noexcept { return cellZoneMap_; } @@ -611,49 +614,48 @@ public: //- Pre-motion point positions. // This specifies the correct way of blowing up // zero-volume objects - const pointField& preMotionPoints() const + const pointField& preMotionPoints() const noexcept { return preMotionPoints_; } //- Has valid preMotionPoints? - bool hasMotionPoints() const + bool hasMotionPoints() const noexcept { - return preMotionPoints_.size() > 0; + return !preMotionPoints_.empty(); } //- Return list of the old patch sizes - const labelList& oldPatchSizes() const + const labelList& oldPatchSizes() const noexcept { return oldPatchSizes_; } //- Return list of the old patch start labels - const labelList& oldPatchStarts() const + const labelList& oldPatchStarts() const noexcept { return oldPatchStarts_; } //- Return numbers of mesh points per old patch - const labelList& oldPatchNMeshPoints() const + const labelList& oldPatchNMeshPoints() const noexcept { return oldPatchNMeshPoints_; } - // Geometric mapping data + // Geometric mapping data - bool hasOldCellVolumes() const - { - return bool(oldCellVolumesPtr_); - } - - const scalarField& oldCellVolumes() const - { - return *oldCellVolumesPtr_; - } + bool hasOldCellVolumes() const noexcept + { + return bool(oldCellVolumesPtr_); + } + const scalarField& oldCellVolumes() const + { + return *oldCellVolumesPtr_; + } }; diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/objectMap/objectMap.H b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/objectMap/objectMap.H index 676ae13729..4b739eeafe 100644 --- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/objectMap/objectMap.H +++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/objectMap/objectMap.H @@ -6,6 +6,7 @@ \\/ M anipulation | ------------------------------------------------------------------------------- Copyright (C) 2011 OpenFOAM Foundation + Copyright (C) 2024 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -35,10 +36,10 @@ SourceFiles \*---------------------------------------------------------------------------*/ -#ifndef objectMap_H -#define objectMap_H +#ifndef Foam_objectMap_H +#define Foam_objectMap_H -#include "labelList.H" +#include "List.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // @@ -46,7 +47,6 @@ namespace Foam { // Forward Declarations - class objectMap; inline bool operator==(const objectMap& a, const objectMap& b); inline bool operator!=(const objectMap& a, const objectMap& b); @@ -60,38 +60,51 @@ inline Istream& operator>>(Istream&, objectMap&); class objectMap { - // Private data + // Private Data //- Object index label index_; - //- Master object index - labelList masterObjects_; + //- Master object indices + labelList objects_; public: // Constructors - //- Null constructor, with index=-1 and no objects - inline objectMap(); + //- Default construct, with index=-1 and no objects + objectMap() noexcept : index_(-1) {} - //- Construct from components - inline objectMap(const label index, const UList