zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of ssh://hunt/home/hunt2/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
andy
2008-09-16 11:27:07 +01:00
parent 571d39c321 b136c76292
commit e95b3a9312
49 changed files with 1510 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
applications/solvers/incompressible/channelOodles/createGradP.H
View File

@ -8,7 +8,7 @@
IFstream gradPFile
(
runTime.path()/runTime.timeName()/"gradP.raw"
runTime.path()/runTime.timeName()/"uniform"/"gradP.raw"
);
if(gradPFile.good())

4
applications/solvers/incompressible/channelOodles/writeGradP.H
View File

@ -2,7 +2,7 @@
{
OFstream gradPFile
(
runTime.path()/runTime.timeName()/"gradP.raw"
runTime.path()/runTime.timeName()/"uniform"/"gradP.raw"
);
if(gradPFile.good())
@ -13,7 +13,7 @@
{
FatalErrorIn(args.executable())
<< "Cannot open file "
<< runTime.path()/runTime.timeName()/"gradP.raw"
<< runTime.path()/runTime.timeName()/"uniform"/"gradP.raw"
<< exit(FatalError);
};
};

28
applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L
View File

@ -187,21 +187,21 @@ time ({digit}{digit}":"{digit}{digit}":"{digit}{digit})
versionNumber ({digit}|".")*
header {spaceNl}"(1"{some_space}
dimension {spaceNl}"(2"{some_space}
points {spaceNl}"(10"{some_space}
faces {spaceNl}"(13"{some_space}
cells {spaceNl}"(12"{some_space}
zoneVariant1 {spaceNl}"(39"{some_space}
zoneVariant2 {spaceNl}"(45"{some_space}
faceTree {spaceNl}"(59"{some_space}
header {spaceNl}"(1"{space}
dimension {spaceNl}"(2"{space}
points {spaceNl}"(10"{space}
faces {spaceNl}"(13"{space}
cells {spaceNl}"(12"{space}
zoneVariant1 {spaceNl}"(39"{space}
zoneVariant2 {spaceNl}"(45"{space}
faceTree {spaceNl}"(59"{space}
comment "0"{some_space}
unknownPeriodicFace "17"{some_space}
periodicFace "18"{some_space}
cellTree "58"{some_space}
faceParents "61"{some_space}
ignoreBlocks ("4"|"37"|"38"|"41"|"60"|"64"){some_space}
comment "0"{space}
unknownPeriodicFace "17"{space}
periodicFace "18"{space}
cellTree "58"{space}
faceParents "61"{space}
ignoreBlocks ("4"|"37"|"38"|"41"|"60"|"64"){space}
redundantBlock {spaceNl}({comment}|{unknownPeriodicFace}|{periodicFace}|{cellTree}|{faceParents}|{ignoreBlocks}){space}

6
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
View File

