From f1bff601a6003f3adcbb1a8c6144157b258c77da Mon Sep 17 00:00:00 2001 From: mattijs Date: Wed, 2 Feb 2011 15:48:58 +0000 Subject: [PATCH 01/30] ENH: dictionary::found : optionally disable wildcards --- .../foamUpgradeCyclics/foamUpgradeCyclics.C | 16 ++++++++++------ src/OpenFOAM/db/dictionary/dictionary.C | 15 ++++++++++----- src/OpenFOAM/db/dictionary/dictionary.H | 10 ++++++++-- 3 files changed, 28 insertions(+), 13 deletions(-) diff --git a/applications/utilities/preProcessing/foamUpgradeCyclics/foamUpgradeCyclics.C b/applications/utilities/preProcessing/foamUpgradeCyclics/foamUpgradeCyclics.C index 84f3c5652b..b3f5e7baab 100644 --- a/applications/utilities/preProcessing/foamUpgradeCyclics/foamUpgradeCyclics.C +++ b/applications/utilities/preProcessing/foamUpgradeCyclics/foamUpgradeCyclics.C @@ -300,19 +300,23 @@ void rewriteField Info<< "Looking for entry for patch " << patchName << endl; - if (boundaryField.found(patchName) && !boundaryField.found(newName)) + // Find old patch name either direct or through wildcards + // Find new patch name direct only + + if + ( + boundaryField.found(patchName) + && !boundaryField.found(newName, false, false) + ) { Info<< " Changing entry " << patchName << " to " << newName << endl; - dictionary patchDict(boundaryField.subDict(patchName)); + dictionary& patchDict = boundaryField.subDict(patchName); if (patchDict.found("value")) { - IOWarningIn("rewriteField(..)", patchDict) - << "Cyclic patch " << patchName - << " has value entry. This will be removed." - << endl; + // Remove any value field since wrong size. patchDict.remove("value"); } diff --git a/src/OpenFOAM/db/dictionary/dictionary.C b/src/OpenFOAM/db/dictionary/dictionary.C index cc8550bab9..7539f6d7de 100644 --- a/src/OpenFOAM/db/dictionary/dictionary.C +++ b/src/OpenFOAM/db/dictionary/dictionary.C @@ -2,7 +2,7 @@ ========= | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / O peration | - \\ / A nd | Copyright (C) 2004-2010 OpenCFD Ltd. + \\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd. \\/ M anipulation | ------------------------------------------------------------------------------- License @@ -260,7 +260,12 @@ Foam::SHA1Digest Foam::dictionary::digest() const } -bool Foam::dictionary::found(const word& keyword, bool recursive) const +bool Foam::dictionary::found +( + const word& keyword, + bool recursive, + bool patternMatch +) const { if (hashedEntries_.found(keyword)) { @@ -268,7 +273,7 @@ bool Foam::dictionary::found(const word& keyword, bool recursive) const } else { - if (patternEntries_.size()) + if (patternMatch && patternEntries_.size()) { DLList::const_iterator wcLink = patternEntries_.begin(); @@ -276,7 +281,7 @@ bool Foam::dictionary::found(const word& keyword, bool recursive) const patternRegexps_.begin(); // Find in patterns using regular expressions only - if (findInPatterns(true, keyword, wcLink, reLink)) + if (findInPatterns(patternMatch, keyword, wcLink, reLink)) { return true; } @@ -284,7 +289,7 @@ bool Foam::dictionary::found(const word& keyword, bool recursive) const if (recursive && &parent_ != &dictionary::null) { - return parent_.found(keyword, recursive); + return parent_.found(keyword, recursive, patternMatch); } else { diff --git a/src/OpenFOAM/db/dictionary/dictionary.H b/src/OpenFOAM/db/dictionary/dictionary.H index 023ea225eb..ebd0dc9ea1 100644 --- a/src/OpenFOAM/db/dictionary/dictionary.H +++ b/src/OpenFOAM/db/dictionary/dictionary.H @@ -2,7 +2,7 @@ ========= | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / O peration | - \\ / A nd | Copyright (C) 2004-2010 OpenCFD Ltd. + \\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd. \\/ M anipulation | ------------------------------------------------------------------------------- License @@ -264,7 +264,13 @@ public: //- Search dictionary for given keyword // If recursive, search parent dictionaries - bool found(const word&, bool recursive=false) const; + // If patternMatch, use regular expressions + bool found + ( + const word&, + bool recursive=false, + bool patternMatch = true + ) const; //- Find and return an entry data stream pointer if present // otherwise return NULL. From c3ae505e334c129cbc962f66fe57d2b89b173306 Mon Sep 17 00:00:00 2001 From: mattijs Date: Wed, 2 Feb 2011 17:34:08 +0000 Subject: [PATCH 02/30] BUG: globalMeshData : fix edge master-slave addressing --- .../polyMesh/globalMeshData/globalMeshData.C | 539 ++++++++++++++---- .../polyMesh/globalMeshData/globalMeshData.H | 27 +- .../polyMesh/globalMeshData/globalPoints.C | 45 +- .../polyMesh/globalMeshData/globalPoints.H | 12 - .../globalIndexAndTransform.H | 25 + .../globalIndexAndTransformI.H | 64 +++ 6 files changed, 532 insertions(+), 180 deletions(-) diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C index fd39d1d0f8..aec5e8ffd3 100644 --- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C +++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C @@ -552,25 +552,102 @@ void Foam::globalMeshData::calcGlobalPointSlaves() const } -void Foam::globalMeshData::calcGlobalEdgeSlaves() const +void Foam::globalMeshData::calcPointConnectivity +( + List& allPointConnectivity +) const { - if (debug) + const globalIndexAndTransform& transforms = globalTransforms(); + const labelListList& slaves = globalPointSlaves(); + const labelListList& transformedSlaves = globalPointTransformedSlaves(); + + + // Create field with my local data + labelPairList myData(globalPointSlavesMap().constructSize()); + forAll(slaves, pointI) { - Pout<< "globalMeshData::calcGlobalEdgeSlaves() :" - << " calculating coupled master to slave edge addressing." << endl; + myData[pointI] = globalIndexAndTransform::encode + ( + Pstream::myProcNo(), + pointI, + transforms.nullTransformIndex() + ); } - - // - Send across connected edges (in global edge addressing) - // - Check on receiving side whether edge has same slave edge - // on both endpoints. + // Send over. + globalPointSlavesMap().distribute(myData); - // Coupled point to global coupled edges. - labelListList globalPointEdges(globalPointSlavesMap().constructSize()); + // String of connected points with their transform + allPointConnectivity.setSize(globalPointSlavesMap().constructSize()); + forAll(slaves, pointI) + { + // Reconstruct string of connected points + const labelList& pSlaves = slaves[pointI]; + const labelList& pTransformSlaves = transformedSlaves[pointI]; + labelPairList& pConnectivity = allPointConnectivity[pointI]; + pConnectivity.setSize(1+pSlaves.size()+pTransformSlaves.size()); + label connI = 0; - // Create local version + // Add myself + pConnectivity[connI++] = myData[pointI]; + // Add untransformed points + forAll(pSlaves, i) + { + pConnectivity[connI++] = myData[pSlaves[i]]; + } + // Add transformed points. + forAll(pTransformSlaves, i) + { + // Get transform from index + label transformI = globalPointSlavesMap().whichTransform + ( + pTransformSlaves[i] + ); + // Add transform to connectivity + const labelPair& n = myData[pTransformSlaves[i]]; + label procI = globalIndexAndTransform::processor(n); + label index = globalIndexAndTransform::index(n); + pConnectivity[connI++] = globalIndexAndTransform::encode + ( + procI, + index, + transformI + ); + } + + // Put back in slots + forAll(pSlaves, i) + { + allPointConnectivity[pSlaves[i]] = pConnectivity; + } + forAll(pTransformSlaves, i) + { + allPointConnectivity[pTransformSlaves[i]] = pConnectivity; + } + } + globalPointSlavesMap().reverseDistribute + ( + allPointConnectivity.size(), + allPointConnectivity + ); +} + + +void Foam::globalMeshData::calcGlobalPointEdges +( + labelListList& globalPointEdges, + List& globalPointPoints +) const +{ + const edgeList& edges = coupledPatch().edges(); const labelListList& pointEdges = coupledPatch().pointEdges(); const globalIndex& globalEdgeNumbers = globalEdgeNumbering(); + const labelListList& slaves = globalPointSlaves(); + const labelListList& transformedSlaves = globalPointTransformedSlaves(); + + // Create local version + globalPointEdges.setSize(globalPointSlavesMap().constructSize()); + globalPointPoints.setSize(globalPointSlavesMap().constructSize()); forAll(pointEdges, pointI) { const labelList& pEdges = pointEdges[pointI]; @@ -580,154 +657,374 @@ void Foam::globalMeshData::calcGlobalEdgeSlaves() const { globalPEdges[i] = globalEdgeNumbers.toGlobal(pEdges[i]); } + + labelPairList& globalPPoints = globalPointPoints[pointI]; + globalPPoints.setSize(pEdges.size()); + forAll(pEdges, i) + { + label otherPointI = edges[pEdges[i]].otherVertex(pointI); + globalPPoints[i] = globalIndexAndTransform::encode + ( + Pstream::myProcNo(), + otherPointI, + globalTransforms().nullTransformIndex() + ); + } } // Pull slave data to master. Dummy transform. globalPointSlavesMap().distribute(globalPointEdges); + globalPointSlavesMap().distribute(globalPointPoints); + // Add all pointEdges + forAll(slaves, pointI) + { + const labelList& pSlaves = slaves[pointI]; + const labelList& pTransformSlaves = transformedSlaves[pointI]; + + label n = 0; + forAll(pSlaves, i) + { + n += globalPointEdges[pSlaves[i]].size(); + } + forAll(pTransformSlaves, i) + { + n += globalPointEdges[pTransformSlaves[i]].size(); + } + + // Add all the point edges of the slaves to those of the (master) point + { + labelList& globalPEdges = globalPointEdges[pointI]; + label sz = globalPEdges.size(); + globalPEdges.setSize(sz+n); + forAll(pSlaves, i) + { + const labelList& otherData = globalPointEdges[pSlaves[i]]; + forAll(otherData, j) + { + globalPEdges[sz++] = otherData[j]; + } + } + forAll(pTransformSlaves, i) + { + const labelList& otherData = + globalPointEdges[pTransformSlaves[i]]; + forAll(otherData, j) + { + globalPEdges[sz++] = otherData[j]; + } + } + + // Put back in slots + forAll(pSlaves, i) + { + globalPointEdges[pSlaves[i]] = globalPEdges; + } + forAll(pTransformSlaves, i) + { + globalPointEdges[pTransformSlaves[i]] = globalPEdges; + } + } - // Now check on master if any of my edges are also on slave. - // This assumes that if slaves have a coupled edge it is also on - // the master (otherwise the mesh would be illegal anyway) + // Same for corresponding pointPoints + { + labelPairList& globalPPoints = globalPointPoints[pointI]; + label sz = globalPPoints.size(); + globalPPoints.setSize(sz + n); - // From global edge to slot in distributed data. - Map