From 4dda4ad1977aad008ded393f08a7e2dee1d46bb0 Mon Sep 17 00:00:00 2001 From: Mark Olesen Date: Thu, 11 Aug 2016 19:35:22 +0200 Subject: [PATCH] DEFEATURE: remove unused meshTriangulation class (issue #294) --- src/triSurface/Make/files | 1 - .../meshTriangulation/meshTriangulation.C | 511 ------------------ .../meshTriangulation/meshTriangulation.H | 152 ------ 3 files changed, 664 deletions(-) delete mode 100644 src/triSurface/meshTriangulation/meshTriangulation.C delete mode 100644 src/triSurface/meshTriangulation/meshTriangulation.H diff --git a/src/triSurface/Make/files b/src/triSurface/Make/files index bb896bb088..933110a4c6 100644 --- a/src/triSurface/Make/files +++ b/src/triSurface/Make/files @@ -1,5 +1,4 @@ faceTriangulation/faceTriangulation.C -meshTriangulation/meshTriangulation.C triSurface/triSurface.C triSurface/triSurfaceAddressing.C diff --git a/src/triSurface/meshTriangulation/meshTriangulation.C b/src/triSurface/meshTriangulation/meshTriangulation.C deleted file mode 100644 index e0d8a753d0..0000000000 --- a/src/triSurface/meshTriangulation/meshTriangulation.C +++ /dev/null @@ -1,511 +0,0 @@ -/*---------------------------------------------------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | - \\ / A nd | Copyright (C) 2011-2016 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 . - -\*---------------------------------------------------------------------------*/ - -#include "meshTriangulation.H" -#include "polyMesh.H" -#include "faceTriangulation.H" - -// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // - -bool Foam::meshTriangulation::isInternalFace -( - const primitiveMesh& mesh, - const boolList& includedCell, - const label facei -) -{ - if (mesh.isInternalFace(facei)) - { - label own = mesh.faceOwner()[facei]; - label nei = mesh.faceNeighbour()[facei]; - - if (includedCell[own] && includedCell[nei]) - { - // Neighbouring cell will get included in subset - // as well so face is internal. - return true; - } - else - { - return false; - } - } - else - { - return false; - } -} - - -void Foam::meshTriangulation::getFaces -( - const primitiveMesh& mesh, - const boolList& includedCell, - boolList& faceIsCut, - label& nFaces, - label& nInternalFaces -) -{ - // All faces to be triangulated. - faceIsCut.setSize(mesh.nFaces()); - faceIsCut = false; - - nFaces = 0; - nInternalFaces = 0; - - forAll(includedCell, celli) - { - // Include faces of cut cells only. - if (includedCell[celli]) - { - const labelList& cFaces = mesh.cells()[celli]; - - forAll(cFaces, i) - { - label facei = cFaces[i]; - - if (!faceIsCut[facei]) - { - // First visit of face. - nFaces++; - faceIsCut[facei] = true; - - // See if would become internal or external face - if (isInternalFace(mesh, includedCell, facei)) - { - nInternalFaces++; - } - } - } - } - } - - Pout<< "Subset consists of " << nFaces << " faces out of " << mesh.nFaces() - << " of which " << nInternalFaces << " are internal" << endl; -} - - -void Foam::meshTriangulation::insertTriangles -( - const triFaceList& faceTris, - const label facei, - const label regionI, - const bool reverse, - - List& triangles, - label& triI -) -{ - // Copy triangles. Optionally reverse them - forAll(faceTris, i) - { - const triFace& f = faceTris[i]; - - labelledTri& tri = triangles[triI]; - - if (reverse) - { - tri[0] = f[0]; - tri[2] = f[1]; - tri[1] = f[2]; - } - else - { - tri[0] = f[0]; - tri[1] = f[1]; - tri[2] = f[2]; - } - - tri.region() = regionI; - - faceMap_[triI] = facei; - - triI++; - } -} - - -// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // - -// Null constructor -Foam::meshTriangulation::meshTriangulation() -: - triSurface(), - nInternalFaces_(0), - faceMap_() -{} - - -// Construct from faces of cells -Foam::meshTriangulation::meshTriangulation -( - const polyMesh& mesh, - const label internalFacesPatch, - const boolList& includedCell, - const bool faceCentreDecomposition -) -: - triSurface(), - nInternalFaces_(0), - faceMap_() -{ - const faceList& faces = mesh.faces(); - const pointField& points = mesh.points(); - const polyBoundaryMesh& patches = mesh.boundaryMesh(); - - // All faces to be triangulated. - boolList faceIsCut; - label nFaces, nInternalFaces; - - getFaces - ( - mesh, - includedCell, - faceIsCut, - nFaces, - nInternalFaces - ); - - - // Find upper limit for number of triangles - // (can be less if triangulation fails) - label nTotTri = 0; - - if (faceCentreDecomposition) - { - forAll(faceIsCut, facei) - { - if (faceIsCut[facei]) - { - nTotTri += faces[facei].size(); - } - } - } - else - { - forAll(faceIsCut, facei) - { - if (faceIsCut[facei]) - { - nTotTri += faces[facei].nTriangles(points); - } - } - } - Pout<< "nTotTri : " << nTotTri << endl; - - - // Storage for new and old points (only for faceCentre decomposition; - // for triangulation uses only existing points) - pointField newPoints; - - if (faceCentreDecomposition) - { - newPoints.setSize(mesh.nPoints() + faces.size()); - forAll(mesh.points(), pointi) - { - newPoints[pointi] = mesh.points()[pointi]; - } - // Face centres - forAll(faces, facei) - { - newPoints[mesh.nPoints() + facei] = mesh.faceCentres()[facei]; - } - } - - // Storage for all triangles - List triangles(nTotTri); - faceMap_.setSize(nTotTri); - label triI = 0; - - - if (faceCentreDecomposition) - { - // Decomposition around face centre - // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - - // Triangulate internal faces - forAll(faceIsCut, facei) - { - if (faceIsCut[facei] && isInternalFace(mesh, includedCell, facei)) - { - // Face was internal to the mesh and will be 'internal' to - // the surface. - - // Triangulate face - const face& f = faces[facei]; - - forAll(f, fp) - { - faceMap_[triI] = facei; - - triangles[triI++] = - labelledTri - ( - f[fp], - f.nextLabel(fp), - mesh.nPoints() + facei, // face centre - internalFacesPatch - ); - } - } - } - nInternalFaces_ = triI; - - - // Triangulate external faces - forAll(faceIsCut, facei) - { - if (faceIsCut[facei] && !isInternalFace(mesh, includedCell, facei)) - { - // Face will become outside of the surface. - - label patchi = -1; - bool reverse = false; - - if (mesh.isInternalFace(facei)) - { - patchi = internalFacesPatch; - - // Check orientation. Check which side of the face gets - // included (note: only one side is). - if (includedCell[mesh.faceOwner()[facei]]) - { - reverse = false; - } - else - { - reverse = true; - } - } - else - { - // Face was already outside so orientation ok. - - patchi = patches.whichPatch(facei); - - reverse = false; - } - - - // Triangulate face - const face& f = faces[facei]; - - if (reverse) - { - forAll(f, fp) - { - faceMap_[triI] = facei; - - triangles[triI++] = - labelledTri - ( - f.nextLabel(fp), - f[fp], - mesh.nPoints() + facei, // face centre - patchi - ); - } - } - else - { - forAll(f, fp) - { - faceMap_[triI] = facei; - - triangles[triI++] = - labelledTri - ( - f[fp], - f.nextLabel(fp), - mesh.nPoints() + facei, // face centre - patchi - ); - } - } - } - } - } - else - { - // Triangulation using existing vertices - // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - - // Triangulate internal faces - forAll(faceIsCut, facei) - { - if (faceIsCut[facei] && isInternalFace(mesh, includedCell, facei)) - { - // Face was internal to the mesh and will be 'internal' to - // the surface. - - // Triangulate face. Fall back to naive triangulation if failed. - faceTriangulation faceTris(points, faces[facei], true); - - if (faceTris.empty()) - { - WarningInFunction - << "Could not find triangulation for face " << facei - << " vertices " << faces[facei] << " coords " - << IndirectList(points, faces[facei])() << endl; - } - else - { - // Copy triangles. Make them internalFacesPatch - insertTriangles - ( - faceTris, - facei, - internalFacesPatch, - false, // no reverse - - triangles, - triI - ); - } - } - } - nInternalFaces_ = triI; - - - // Triangulate external faces - forAll(faceIsCut, facei) - { - if (faceIsCut[facei] && !isInternalFace(mesh, includedCell, facei)) - { - // Face will become outside of the surface. - - label patchi = -1; - bool reverse = false; - - if (mesh.isInternalFace(facei)) - { - patchi = internalFacesPatch; - - // Check orientation. Check which side of the face gets - // included (note: only one side is). - if (includedCell[mesh.faceOwner()[facei]]) - { - reverse = false; - } - else - { - reverse = true; - } - } - else - { - // Face was already outside so orientation ok. - - patchi = patches.whichPatch(facei); - - reverse = false; - } - - // Triangulate face - faceTriangulation faceTris(points, faces[facei], true); - - if (faceTris.empty()) - { - WarningInFunction - << "Could not find triangulation for face " << facei - << " vertices " << faces[facei] << " coords " - << IndirectList(points, faces[facei])() << endl; - } - else - { - // Copy triangles. Optionally reverse them - insertTriangles - ( - faceTris, - facei, - patchi, - reverse, // whether to reverse - - triangles, - triI - ); - } - } - } - } - - // Shrink if necessary (because of invalid triangulations) - triangles.setSize(triI); - faceMap_.setSize(triI); - - Pout<< "nInternalFaces_:" << nInternalFaces_ << endl; - Pout<< "triangles:" << triangles.size() << endl; - - - geometricSurfacePatchList surfPatches(patches.size()); - - forAll(patches, patchi) - { - surfPatches[patchi] = - geometricSurfacePatch - ( - patches[patchi].physicalType(), - patches[patchi].name(), - patchi - ); - } - - // Create globally numbered tri surface - if (faceCentreDecomposition) - { - // Use newPoints (mesh points + face centres) - triSurface globalSurf(triangles, surfPatches, newPoints); - - // Create locally numbered tri surface - triSurface::operator= - ( - triSurface - ( - globalSurf.localFaces(), - surfPatches, - globalSurf.localPoints() - ) - ); - } - else - { - // Use mesh points - triSurface globalSurf(triangles, surfPatches, mesh.points()); - - // Create locally numbered tri surface - triSurface::operator= - ( - triSurface - ( - globalSurf.localFaces(), - surfPatches, - globalSurf.localPoints() - ) - ); - } -} - - -// ************************************************************************* // diff --git a/src/triSurface/meshTriangulation/meshTriangulation.H b/src/triSurface/meshTriangulation/meshTriangulation.H deleted file mode 100644 index c1f87bc0eb..0000000000 --- a/src/triSurface/meshTriangulation/meshTriangulation.H +++ /dev/null @@ -1,152 +0,0 @@ -/*---------------------------------------------------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | - \\ / A nd | Copyright (C) 2011-2016 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 . - -Class - Foam::meshTriangulation - -Description - Triangulation of mesh faces. Generates (multiply connected) trisurface. - - All patch faces keep their patchID as triangle region. - Internal faces get the supplied region number. - -SourceFiles - meshTriangulation.C - -\*---------------------------------------------------------------------------*/ - - -#ifndef meshTriangulation_H -#define meshTriangulation_H - -#include "triSurface.H" -#include "typeInfo.H" - -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -namespace Foam -{ - -// Forward declaration of classes -class polyMesh; -class primitiveMesh; - -/*---------------------------------------------------------------------------*\ - Class meshTriangulation Declaration -\*---------------------------------------------------------------------------*/ - -class meshTriangulation -: - public triSurface -{ - // Private data - - //- Number of triangles in this that are internal to the surface. - label nInternalFaces_; - - //- From triangle to mesh face - labelList faceMap_; - - // Private Member Functions - - //- Is face internal to the subset. - static bool isInternalFace - ( - const primitiveMesh&, - const boolList& includedCell, - const label facei - ); - - //- Find boundary faces of subset. - static void getFaces - ( - const primitiveMesh&, - const boolList& includedCell, - boolList& faceIsCut, - label& nFaces, - label& nInternalFaces - ); - - //- Add triangulation of face to triangles. Optionally reverse. - void insertTriangles - ( - const triFaceList&, - const label facei, - const label regionI, - const bool reverse, - - List& triangles, - label& triI - ); - - -public: - - ClassName("meshTriangulation"); - - - // Constructors - - //- Construct null - meshTriangulation(); - - //- Construct from selected mesh cell and region number to be used - // for triangles resulting from internal faces. (all boundary triangles - // get polyMesh patch id). - // faceCentreDecomposition = true : decomposition around face centre - // false : decomposition using - // existing vertices - meshTriangulation - ( - const polyMesh&, - const label internalFacesPatch, - const boolList& includedCell, - const bool faceCentreDecomposition = false - ); - - - // Member Functions - - //- Number of triangles in *this which are internal to the surface - label nInternalFaces() const - { - return nInternalFaces_; - } - - //- From triangle to mesh face - const labelList& faceMap() const - { - return faceMap_; - } -}; - - -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -} // End namespace Foam - -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -#endif - -// ************************************************************************* //