@ -405,9 +405,9 @@ void writePatchField
{
const Time& runTime = eMesh.mesh().time();
const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets;
const HashTable<labelList>& allPatchNames = eMesh.allPatchNames;
const HashTable<label>& patchIndices = eMesh.patchIndices;
const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets();
const HashTable<labelList>& allPatchNames = eMesh.allPatchNames();
const HashTable<label>& patchIndices = eMesh.patchIndices();
const HashTable<ensightMesh::nFacePrimitives>&
nPatchPrims = eMesh.nPatchPrims();

6
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H
View File

@ -88,9 +88,6 @@ class ensightMesh
List<faceSets> boundaryFaceSets_;
HashTable<labelList> allPatchNames_;
HashTable<label> patchIndices_;
@ -246,8 +243,7 @@ public:
ensightMesh(const fvMesh&, const argList& args, const bool binary);
// Destructor
//- Destructor
~ensightMesh();

4
applications/utilities/postProcessing/miscellaneous/postChannel/postChannelDict
View File

@ -18,8 +18,10 @@ FoamFile
Nx 40;
Ny
(
50
25
25
);
Nz 30;
// ************************************************************************* //

7
bin/mpirunDebug
View File

@ -76,9 +76,9 @@ echo "run $args" > $HOME/gdbCommands
echo "where" >> $HOME/gdbCommands
echo "Constructed gdb initialization file $HOME/gdbCommands"
$ECHO "Choose running method: 1)gdb+xterm 2)gdb 3)log 4)xterm+valgrind: \c"
$ECHO "Choose running method: 1)gdb+xterm 2)gdb 3)log 4)log+xterm 5)xterm+valgrind: \c"
read method
if [ "$method" -ne 1 -a "$method" -ne 2 -a "$method" -ne 3 -a "$method" -ne 4 ]; then
if [ "$method" -ne 1 -a "$method" -ne 2 -a "$method" -ne 3 -a "$method" -ne 4 -a "$method" -ne 5 ]; then
printUsage
exit 1
fi
@ -152,6 +152,9 @@ do
echo "$sourceFoam; cd $PWD; $exec $args >& $procLog" >> $procCmdFile
echo "${node}$procCmdFile" >> $HOME/mpirun.schema
elif [ "$method" -eq 4 ]; then
echo "$sourceFoam; cd $PWD; $exec $args 2>&1 | tee $procLog; read dummy" >> $procCmdFile
echo "${node}xterm -font fixed -title 'processor'$proc $geom -e $procCmdFile" >> $HOME/mpirun.schema
elif [ "$method" -eq 5 ]; then
echo "$sourceFoam; cd $PWD; valgrind $exec $args; read dummy" >> $procCmdFile
echo "${node}xterm -font fixed -title 'processor'$proc $geom -e $procCmdFile" >> $HOME/mpirun.schema
fi

2
etc/controlDict
View File

@ -808,7 +808,7 @@ OptimisationSwitches
{
fileModificationSkew 10;
commsType nonBlocking; //scheduled; //blocking;
floatTransfer 1;
floatTransfer 0;
nProcsSimpleSum 0;
}

90
src/OpenFOAM/containers/HashTables/HashSet/HashSet.C Normal file
View File

@ -0,0 +1,90 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#ifndef HashSet_C
#define HashSet_C
#include "HashSet.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class Key, class Hash>
bool HashSet<Key, Hash>::operator==(const HashSet<Key, Hash>& ht) const
{
const HashTable<empty, Key, Hash>& a = *this;
// Are all my elements in ht?
for
(
typename HashTable<empty, Key, Hash>::const_iterator iter = a.begin();
iter != a.end();
++iter
)
{
if (!ht.found(iter.key()))
{
return false;
}
}
// Are all ht elements in me?
for
(
typename HashTable<empty, Key, Hash>::const_iterator iter = ht.begin();
iter != ht.end();
++iter
)
{
if (!found(iter.key()))
{
return false;
}
}
return true;
}
template<class Key, class Hash>
bool HashSet<Key, Hash>::operator!=(const HashSet<Key, Hash>& ht) const
{
return !(operator==(ht));
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

17
src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
View File

@ -100,6 +100,17 @@ public:
{
return HashTable<empty, Key, Hash>::insert(key, empty());
}
// Member Operators
//- Equality. Two hashtables are equal if all contents of first are
// also in second and vice versa. So does not depend on table size or
// order!
bool operator==(const HashSet<Key, Hash>&) const;
//- The opposite of the equality operation.
bool operator!=(const HashSet<Key, Hash>&) const;
};
@ -112,6 +123,12 @@ typedef HashSet<> wordHashSet;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "HashSet.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

21
src/OpenFOAM/containers/Lists/List/List.C
View File

@ -321,7 +321,7 @@ List<T>::List(const BiIndirectList<T>& idl)
template<class T>
List<T>::~List()
{
if (this->size_) delete[] this->v_;
if (this->v_) delete[] this->v_;
}
@ -367,9 +367,8 @@ void List<T>::setSize(const label newSize)
register T* av = &nv[i];
while (i--) *--av = *--vv;
}
delete[] this->v_;
}
if (this->v_) delete[] this->v_;
this->size_ = newSize;
this->v_ = nv;
@ -400,7 +399,7 @@ void List<T>::setSize(const label newSize, const T& a)
template<class T>
void List<T>::clear()
{
if (this->size_) delete[] this->v_;
if (this->v_) delete[] this->v_;
this->size_ = 0;
this->v_ = 0;
}
@ -411,7 +410,7 @@ void List<T>::clear()
template<class T>
void List<T>::transfer(List<T>& a)
{
if (this->size_) delete[] this->v_;
if (this->v_) delete[] this->v_;
this->size_ = a.size_;
this->v_ = a.v_;
@ -457,7 +456,8 @@ void List<T>::operator=(const UList<T>& a)
{
if (a.size_ != this->size_)
{
if (this->size_) delete[] this->v_;
if (this->v_) delete[] this->v_;
this->v_ = 0;
this->size_ = a.size_;
if (this->size_) this->v_ = new T[this->size_];
}
@ -503,7 +503,8 @@ void List<T>::operator=(const SLList<T>& sll)
{
if (sll.size() != this->size_)
{
if (this->size_) delete[] this->v_;
if (this->v_) delete[] this->v_;
this->v_ = 0;
this->size_ = sll.size();
if (this->size_) this->v_ = new T[this->size_];
}
@ -530,7 +531,8 @@ void List<T>::operator=(const IndirectList<T>& idl)
{
if (idl.size() != this->size_)
{
if (this->size_) delete[] this->v_;
if (this->v_) delete[] this->v_;
this->v_ = 0;
this->size_ = idl.size();
if (this->size_) this->v_ = new T[this->size_];
}
@ -551,7 +553,8 @@ void List<T>::operator=(const BiIndirectList<T>& idl)
{
if (idl.size() != this->size_)
{
if (this->size_) delete[] this->v_;
if (this->v_) delete[] this->v_;
this->v_ = 0;
this->size_ = idl.size();
if (this->size_) this->v_ = new T[this->size_];
}

7
src/OpenFOAM/containers/Lists/List/List.H
View File

@ -137,6 +137,9 @@ public:
//- Return a null List
static const List<T>& null();
//- Return the number of elements in the UList.
inline label size() const;
// Edit
@ -156,6 +159,10 @@ public:
//- Return subscript-checked element of UList.
inline T& newElmt(const label);
//- Override size to be inconsistent with allocated storage.
// Use with care.
inline label& size();
// Member operators

14
src/OpenFOAM/containers/Lists/List/ListI.H
View File

@ -52,6 +52,20 @@ inline T& Foam::List<T>::newElmt(const label i)
}
template<class T>
inline Foam::label Foam::List<T>::size() const
{
return UList<T>::size_;
}
template<class T>
inline Foam::label& Foam::List<T>::size()
{
return UList<T>::size_;
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T>

3
src/OpenFOAM/meshes/polyMesh/polyPatches/polyPatch/polyPatch.C
View File

@ -282,8 +282,7 @@ const Foam::labelList& Foam::polyPatch::meshEdges() const
primitivePatch::meshEdges
(
boundaryMesh().mesh().edges(),
boundaryMesh().mesh().cellEdges(),
faceCells()
boundaryMesh().mesh().pointEdges()
)
);
}

52
src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.C
View File

@ -169,7 +169,7 @@ Foam::PackedList<1> Foam::syncTools::getMasterPoints(const polyMesh& mesh)
else
{
FatalErrorIn("syncTools::getMasterPoints(const polyMesh&)")
<< "Cannot handle patch " << patches[patchI].name()
<< "Cannot handle coupled patch " << patches[patchI].name()
<< " of type " << patches[patchI].type()
<< abort(FatalError);
}
@ -290,7 +290,7 @@ Foam::PackedList<1> Foam::syncTools::getMasterEdges(const polyMesh& mesh)
else
{
FatalErrorIn("syncTools::getMasterEdges(const polyMesh&)")
<< "Cannot handle patch " << patches[patchI].name()
<< "Cannot handle coupled patch " << patches[patchI].name()
<< " of type " << patches[patchI].type()
<< abort(FatalError);
}
@ -314,6 +314,54 @@ Foam::PackedList<1> Foam::syncTools::getMasterEdges(const polyMesh& mesh)
}
// Determines for every face whether it is coupled and if so sets only one.
Foam::PackedList<1> Foam::syncTools::getMasterFaces(const polyMesh& mesh)
{
PackedList<1> isMasterFace(mesh.nFaces(), 1);
const polyBoundaryMesh& patches = mesh.boundaryMesh();
forAll(patches, patchI)
{
if (patches[patchI].coupled())
{
if (Pstream::parRun() && isA<processorPolyPatch>(patches[patchI]))
{
const processorPolyPatch& pp =
refCast<const processorPolyPatch>(patches[patchI]);
if (!pp.owner())
{
forAll(pp, i)
{
isMasterFace.set(pp.start()+i, 0);
}
}
}
else if (isA<cyclicPolyPatch>(patches[patchI]))
{
const cyclicPolyPatch& pp =
refCast<const cyclicPolyPatch>(patches[patchI]);
for (label i = pp.size()/2; i < pp.size(); i++)
{
isMasterFace.set(pp.start()+i, 0);
}
}
else
{
FatalErrorIn("syncTools::getMasterFaces(const polyMesh&)")
<< "Cannot handle coupled patch " << patches[patchI].name()
<< " of type " << patches[patchI].type()
<< abort(FatalError);
}
}
}
return isMasterFace;
}
template <>
void Foam::syncTools::separateList
(

5
src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.H
View File

@ -226,9 +226,12 @@ public:
//- Get per point whether is it master (of a coupled set of points)
static PackedList<1> getMasterPoints(const polyMesh&);
//- Get per edge whether is it master (of a coupled set of edge)
//- Get per edge whether is it master (of a coupled set of edges)
static PackedList<1> getMasterEdges(const polyMesh&);
//- Get per face whether is it master (of a coupled set of faces)
static PackedList<1> getMasterFaces(const polyMesh&);
};

34
src/OpenFOAM/meshes/polyMesh/zones/faceZone/faceZone.C
View File

@ -362,16 +362,27 @@ const Foam::labelList& Foam::faceZone::meshEdges() const
{
if (!mePtr_)
{
labelList faceCells(size());
const labelList& own = zoneMesh().mesh().faceOwner();
const labelList& faceLabels = *this;
forAll (faceCells, faceI)
{
faceCells[faceI] = own[faceLabels[faceI]];
}
//labelList faceCells(size());
//
//const labelList& own = zoneMesh().mesh().faceOwner();
//
//const labelList& faceLabels = *this;
//
//forAll (faceCells, faceI)
//{
// faceCells[faceI] = own[faceLabels[faceI]];
//}
//
//mePtr_ =
// new labelList
// (
// operator()().meshEdges
// (
// zoneMesh().mesh().edges(),
// zoneMesh().mesh().cellEdges(),
// faceCells
// )
// );
mePtr_ =
new labelList
@ -379,8 +390,7 @@ const Foam::labelList& Foam::faceZone::meshEdges() const
operator()().meshEdges
(
zoneMesh().mesh().edges(),
zoneMesh().mesh().cellEdges(),
faceCells
zoneMesh().mesh().pointEdges()
)
);
}

11
src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatch.H
View File

@ -348,7 +348,8 @@ public:
// index in the edge list. If the edge is not found, return -1
label whichEdge(const edge& e) const;
//- Return labels of patch edges in the global edge list
//- Return labels of patch edges in the global edge list using
// cell addressing
labelList meshEdges
(
const edgeList& allEdges,
@ -356,6 +357,14 @@ public:
const labelList& faceCells
) const;
//- Return labels of patch edges in the global edge list using
// basic edge addressing.
labelList meshEdges
(
const edgeList& allEdges,
const labelListList& pointEdges
) const;
//- Return face normals for patch
const Field<PointType>& faceNormals() const;

54
src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchMeshEdges.C
View File

@ -111,6 +111,60 @@ labelList PrimitivePatch<Face, FaceList, PointField, PointType>::meshEdges
}
template
<
class Face,
template<class> class FaceList,
class PointField,
class PointType
>
labelList PrimitivePatch<Face, FaceList, PointField, PointType>::meshEdges
(
const edgeList& allEdges,
const labelListList& pointEdges
) const
{
if (debug)
{
Info<< "labelList PrimitivePatch<Face, FaceList, PointField, PointType>"
<< "::meshEdges() : "
<< "calculating labels of patch edges in mesh edge list"
<< endl;
}
// get reference to the list of edges on the patch
const edgeList& PatchEdges = edges();
// create the storage
labelList meshEdges(PatchEdges.size());
// get reference to the points on the patch
const labelList& pp = meshPoints();
// WARNING: Remember that local edges address into local point list;
// local-to-global point label translation is necessary
forAll (PatchEdges, edgeI)
{
const label globalPointI = pp[PatchEdges[edgeI].start()];
const edge curEdge(globalPointI, pp[PatchEdges[edgeI].end()]);
const labelList& pe = pointEdges[globalPointI];
forAll (pe, i)
{
if (allEdges[pe[i]] == curEdge)
{
meshEdges[edgeI] = pe[i];
break;
}
}
}
return meshEdges;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template

6
src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C
View File

@ -66,6 +66,9 @@ primitiveMesh::primitiveMesh()
ppPtr_(NULL),
cpPtr_(NULL),
allocSize_(0),
labels_(0),
cellCentresPtr_(NULL),
faceCentresPtr_(NULL),
cellVolumesPtr_(NULL),
@ -106,6 +109,9 @@ primitiveMesh::primitiveMesh
ppPtr_(NULL),
cpPtr_(NULL),
allocSize_(0),
labels_(0),
cellCentresPtr_(NULL),
faceCentresPtr_(NULL),
cellVolumesPtr_(NULL),

70
src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.H
View File

@ -155,6 +155,17 @@ class primitiveMesh
mutable labelListList* cpPtr_;
// On-the-fly edge addresing storage
//- Temporary storage for addressing. allocSize is the real size
// of the labelList.
mutable label allocSize_;
mutable labelList labels_;
//- Temporary storage for addressing
mutable labelHashSet labelSet_;
// Geometric data
//- Cell centres
@ -209,8 +220,14 @@ class primitiveMesh
(
List<DynamicList<label> >&,
DynamicList<edge>&,
const label pA,
const label pB
const label,
const label
);
//- For on-the-fly addressing calculation
static label findFirstCommonElementFromSortedLists
(
const labelList&,
const labelList&
);
@ -667,6 +684,55 @@ public:
//- Print a list of all the currently allocated mesh data
void printAllocated() const;
// Per storage whether allocated
inline bool hasCellShapes() const;
inline bool hasEdges() const;
inline bool hasCellCells() const;
inline bool hasEdgeCells() const;
inline bool hasPointCells() const;
inline bool hasCells() const;
inline bool hasEdgeFaces() const;
inline bool hasPointFaces() const;
inline bool hasCellEdges() const;
inline bool hasFaceEdges() const;
inline bool hasPointEdges() const;
inline bool hasPointPoints() const;
inline bool hasCellPoints() const;
inline bool hasCellCentres() const;
inline bool hasFaceCentres() const;
inline bool hasCellVolumes() const;
inline bool hasFaceAreas() const;
// On-the-fly addressing calculation. These functions return either
// a reference to the full addressing (if already calculated) or
// a reference to member data labels_ so be careful when not storing
// result.
//- cellCells using cells
const labelList& cellCells(const label cellI) const;
//- cellPoints using cells
const labelList& cellPoints(const label cellI) const;
//- pointCells using pointFaces
const labelList& pointCells(const label pointI) const;
//- pointPoints using edges, pointEdges
const labelList& pointPoints(const label pointI) const;
//- faceEdges using pointFaces, edges, pointEdges
const labelList& faceEdges(const label faceI) const;
//- edgeFaces using pointFaces, edges, pointEdges
const labelList& edgeFaces(const label edgeI) const;
//- edgeCells using pointFaces, edges, pointEdges
const labelList& edgeCells(const label edgeI) const;
//- cellEdges using cells, pointFaces, edges, pointEdges
const labelList& cellEdges(const label cellI) const;
//- Clear geometry
void clearGeom();

47
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCellCells.C
View File

@ -105,6 +105,53 @@ const labelListList& primitiveMesh::cellCells() const
}
const labelList& primitiveMesh::cellCells(const label cellI) const
{
if (hasCellCells())
{
return cellCells()[cellI];
}
else
{
const labelList& own = faceOwner();
const labelList& nei = faceNeighbour();
const cell& cFaces = cells()[cellI];
labels_.size() = allocSize_;
if (cFaces.size() > allocSize_)
{
labels_.clear();
allocSize_ = cFaces.size();
labels_.setSize(allocSize_);
}
label n = 0;
forAll(cFaces, i)
{
label faceI = cFaces[i];
if (faceI < nInternalFaces())
{
if (own[faceI] == cellI)
{
labels_[n++] = nei[faceI];
}
else
{
labels_[n++] = own[faceI];
}
}
}
labels_.size() = n;
return labels_;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

46
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCellPoints.C
View File

@ -53,6 +53,52 @@ const labelListList& primitiveMesh::cellPoints() const
}
const labelList& primitiveMesh::cellPoints(const label cellI) const
{
if (hasCellPoints())
{
return cellPoints()[cellI];
}
else
{
const faceList& fcs = faces();
const labelList& cFaces = cells()[cellI];
labelSet_.clear();
forAll(cFaces, i)
{
const labelList& f = fcs[cFaces[i]];
forAll(f, fp)
{
labelSet_.insert(f[fp]);
}
}
labels_.size() = allocSize_;
if (labelSet_.size() > allocSize_)
{
labels_.clear();
allocSize_ = labelSet_.size();
labels_.setSize(allocSize_);
}
label n = 0;
forAllConstIter(labelHashSet, labelSet_, iter)
{
labels_[n++] = iter.key();
}
labels_.size() = n;
return labels_;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

7
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshCheck.C
View File

@ -771,11 +771,12 @@ bool primitiveMesh::checkPoints
}
}
const labelListList& pc = pointCells();
forAll (pc, pointI)
forAll (pf, pointI)
{
if (pc[pointI].size() == 0)
const labelList& pc = pointCells(pointI);
if (pc.size() == 0)
{
if (setPtr)
{

80
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshEdgeCells.C
View File

@ -51,6 +51,86 @@ const labelListList& primitiveMesh::edgeCells() const
}
const labelList& primitiveMesh::edgeCells(const label edgeI) const
{
if (hasEdgeCells())
{
return edgeCells()[edgeI];
}
else
{
const labelList& own = faceOwner();
const labelList& nei = faceNeighbour();
// edge faces can either return labels_ or reference in edgeLabels.
labelList labelsCopy;
if (!hasEdgeFaces())
{
labelsCopy = edgeFaces(edgeI);
}
const labelList& eFaces =
(
hasEdgeFaces()
? edgeFaces()[edgeI]
: labelsCopy
);
labels_.size() = allocSize_;
// labels_ should certainly be big enough for edge cells.
label n = 0;
// Do quadratic insertion.
forAll(eFaces, i)
{
label faceI = eFaces[i];
{
label ownCellI = own[faceI];
// Check if not already in labels_
for (label j = 0; j < n; j++)
{
if (labels_[j] == ownCellI)
{
ownCellI = -1;
break;
}
}
if (ownCellI != -1)
{
labels_[n++] = ownCellI;
}
}
if (isInternalFace(faceI))
{
label neiCellI = nei[faceI];
for (label j = 0; j < n; j++)
{
if (labels_[j] == neiCellI)
{
neiCellI = -1;
break;
}
}
if (neiCellI != -1)
{
labels_[n++] = neiCellI;
}
}
}
labels_.size() = n;
return labels_;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

53
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshEdgeFaces.C
View File

@ -51,6 +51,59 @@ const labelListList& primitiveMesh::edgeFaces() const
return *efPtr_;
}
const labelList& primitiveMesh::edgeFaces(const label edgeI) const
{
if (hasEdgeFaces())
{
return edgeFaces()[edgeI];
}
else
{
// Use the fact that pointEdges are sorted in incrementing edge order
const edge& e = edges()[edgeI];
const labelList& pFaces0 = pointFaces()[e[0]];
const labelList& pFaces1 = pointFaces()[e[1]];
label i0 = 0;
label i1 = 0;
label n = 0;
labels_.size() = allocSize_;
while (i0 < pFaces0.size() && i1 < pFaces1.size())
{
if (pFaces0[i0] < pFaces1[i1])
{
++i0;
}
else if (pFaces0[i0] > pFaces1[i1])
{
++i1;
}
else
{
// Equal. Append.
if (n == allocSize_)
{
// Have setSize copy contents so far
labels_.size() = n;
allocSize_ = allocSize_*2 + 1;
labels_.setSize(allocSize_);
}
labels_[n++] = pFaces0[i0];
++i0;
++i1;
}
}
labels_.size() = n;
return labels_;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

125
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshEdges.C
View File

@ -461,6 +461,46 @@ void primitiveMesh::calcEdges(const bool doFaceEdges) const
}
label primitiveMesh::findFirstCommonElementFromSortedLists
(
const labelList& list1,
const labelList& list2
)
{
label result = -1;
labelList::const_iterator iter1 = list1.begin();
labelList::const_iterator iter2 = list2.begin();
while (iter1 != list1.end() && iter2 != list2.end())
{
if( *iter1 < *iter2)
{
++iter1;
}
else if (*iter1 > *iter2)
{
++iter2;
}
else
{
result = *iter1;
break;
}
}
if (result == -1)
{
FatalErrorIn
(
"primitiveMesh::findFirstCommonElementFromSortedLists"
"(const labelList&, const labelList&)"
) << "No common elements in lists " << list1 << " and " << list2
<< abort(FatalError);
}
return result;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const edgeList& primitiveMesh::edges() const
@ -542,6 +582,91 @@ void primitiveMesh::clearOutEdges()
deleteDemandDrivenData(edgesPtr_);
deleteDemandDrivenData(pePtr_);
deleteDemandDrivenData(fePtr_);
labels_.clear();
allocSize_ = 0;
}
const labelList& primitiveMesh::faceEdges(const label faceI) const
{
if (hasFaceEdges())
{
return faceEdges()[faceI];
}
else
{
const labelListList& pointEs = pointEdges();
const face& f = faces()[faceI];
labels_.size() = allocSize_;
if (f.size() > allocSize_)
{
labels_.clear();
allocSize_ = f.size();
labels_.setSize(allocSize_);
}
label n = 0;
forAll(f, fp)
{
labels_[n++] = findFirstCommonElementFromSortedLists
(
pointEs[f[fp]],
pointEs[f.nextLabel(fp)]
);
}
labels_.size() = n;
return labels_;
}
}
const labelList& primitiveMesh::cellEdges(const label cellI) const
{
if (hasCellEdges())
{
return cellEdges()[cellI];
}
else
{
const labelList& cFaces = cells()[cellI];
labelSet_.clear();
forAll(cFaces, i)
{
const labelList& fe = faceEdges(cFaces[i]);
forAll(fe, feI)
{
labelSet_.insert(fe[feI]);
}
}
labels_.size() = allocSize_;
if (labelSet_.size() > allocSize_)
{
labels_.clear();
allocSize_ = labelSet_.size();
labels_.setSize(allocSize_);
}
label n =0;
forAllConstIter(labelHashSet, labelSet_, iter)
{
labels_[n++] = iter.key();
}
labels_.size() = n;
return labels_;
}
}

102
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshI.H
View File

@ -104,6 +104,108 @@ inline bool primitiveMesh::isInternalFace(const label faceIndex) const
}
inline bool primitiveMesh::hasCellShapes() const
{
return cellShapesPtr_;
}
inline bool primitiveMesh::hasEdges() const
{
return edgesPtr_;
}
inline bool primitiveMesh::hasCellCells() const
{
return ccPtr_;
}
inline bool primitiveMesh::hasEdgeCells() const
{
return ecPtr_;
}
inline bool primitiveMesh::hasPointCells() const
{
return pcPtr_;
}
inline bool primitiveMesh::hasCells() const
{
return cfPtr_;
}
inline bool primitiveMesh::hasEdgeFaces() const
{
return efPtr_;
}
inline bool primitiveMesh::hasPointFaces() const
{
return pfPtr_;
}
inline bool primitiveMesh::hasCellEdges() const
{
return cePtr_;
}
inline bool primitiveMesh::hasFaceEdges() const
{
return fePtr_;
}
inline bool primitiveMesh::hasPointEdges() const
{
return pePtr_;
}
inline bool primitiveMesh::hasPointPoints() const
{
return ppPtr_;
}
inline bool primitiveMesh::hasCellPoints() const
{
return cpPtr_;
}
inline bool primitiveMesh::hasCellCentres() const
{
return cellCentresPtr_;
}
inline bool primitiveMesh::hasFaceCentres() const
{
return faceCentresPtr_;
}
inline bool primitiveMesh::hasCellVolumes() const
{
return cellVolumesPtr_;
}
inline bool primitiveMesh::hasFaceAreas() const
{
return faceAreasPtr_;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

64
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshPointCells.C
View File

@ -114,6 +114,70 @@ const labelListList& primitiveMesh::pointCells() const
}
const labelList& primitiveMesh::pointCells(const label pointI) const
{
if (hasPointCells())
{
return pointCells()[pointI];
}
else
{
const labelList& own = faceOwner();
const labelList& nei = faceNeighbour();
const labelList& pFaces = pointFaces()[pointI];
labels_.size() = allocSize_;
label n = 0;
forAll(pFaces, i)
{
const label faceI = pFaces[i];
// Append owner
if (n == allocSize_)
{
labels_.size() = n;
allocSize_ = allocSize_*2 + 1;
labels_.setSize(allocSize_);
}
labels_[n++] = own[faceI];
// Append neighbour
if (faceI < nInternalFaces())
{
if (n == allocSize_)
{
labels_.size() = n;
allocSize_ = allocSize_*2 + 1;
labels_.setSize(allocSize_);
}
labels_[n++] = nei[faceI];
}
}
labels_.size() = n;
// Filter duplicates
sort(labels_);
n = 1;
for (label i = 1; i < labels_.size(); i++)
{
if (labels_[i] != labels_[i-1])
{
labels_[n++] = labels_[i];
}
}
labels_.size() = n;
return labels_;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

34
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshPointPoints.C
View File

@ -97,6 +97,40 @@ const labelListList& primitiveMesh::pointPoints() const
}
const labelList& primitiveMesh::pointPoints(const label pointI) const
{
if (hasPointPoints())
{
return pointPoints()[pointI];
}
else
{
const edgeList& edges = this->edges();
const labelList& pEdges = pointEdges()[pointI];
labels_.size() = allocSize_;
if (pEdges.size() > allocSize_)
{
// Set size() so memory allocation behaves as normal.
labels_.clear();
allocSize_ = pEdges.size();
labels_.setSize(allocSize_);
}
label n = 0;
forAll(pEdges, i)
{
labels_[n++] = edges[pEdges[i]].otherVertex(pointI);
}
labels_.size() = n;
return labels_;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

18
src/OpenFOAM/primitives/contiguous/contiguous.H
View File

@ -58,15 +58,33 @@ inline bool contiguous<bool>() {return true;}
template<>
inline bool contiguous<char>() {return true;}
template<>
inline bool contiguous<unsigned char>() {return true;}
template<>
inline bool contiguous<short>() {return true;}
template<>
inline bool contiguous<unsigned short>() {return true;}
template<>
inline bool contiguous<int>() {return true;}
template<>
inline bool contiguous<unsigned int>() {return true;}
template<>
inline bool contiguous<long>() {return true;}
template<>
inline bool contiguous<unsigned long>() {return true;}
template<>
inline bool contiguous<long long>() {return true;}
template<>
inline bool contiguous<unsigned long long>() {return true;}
template<>
inline bool contiguous<float>() {return true;}

3
src/conversion/polyDualMesh/polyDualMesh.C
View File

@ -746,8 +746,7 @@ void Foam::polyDualMesh::calcDual
allBoundary.meshEdges
(
mesh.edges(),
mesh.cellEdges(),
SubList<label>(mesh.faceOwner(), allBoundary.size(), nIntFaces)
mesh.pointEdges()
)
);

4
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C
View File

@ -1295,7 +1295,7 @@ void Foam::polyTopoChange::calcFaceInflationMaps
selectFaces
(
mesh,
mesh.edgeFaces()[iter()],
mesh.edgeFaces(iter()),
true
)
);
@ -1309,7 +1309,7 @@ void Foam::polyTopoChange::calcFaceInflationMaps
selectFaces
(
mesh,
mesh.edgeFaces()[iter()],
mesh.edgeFaces(iter()),
false
)
);

2
src/finiteVolume/Make/files
View File

@ -187,6 +187,8 @@ $(limitedSchemes)/MC/MC.C
$(limitedSchemes)/Phi/Phi.C
$(limitedSchemes)/filteredLinear/filteredLinear.C
$(limitedSchemes)/filteredLinear2/filteredLinear2.C
$(limitedSchemes)/filteredLinear3/filteredLinear3.C
$(limitedSchemes)/limitWith/limitWith.C
multivariateSchemes = $(surfaceInterpolation)/multivariateSchemes
$(multivariateSchemes)/multivariateSurfaceInterpolationScheme/multivariateSurfaceInterpolationSchemes.C

48
src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3.C Normal file
View File

@ -0,0 +1,48 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "LimitedScheme.H"
#include "filteredLinear3.H"
#include "filteredLinear3V.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makeLimitedSurfaceInterpolationScheme
(
filteredLinear3,
filteredLinear3Limiter
)
makeLimitedVSurfaceInterpolationScheme
(
filteredLinear3V,
filteredLinear3VLimiter
)
}
// ************************************************************************* //

120
src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3.H Normal file
View File

@ -0,0 +1,120 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::filteredLinear3Limiter
Description
Class to generate weighting factors for the filtered-linear-3
differencing scheme.
The aim is to remove high-frequency modes with "staggering"
characteristics by comparing the face gradient with both neighbouring
cell gradients and introduce small amounts of upwind in order to damp
these modes.
Used in conjunction with the template class LimitedScheme.
SourceFiles
filteredLinear3.C
\*---------------------------------------------------------------------------*/
#ifndef filteredLinear3_H
#define filteredLinear3_H
#include "vector.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class filteredLinear3Limiter Declaration
\*---------------------------------------------------------------------------*/
template<class LimiterFunc>
class filteredLinear3Limiter
:
public LimiterFunc
{
// Private data
// Scaling corefficient for the gradient ratio,
// 0 = linear
// 1 = fully limited
scalar k_;
public:
filteredLinear3Limiter(Istream& is)
:
k_(readScalar(is))
{
if (k_ < 0 || k_ > 1)
{
FatalIOErrorIn("filteredLinear3Limiter(Istream& is)", is)
<< "coefficient = " << k_
<< " should be >= 0 and <= 1"
<< exit(FatalIOError);
}
}
scalar limiter
(
const scalar cdWeight,
const scalar faceFlux,
const typename LimiterFunc::phiType& phiP,
const typename LimiterFunc::phiType& phiN,
const typename LimiterFunc::gradPhiType& gradcP,
const typename LimiterFunc::gradPhiType& gradcN,
const vector& d
) const
{
// Difference across face
scalar df = phiN - phiP;
// Twice the differences across face-neighbour cells
scalar dP = 2*(d & gradcP);
scalar dN = 2*(d & gradcN);
// Calculate the limiter
scalar limiter = 1 - k_*(dN - df)*(dP - df)/max(sqr(dN + dP), SMALL);
// Limit the limiter between linear and upwind
return max(min(limiter, 1), 0);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

123
src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3V.H Normal file
View File

@ -0,0 +1,123 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::filteredLinear3VLimiter
Description
Class to generate weighting factors for the filteredLinear3V differencing
scheme. The aim is to remove high-frequency modes with "staggering"
characteristics from vector fields by comparing the face gradient in the
direction of maximum gradient with both neighbouring cell gradients and
introduce small amounts of upwind in order to damp these modes.
Used in conjunction with the template class LimitedScheme.
SourceFiles
filteredLinear3V.C
\*---------------------------------------------------------------------------*/
#ifndef filteredLinear3V_H
#define filteredLinear3V_H
#include "vector.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class filteredLinear3VLimiter Declaration
\*---------------------------------------------------------------------------*/
template<class LimiterFunc>
class filteredLinear3VLimiter
:
public LimiterFunc
{
// Private data
// Scaling corefficient for the gradient ratio,
// 0 = linear
// 1 = fully limited
scalar k_;
public:
filteredLinear3VLimiter(Istream& is)
:
k_(readScalar(is))
{
if (k_ < 0 || k_ > 1)
{
FatalIOErrorIn("filteredLinear3VLimiter(Istream& is)", is)
<< "coefficient = " << k_
<< " should be >= 0 and <= 1"
<< exit(FatalIOError);
}
}
scalar limiter
(
const scalar cdWeight,
const scalar faceFlux,
const typename LimiterFunc::phiType& phiP,
const typename LimiterFunc::phiType& phiN,
const typename LimiterFunc::gradPhiType& gradcP,
const typename LimiterFunc::gradPhiType& gradcN,
const vector& d
) const
{
// Difference across face
vector dfV = phiN - phiP;
// Scalar difference across the face
// in the direction in which the difference is largest
scalar df = dfV & dfV;
// Twice differences across face-neighbour cells
// in the direction in which the face-difference is largest
scalar dP = 2*(dfV & (d & gradcP));
scalar dN = 2*(dfV & (d & gradcN));
// Calculate the limiter
scalar limiter = 1 - k_*(dN - df)*(dP - df)/max(sqr(dN + dP), SMALL);
// Limit the limiter between linear and upwind
return max(min(limiter, 1), 0);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

37
src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitWith/limitWith.C Normal file
View File

@ -0,0 +1,37 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "fvMesh.H"
#include "limitWith.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makeSurfaceInterpolationScheme(limitWith)
}
// ************************************************************************* //

161
src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitWith/limitWith.H Normal file
View File

@ -0,0 +1,161 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::limitWith
Description
limitWith differencing scheme limits the specified scheme with the
specified limiter.
SourceFiles
limitWith.C
\*---------------------------------------------------------------------------*/
#ifndef limitWith_H
#define limitWith_H
#include "surfaceInterpolationScheme.H"
#include "limitedSurfaceInterpolationScheme.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class limitWith Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class limitWith
:
public surfaceInterpolationScheme<Type>
{
// Private Member Functions
//- Interpolation scheme
tmp<surfaceInterpolationScheme<Type> > tInterp_;
//- Limiter
tmp<limitedSurfaceInterpolationScheme<Type> > tLimiter_;
//- Disallow default bitwise copy construct
limitWith(const limitWith&);
//- Disallow default bitwise assignment
void operator=(const limitWith&);
public:
//- Runtime type information
TypeName("limitWith");
// Constructors
//- Construct from mesh and Istream.
// The name of the flux field is read from the Istream and looked-up
// from the mesh objectRegistry
limitWith
(
const fvMesh& mesh,
Istream& is
)
:
surfaceInterpolationScheme<Type>(mesh),
tInterp_
(
surfaceInterpolationScheme<Type>::New(mesh, is)
),
tLimiter_
(
limitedSurfaceInterpolationScheme<Type>::New(mesh, is)
)
{}
//- Construct from mesh, faceFlux and Istream
limitWith
(
const fvMesh& mesh,
const surfaceScalarField& faceFlux,
Istream& is
)
:
surfaceInterpolationScheme<Type>(mesh),
tInterp_
(
surfaceInterpolationScheme<Type>::New(mesh, faceFlux, is)
),
tLimiter_
(
limitedSurfaceInterpolationScheme<Type>::New(mesh, faceFlux, is)
)
{}
// Member Functions
//- Return the interpolation weighting factors
virtual tmp<surfaceScalarField> weights
(
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
return tLimiter_().weights
(
vf,
tInterp_().weights(vf),
tLimiter_().limiter(vf)
);
}
//- Return true if this scheme uses an explicit correction
virtual bool corrected() const
{
return tInterp_().corrected();
}
//- Return the explicit correction to the face-interpolate
// for the given field
virtual tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
correction(const GeometricField<Type, fvPatchField, volMesh>& vf) const
{
return tLimiter_().limiter(vf)*tInterp_().correction(vf);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

30
src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedSurfaceInterpolationScheme/limitedSurfaceInterpolationScheme.C
View File

@ -22,9 +22,6 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Abstract base class for surface interpolation schemes.
\*---------------------------------------------------------------------------*/
#include "limitedSurfaceInterpolationScheme.H"
@ -39,7 +36,6 @@ namespace Foam
// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
// Return weighting factors for scheme given by name in dictionary
template<class Type>
tmp<limitedSurfaceInterpolationScheme<Type> >
limitedSurfaceInterpolationScheme<Type>::New
@ -160,17 +156,14 @@ limitedSurfaceInterpolationScheme<Type>::~limitedSurfaceInterpolationScheme()
template<class Type>
tmp<surfaceScalarField> limitedSurfaceInterpolationScheme<Type>::weights
(
const GeometricField<Type, fvPatchField, volMesh>& phi
const GeometricField<Type, fvPatchField, volMesh>& phi,
const surfaceScalarField& CDweights,
tmp<surfaceScalarField> tLimiter
) const
{
const fvMesh& mesh = this->mesh();
// Note that here the weights field is initialised as the limiter
// from which the weight is calculated using the limiter value
tmp<surfaceScalarField> tWeights(this->limiter(phi));
surfaceScalarField& Weights = tWeights();
const surfaceScalarField& CDweights = mesh.surfaceInterpolation::weights();
surfaceScalarField& Weights = tLimiter();
scalarField& pWeights = Weights.internalField();
@ -199,9 +192,22 @@ tmp<surfaceScalarField> limitedSurfaceInterpolationScheme<Type>::weights
}
}
return tWeights;
return tLimiter;
}
template<class Type>
tmp<surfaceScalarField> limitedSurfaceInterpolationScheme<Type>::weights
(
const GeometricField<Type, fvPatchField, volMesh>& phi
) const
{
return this->weights
(
phi,
this->mesh().surfaceInterpolation::weights(),
this->limiter(phi)
);
}
template<class Type>
tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >

11
src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedSurfaceInterpolationScheme/limitedSurfaceInterpolationScheme.H
View File

@ -26,7 +26,7 @@ Class
Foam::limitedSurfaceInterpolationScheme
Description
Abstract base class for surface interpolation schemes.
Abstract base class for limited surface interpolation schemes.
SourceFiles
limitedSurfaceInterpolationScheme.C
@ -170,6 +170,15 @@ public:
const GeometricField<Type, fvPatchField, volMesh>&
) const = 0;
//- Return the interpolation weighting factors for the given field,
// by limiting the given weights with the given limiter
tmp<surfaceScalarField> weights
(
const GeometricField<Type, fvPatchField, volMesh>&,
const surfaceScalarField& CDweights,
tmp<surfaceScalarField> tLimiter
) const;
//- Return the interpolation weighting factors for the given field
virtual tmp<surfaceScalarField> weights
(

20
src/meshTools/meshTools/meshTools.C
View File

@ -182,7 +182,7 @@ Foam::vectorField Foam::meshTools::calcBoxPointNormals(const primitivePatch& pp)
"Foam::meshTools::calcBoxPointNormals"
"(const primitivePatch& pp)"
) << "No visible octant for point:" << pp.meshPoints()[pointI]
<< " cooord:" << pp.localPoints()[pointI] << nl
<< " cooord:" << pp.points()[pp.meshPoints()[pointI]] << nl
<< "Normal set to " << pn[pointI] << endl;
}
}
@ -299,7 +299,7 @@ bool Foam::meshTools::edgeOnCell
const label edgeI
)
{
return findIndex(mesh.edgeCells()[edgeI], cellI) != -1;
return findIndex(mesh.edgeCells(edgeI), cellI) != -1;
}
@ -310,7 +310,7 @@ bool Foam::meshTools::edgeOnFace
const label edgeI
)
{
return findIndex(mesh.faceEdges()[faceI], edgeI) != -1;
return findIndex(mesh.faceEdges(faceI), edgeI) != -1;
}
@ -403,7 +403,6 @@ Foam::label Foam::meshTools::getSharedEdge
const labelList& f0Edges = mesh.faceEdges()[f0];
const labelList& f1Edges = mesh.faceEdges()[f1];
forAll(f0Edges, f0EdgeI)
{
label edge0 = f0Edges[f0EdgeI];
@ -481,7 +480,7 @@ void Foam::meshTools::getEdgeFaces
label& face1
)
{
const labelList& eFaces = mesh.edgeFaces()[edgeI];
const labelList& eFaces = mesh.edgeFaces(edgeI);
face0 = -1;
face1 = -1;
@ -619,7 +618,7 @@ Foam::label Foam::meshTools::walkFace
const label nEdges
)
{
const labelList& fEdges = mesh.faceEdges()[faceI];
const labelList& fEdges = mesh.faceEdges(faceI);
label edgeI = startEdgeI;
@ -790,13 +789,4 @@ Foam::label Foam::meshTools::cutDirToEdge
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
// ************************************************************************* //

2
tutorials/MRFSimpleFoam/mixerVessel2D/constant/polyMesh/blockMeshDict.m4
View File

@ -8,7 +8,7 @@
FoamFile
{
version 2.0;
format ascii;
`format' ascii;
class dictionary;
object blockMeshDict;
}

2
tutorials/interDyMFoam/sloshingTank2D3DoF/constant/polyMesh/blockMeshDict.m4
View File

@ -8,7 +8,7 @@
FoamFile
{
version 2.0;
format ascii;
`format' ascii;
class dictionary;
object blockMeshDict;
}

2
tutorials/interDyMFoam/sloshingTank3D/constant/polyMesh/blockMeshDict.m4
View File

@ -8,7 +8,7 @@
FoamFile
{
version 2.0;
format ascii;
`format' ascii;
class dictionary;
object blockMeshDict;
}

2
tutorials/interDyMFoam/sloshingTank3D3DoF/constant/polyMesh/blockMeshDict.m4
View File

@ -8,7 +8,7 @@
FoamFile
{
version 2.0;
format ascii;
`format' ascii;
class dictionary;
object blockMeshDict;
}

2
tutorials/interDyMFoam/sloshingTank3D6DoF/constant/polyMesh/blockMeshDict.m4
View File

@ -8,7 +8,7 @@
FoamFile
{
version 2.0;
format ascii;
`format' ascii;
class dictionary;
object blockMeshDict;
}

2
tutorials/rhoPimpleFoam/angledDuct/constant/polyMesh/blockMeshDict.m4
View File

@ -8,7 +8,7 @@
FoamFile
{
version 2.0;
format ascii;
`format' ascii;
class dictionary;
object blockMeshDict;
}

2
tutorials/rhoPorousSimpleFoam/angledDuctImplicit/constant/polyMesh/blockMeshDict.m4
View File

@ -8,7 +8,7 @@
FoamFile
{
version 2.0;
format ascii;
`format' ascii;
class dictionary;
object blockMeshDict;
}