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

ENH: FieldMapper: extend with unmapped checking flag

Browse Source
This commit is contained in:
mattijs
2013-09-12 15:37:53 +01:00
parent f35433bdea
commit 5ac31aabc8
28 changed files with 754 additions and 402 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposer.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -37,7 +37,6 @@ SourceFiles
#define dimFieldDecomposer_H
#include "fvMesh.H"
#include "fvPatchFieldMapper.H"
#include "surfaceFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

7
applications/utilities/parallelProcessing/decomposePar/pointFieldDecomposer.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -39,7 +39,8 @@ Foam::pointFieldDecomposer::patchFieldDecomposer::patchFieldDecomposer
completeMeshPatch,
procMeshPatch
),
directAddressing_(procMeshPatch.size(), -1)
directAddressing_(procMeshPatch.size(), -1),
hasUnmapped_(false)
{
// Create the inverse-addressing of the patch point labels.
labelList pointMap(completeMeshPatch.boundaryMesh().mesh().size(), -1);
@ -64,6 +65,8 @@ Foam::pointFieldDecomposer::patchFieldDecomposer::patchFieldDecomposer
// Check that all the patch point addresses are set
if (directAddressing_.size() && min(directAddressing_) < 0)
{
hasUnmapped_ = true;
FatalErrorIn
(
"pointFieldDecomposer::patchFieldDecomposer()"

10
applications/utilities/parallelProcessing/decomposePar/pointFieldDecomposer.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -63,6 +63,9 @@ public:
labelList directAddressing_;
//- Does map contain any unmapped values
bool hasUnmapped_;
public:
// Constructors
@ -88,6 +91,11 @@ public:
return true;
}
bool hasUnmapped() const
{
return hasUnmapped_;
}
const labelUList& directAddressing() const
{
return directAddressing_;

6
src/OpenFOAM/fields/Fields/Field/FieldMapper.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -64,6 +64,10 @@ public:
virtual bool direct() const = 0;
//- Are there unmapped values? I.e. do all size() elements get
// get value
virtual bool hasUnmapped() const = 0;
virtual const labelUList& directAddressing() const
{
FatalErrorIn("FieldMapper::directAddressing() const")

104
src/OpenFOAM/fields/Fields/Field/directFieldMapper.H Normal file
View File

@ -0,0 +1,104 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::directFieldMapper
Description
FieldMapper with direct mapping.
\*---------------------------------------------------------------------------*/
#ifndef directFieldMapper_H
#define directFieldMapper_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class directFieldMapper Declaration
\*---------------------------------------------------------------------------*/
class directFieldMapper
:
public FieldMapper
{
const labelUList& directAddressing_;
bool hasUnmapped_;
public:
// Constructors
//- Construct given addressing
patchFieldSubset(const labelUList& directAddressing)
:
directAddressing_(directAddressing),
hasUnmapped_(false)
{
if (directAddressing_.size() && min(directAddressing_) < 0)
{
hasUnmapped_ = true;
}
}
//- Destructor
virtual ~directFieldMapper()
{}
// Member Functions
label size() const
{
return directAddressing_.size();
}
bool direct() const
{
return true;
}
bool hasUnmapped() const
{
return hasUnmapped_;
}
const labelUList& directAddressing() const
{
return directAddressing_;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

111
src/OpenFOAM/fields/pointPatchFields/pointPatchField/directPointPatchFieldMapper.H Normal file
View File

@ -0,0 +1,111 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::directPointPatchFieldMapper
Description
direct pointPatchFieldMapper
\*---------------------------------------------------------------------------*/
#ifndef directPointPatchFieldMapper_H
#define directPointPatchFieldMapper_H
#include "pointPatchFieldMapper.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class directPointPatchFieldMapper Declaration
\*---------------------------------------------------------------------------*/
class directPointPatchFieldMapper
:
public pointPatchFieldMapper
{
//- Addressing from new back to old
const labelUList& directAddressing_;
//- Does map contain any unmapped values
bool hasUnmapped_;
public:
// Constructors
//- Construct given addressing
directPointPatchFieldMapper(const labelUList& directAddressing)
:
directAddressing_(directAddressing),
hasUnmapped_(false)
{
if (directAddressing_.size() && min(directAddressing_) < 0)
{
hasUnmapped_ = true;
}
}
//- Destructor
virtual ~directPointPatchFieldMapper()
{}
// Member Functions
label size() const
{
return directAddressing_.size();
}
bool direct() const
{
return true;
}
bool hasUnmapped() const
{
return hasUnmapped_;
}
const labelUList& directAddressing() const
{
return directAddressing_;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

9
src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -129,6 +129,13 @@ public:
return direct_;
}
//- Are there unmapped values? I.e. do all size() elements get
// get value
virtual bool hasUnmapped() const
{
return insertedObjects();
}
//- Return direct addressing
virtual const labelUList& directAddressing() const;

16
src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -47,6 +47,8 @@ void Foam::pointPatchMapper::calcAddressing() const
<< abort(FatalError);
}
hasUnmapped_ = false;
if (direct())
{
// Direct mapping.
@ -57,7 +59,7 @@ void Foam::pointPatchMapper::calcAddressing() const
{
if (addr[i] < 0)
{
addr[i] = 0;
hasUnmapped_ = true;
}
}
}
@ -87,9 +89,11 @@ void Foam::pointPatchMapper::calcAddressing() const
}
else
{
// Inserted point. Map from point0 (arbitrary choice)
addr[i] = labelList(1, label(0));
w[i] = scalarList(1, 1.0);
// Inserted point.
///// Map from point0 (arbitrary choice)
//addr[i] = labelList(1, label(0));
//w[i] = scalarList(1, 1.0);
hasUnmapped_ = true;
}
}
}
@ -101,6 +105,7 @@ void Foam::pointPatchMapper::clearOut()
deleteDemandDrivenData(directAddrPtr_);
deleteDemandDrivenData(interpolationAddrPtr_);
deleteDemandDrivenData(weightsPtr_);
hasUnmapped_ = false;
}
@ -124,6 +129,7 @@ Foam::pointPatchMapper::pointPatchMapper
? mpm_.oldPatchNMeshPoints()[patch_.index()]
: 0
),
hasUnmapped_(false),
directAddrPtr_(NULL),
interpolationAddrPtr_(NULL),
weightsPtr_(NULL)

9
src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -74,6 +74,8 @@ class pointPatchMapper
// Demand-driven private data
mutable bool hasUnmapped_;
//- Direct addressing (only one for of addressing is used)
mutable labelList* directAddrPtr_;
@ -130,6 +132,11 @@ public:
return patch_.size();
}
virtual bool hasUnmapped() const
{
return hasUnmapped_;
}
//- Return size of field before mapping
virtual label sizeBeforeMapping() const
{

11
src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -130,6 +130,11 @@ public:
return direct_;
}
virtual bool hasUnmapped() const
{
return insertedObjects();
}
//- Return direct addressing
virtual const labelUList& directAddressing() const;
@ -140,13 +145,13 @@ public:
virtual const scalarListList& weights() const;
//- Are there any inserted cells
bool insertedObjects() const
virtual bool insertedObjects() const
{
return insertedCells_;
}
//- Return list of inserted cells
const labelList& insertedObjectLabels() const;
const virtual labelList& insertedObjectLabels() const;
};

7
src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -134,6 +134,11 @@ public:
return direct_;
}
virtual bool hasUnmapped() const
{
return insertedObjects();
}
//- Return direct addressing
virtual const labelUList& directAddressing() const;

49
src/dynamicMesh/fvMeshAdder/fvMeshAdder.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -67,53 +67,6 @@ class fvMeshAdder
private:
// Private class
class directFvPatchFieldMapper
:
public fvPatchFieldMapper
{
// Private data
const labelList& directAddressing_;
public:
// Constructors
//- Construct from components
directFvPatchFieldMapper(const labelList& directAddressing)
:
fvPatchFieldMapper(),
directAddressing_(directAddressing)
{}
//- Destructor
virtual ~directFvPatchFieldMapper()
{}
// Member Functions
label size() const
{
return directAddressing_.size();
}
bool direct() const
{
return true;
}
const labelUList& directAddressing() const
{
return directAddressing_;
}
};
// Private Member Functions
//- Calculate map from new patch faces to old patch faces. -1 where

4
src/dynamicMesh/fvMeshAdder/fvMeshAdderTemplates.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,10 +23,10 @@ License
\*---------------------------------------------------------------------------*/
#include "volFields.H"
#include "surfaceFields.H"
#include "emptyFvPatchField.H"
#include "directFvPatchFieldMapper.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //

7
src/finiteVolume/fields/fvPatchFields/derived/fixedFluxPressure/fixedFluxPressureFvPatchScalarField.C
View File

@ -53,8 +53,13 @@ Foam::fixedFluxPressureFvPatchScalarField::fixedFluxPressureFvPatchScalarField
fixedGradientFvPatchScalarField(p, iF),
curTimeIndex_(-1)
{
patchType() = ptf.patchType();
// Map value. Set unmapped values and overwrite with mapped ptf
fvPatchField<scalar>::operator=(patchInternalField());
if (&iF && iF.size())
{
fvPatchField<scalar>::operator=(patchInternalField());
}
map(ptf, mapper);
// Map gradient. Set unmapped values and overwrite with mapped ptf
gradient() = 0.0;

111
src/finiteVolume/fields/fvPatchFields/fvPatchField/directFvPatchFieldMapper.H Normal file
View File

@ -0,0 +1,111 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::directFvPatchFieldMapper
Description
direct fvPatchFieldMapper
\*---------------------------------------------------------------------------*/
#ifndef directFvPatchFieldMapper_H
#define directFvPatchFieldMapper_H
#include "fvPatchFieldMapper.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class directFvPatchFieldMapper Declaration
\*---------------------------------------------------------------------------*/
class directFvPatchFieldMapper
:
public fvPatchFieldMapper
{
//- Addressing from new back to old
const labelUList& directAddressing_;
//- Does map contain any unmapped values
bool hasUnmapped_;
public:
// Constructors
//- Construct given addressing
directFvPatchFieldMapper(const labelUList& directAddressing)
:
directAddressing_(directAddressing),
hasUnmapped_(false)
{
if (directAddressing_.size() && min(directAddressing_) < 0)
{
hasUnmapped_ = true;
}
}
//- Destructor
virtual ~directFvPatchFieldMapper()
{}
// Member Functions
label size() const
{
return directAddressing_.size();
}
bool direct() const
{
return true;
}
bool hasUnmapped() const
{
return hasUnmapped_;
}
const labelUList& directAddressing() const
{
return directAddressing_;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

9
src/finiteVolume/fvMesh/fvMeshMapper/fvPatchMapper.C
View File

@ -55,6 +55,8 @@ void Foam::fvPatchMapper::calcAddressing() const
const label oldPatchEnd =
oldPatchStart + faceMap_.oldPatchSizes()[patch_.index()];
hasUnmapped_ = false;
// Assemble the maps: slice to patch
if (direct())
{
@ -84,6 +86,7 @@ void Foam::fvPatchMapper::calcAddressing() const
{
//addr[faceI] = 0;
addr[faceI] = -1;
hasUnmapped_ = true;
}
}
@ -175,6 +178,10 @@ void Foam::fvPatchMapper::calcAddressing() const
{
newWeights /= sum(newWeights);
}
else
{
hasUnmapped_ = true;
}
// Reset addressing and weights
curAddr = newAddr;
@ -206,6 +213,7 @@ void Foam::fvPatchMapper::clearOut()
deleteDemandDrivenData(directAddrPtr_);
deleteDemandDrivenData(interpolationAddrPtr_);
deleteDemandDrivenData(weightsPtr_);
hasUnmapped_ = false;
}
@ -221,6 +229,7 @@ Foam::fvPatchMapper::fvPatchMapper
patch_(patch),
faceMap_(faceMap),
sizeBeforeMapping_(faceMap.oldPatchSizes()[patch_.index()]),
hasUnmapped_(false),
directAddrPtr_(NULL),
interpolationAddrPtr_(NULL),
weightsPtr_(NULL)

9
src/finiteVolume/fvMesh/fvMeshMapper/fvPatchMapper.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -71,6 +71,8 @@ class fvPatchMapper
// Demand-driven private data
mutable bool hasUnmapped_;
//- Direct addressing (only one for of addressing is used)
mutable labelList* directAddrPtr_;
@ -138,6 +140,11 @@ public:
return faceMap_.direct();
}
virtual bool hasUnmapped() const
{
return hasUnmapped_;
}
//- Return direct addressing
virtual const labelUList& directAddressing() const;

8
src/finiteVolume/fvMesh/fvMeshMapper/fvSurfaceMapper.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -133,6 +133,12 @@ public:
return faceMap_.direct();
}
//- Has unmapped elements
virtual bool hasUnmapped() const
{
return insertedObjects();
}
//- Return direct addressing
virtual const labelUList& directAddressing() const;

86
src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.H
View File

@ -56,8 +56,6 @@ SourceFiles
#include "fvMesh.H"
#include "pointMesh.H"
#include "fvPatchFieldMapper.H"
#include "pointPatchFieldMapper.H"
#include "GeometricField.H"
#include "HashSet.H"
#include "surfaceMesh.H"
@ -74,90 +72,6 @@ namespace Foam
class fvMeshSubset
{
public:
//- Patch-field subset interpolation class
class patchFieldSubset
:
public fvPatchFieldMapper
{
const labelList& directAddressing_;
public:
// Constructors
//- Construct given addressing
patchFieldSubset(const labelList& directAddressing)
:
directAddressing_(directAddressing)
{}
//- Destructor
virtual ~patchFieldSubset()
{}
// Member Functions
label size() const
{
return directAddressing_.size();
}
bool direct() const
{
return true;
}
const labelUList& directAddressing() const
{
return directAddressing_;
}
};
//- Patch-field subset interpolation class
class pointPatchFieldSubset
:
public pointPatchFieldMapper
{
const labelList& directAddressing_;
public:
// Constructors
//- Construct given addressing
pointPatchFieldSubset(const labelList& directAddressing)
:
directAddressing_(directAddressing)
{}
//- Destructor
virtual ~pointPatchFieldSubset()
{}
// Member Functions
label size() const
{
return directAddressing_.size();
}
bool direct() const
{
return true;
}
const labelUList& directAddressing() const
{
return directAddressing_;
}
};
private:
// Private data

91
src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubsetInterpolate.C
View File

@ -27,6 +27,8 @@ License
#include "emptyFvsPatchField.H"
#include "emptyPointPatchField.H"
#include "emptyFvPatchFields.H"
#include "directFvPatchFieldMapper.H"
#include "directPointPatchFieldMapper.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -70,8 +72,9 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > fvMeshSubset::interpolate
patchFields.set
(
patchI,
new calculatedFvPatchField<Type>
fvPatchField<Type>::New
(
calculatedFvPatchField<Type>::typeName,
sMesh.boundary()[patchI],
DimensionedField<Type, volMesh>::null()
)
@ -142,7 +145,7 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > fvMeshSubset::interpolate
vf.boundaryField()[patchMap[patchI]],
subPatch,
resF.dimensionedInternalField(),
patchFieldSubset(directAddressing)
directFvPatchFieldMapper(directAddressing)
)
);
}
@ -203,8 +206,9 @@ tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > fvMeshSubset::interpolate
patchFields.set
(
patchI,
new calculatedFvsPatchField<Type>
fvsPatchField<Type>::New
(
calculatedFvsPatchField<Type>::typeName,
sMesh.boundary()[patchI],
DimensionedField<Type, surfaceMesh>::null()
)
@ -285,7 +289,7 @@ tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > fvMeshSubset::interpolate
vf.boundaryField()[patchMap[patchI]],
subPatch,
resF.dimensionedInternalField(),
patchFieldSubset(directAddressing)
directFvPatchFieldMapper(directAddressing)
)
);
@ -348,10 +352,7 @@ fvMeshSubset::interpolate
const labelList& pointMap
)
{
// Create and map the internal-field values
Field<Type> internalField(vf.internalField(), pointMap);
// Create and map the patch field values
// 1. Create the complete field with dummy patch fields
PtrList<pointPatchField<Type> > patchFields(patchMap.size());
forAll(patchFields, patchI)
@ -372,6 +373,54 @@ fvMeshSubset::interpolate
);
}
else
{
patchFields.set
(
patchI,
pointPatchField<Type>::New
(
calculatedPointPatchField<Type>::typeName,
sMesh.boundary()[patchI],
DimensionedField<Type, pointMesh>::null()
)
);
}
}
// Create the complete field from the pieces
tmp<GeometricField<Type, pointPatchField, pointMesh> > tresF
(
new GeometricField<Type, pointPatchField, pointMesh>
(
IOobject
(
"subset"+vf.name(),
sMesh.time().timeName(),
sMesh.thisDb(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
sMesh,
vf.dimensions(),
Field<Type>(vf.internalField(), pointMap),
patchFields
)
);
GeometricField<Type, pointPatchField, pointMesh>& resF = tresF();
// 2. Change the pointPatchFields to the correct type using a mapper
// constructor (with reference to the now correct internal field)
typename GeometricField<Type, pointPatchField, pointMesh>::
GeometricBoundaryField& bf = resF.boundaryField();
forAll(bf, patchI)
{
// Set the first one by hand as it corresponds to the
// exposed internal faces. Additional interpolation can be put here
// as necessary.
if (patchMap[patchI] != -1)
{
// Construct addressing
const pointPatch& basePatch =
@ -406,40 +455,20 @@ fvMeshSubset::interpolate
}
}
patchFields.set
bf.set
(
patchI,
pointPatchField<Type>::New
(
vf.boundaryField()[patchMap[patchI]],
subPatch,
DimensionedField<Type, pointMesh>::null(),
pointPatchFieldSubset(directAddressing)
resF.dimensionedInternalField(),
directPointPatchFieldMapper(directAddressing)
)
);
}
}
// Create the complete field from the pieces
tmp<GeometricField<Type, pointPatchField, pointMesh> > tresF
(
new GeometricField<Type, pointPatchField, pointMesh>
(
IOobject
(
"subset"+vf.name(),
vf.time().timeName(),
sMesh.thisDb(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
sMesh,
vf.dimensions(),
internalField,
patchFields
)
);
return tresF;
}

55
src/finiteVolume/fvMesh/singleCellFvMesh/singleCellFvMesh.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -87,39 +87,6 @@ class singleCellFvMesh
public:
//- Patch field mapper class for non-agglomerated meshes
class directPatchFieldMapper
:
public fvPatchFieldMapper
{
// Private data
const labelUList& directAddressing_;
public:
//- Construct given addressing
directPatchFieldMapper(const labelUList& directAddressing)
:
directAddressing_(directAddressing)
{}
virtual label size() const
{
return directAddressing_.size();
}
virtual bool direct() const
{
return true;
}
virtual const labelUList& directAddressing() const
{
return directAddressing_;
}
};
//- Patch field mapper class for agglomerated meshes
class agglomPatchFieldMapper
:
@ -129,6 +96,7 @@ public:
const labelListList& addressing_;
const scalarListList& weights_;
bool hasUnmapped_;
public:
@ -140,8 +108,18 @@ public:
)
:
addressing_(addressing),
weights_(weights)
{}
weights_(weights),
hasUnmapped_(false)
{
forAll(addressing_, i)
{
if (addressing_[i].empty())
{
hasUnmapped_ = true;
break;
}
}
}
virtual label size() const
{
@ -153,6 +131,11 @@ public:
return false;
}
bool hasUnmapped() const
{
return hasUnmapped_;
}
virtual const labelListList& addressing() const
{
return addressing_;

81
src/finiteVolume/fvMesh/singleCellFvMesh/singleCellFvMeshInterpolate.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -24,6 +24,8 @@ License
\*---------------------------------------------------------------------------*/
#include "singleCellFvMesh.H"
#include "calculatedFvPatchFields.H"
#include "directFvPatchFieldMapper.H"
#include "Time.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -39,12 +41,51 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > singleCellFvMesh::interpolate
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
// Create internal-field values
Field<Type> internalField(1, gAverage(vf));
// Create and map the patch field values
// 1. Create the complete field with dummy patch fields
PtrList<fvPatchField<Type> > patchFields(vf.boundaryField().size());
forAll(patchFields, patchI)
{
patchFields.set
(
patchI,
fvPatchField<Type>::New
(
calculatedFvPatchField<Type>::typeName,
boundary()[patchI],
DimensionedField<Type, volMesh>::null()
)
);
}
// Create the complete field from the pieces
tmp<GeometricField<Type, fvPatchField, volMesh> > tresF
(
new GeometricField<Type, fvPatchField, volMesh>
(
IOobject
(
vf.name(),
time().timeName(),
*this,
IOobject::NO_READ,
IOobject::NO_WRITE
),
*this,
vf.dimensions(),
Field<Type>(1, gAverage(vf)),
patchFields
)
);
GeometricField<Type, fvPatchField, volMesh>& resF = tresF();
// 2. Change the fvPatchFields to the correct type using a mapper
// constructor (with reference to the now correct internal field)
typename GeometricField<Type, fvPatchField, volMesh>::
GeometricBoundaryField& bf = resF.boundaryField();
if (agglomerate())
{
forAll(vf.boundaryField(), patchI)
@ -67,14 +108,14 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > singleCellFvMesh::interpolate
);
}
patchFields.set
bf.set
(
patchI,
fvPatchField<Type>::New
(
vf.boundaryField()[patchI],
boundary()[patchI],
DimensionedField<Type, volMesh>::null(),
resF.dimensionedInternalField(),
agglomPatchFieldMapper(coarseToFine, coarseWeights)
)
);
@ -86,40 +127,20 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > singleCellFvMesh::interpolate
{
labelList map(identity(vf.boundaryField()[patchI].size()));
patchFields.set
bf.set
(
patchI,
fvPatchField<Type>::New
(
vf.boundaryField()[patchI],
boundary()[patchI],
DimensionedField<Type, volMesh>::null(),
directPatchFieldMapper(map)
resF.dimensionedInternalField(),
directFvPatchFieldMapper(map)
)
);
}
}
// Create the complete field from the pieces
tmp<GeometricField<Type, fvPatchField, volMesh> > tresF
(
new GeometricField<Type, fvPatchField, volMesh>
(
IOobject
(
vf.name(),
time().timeName(),
*this,
IOobject::NO_READ,
IOobject::NO_WRITE
),
*this,
vf.dimensions(),
internalField,
patchFields
)
);
return tresF;
}

20
src/parallel/decompose/decompose/fvFieldDecomposer.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -88,6 +88,12 @@ public:
return true;
}
//- Are there unmapped values
bool hasUnmapped() const
{
return false;
}
const labelUList& directAddressing() const
{
return directAddressing_;
@ -128,6 +134,12 @@ public:
return true;
}
//- Are there unmapped values
bool hasUnmapped() const
{
return false;
}
const labelUList& directAddressing() const
{
return directAddressing_;
@ -165,6 +177,12 @@ public:
return false;
}
//- Are there unmapped values
bool hasUnmapped() const
{
return false;
}
const labelListList& addressing() const
{
return addressing_;

239
src/parallel/decompose/decompose/fvFieldDecomposerDecomposeFields.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -40,83 +40,25 @@ Foam::fvFieldDecomposer::decomposeField
const bool allowUnknownPatchFields
) const
{
// Create and map the internal field values
Field<Type> internalField(field.internalField(), cellAddressing_);
// Create and map the patch field values
// 1. Create the complete field with dummy patch fields
PtrList<fvPatchField<Type> > patchFields(boundaryAddressing_.size());
forAll(boundaryAddressing_, patchi)
{
if (patchFieldDecomposerPtrs_[patchi])
{
patchFields.set
patchFields.set
(
patchi,
fvPatchField<Type>::New
(
patchi,
fvPatchField<Type>::New
(
field.boundaryField()[boundaryAddressing_[patchi]],
procMesh_.boundary()[patchi],
DimensionedField<Type, volMesh>::null(),
*patchFieldDecomposerPtrs_[patchi]
)
);
}
else if (isA<processorCyclicFvPatch>(procMesh_.boundary()[patchi]))
{
patchFields.set
(
patchi,
new processorCyclicFvPatchField<Type>
(
procMesh_.boundary()[patchi],
DimensionedField<Type, volMesh>::null(),
Field<Type>
(
field.internalField(),
*processorVolPatchFieldDecomposerPtrs_[patchi]
)
)
);
}
else if (isA<processorFvPatch>(procMesh_.boundary()[patchi]))
{
patchFields.set
(
patchi,
new processorFvPatchField<Type>
(
procMesh_.boundary()[patchi],
DimensionedField<Type, volMesh>::null(),
Field<Type>
(
field.internalField(),
*processorVolPatchFieldDecomposerPtrs_[patchi]
)
)
);
}
else if (allowUnknownPatchFields)
{
patchFields.set
(
patchi,
new emptyFvPatchField<Type>
(
procMesh_.boundary()[patchi],
DimensionedField<Type, volMesh>::null()
)
);
}
else
{
FatalErrorIn("fvFieldDecomposer::decomposeField()")
<< "Unknown type." << abort(FatalError);
}
calculatedFvPatchField<Type>::typeName,
procMesh_.boundary()[patchi],
DimensionedField<Type, volMesh>::null()
)
);
}
// Create the field for the processor
return tmp<GeometricField<Type, fvPatchField, volMesh> >
tmp<GeometricField<Type, fvPatchField, volMesh> > tresF
(
new GeometricField<Type, fvPatchField, volMesh>
(
@ -130,10 +72,90 @@ Foam::fvFieldDecomposer::decomposeField
),
procMesh_,
field.dimensions(),
internalField,
Field<Type>(field.internalField(), cellAddressing_),
patchFields
)
);
GeometricField<Type, fvPatchField, volMesh>& resF = tresF();
// 2. Change the fvPatchFields to the correct type using a mapper
// constructor (with reference to the now correct internal field)
typename GeometricField<Type, fvPatchField, volMesh>::
GeometricBoundaryField& bf = resF.boundaryField();
forAll(bf, patchi)
{
if (patchFieldDecomposerPtrs_[patchi])
{
bf.set
(
patchi,
fvPatchField<Type>::New
(
field.boundaryField()[boundaryAddressing_[patchi]],
procMesh_.boundary()[patchi],
resF.dimensionedInternalField(),
*patchFieldDecomposerPtrs_[patchi]
)
);
}
else if (isA<processorCyclicFvPatch>(procMesh_.boundary()[patchi]))
{
bf.set
(
patchi,
new processorCyclicFvPatchField<Type>
(
procMesh_.boundary()[patchi],
resF.dimensionedInternalField(),
Field<Type>
(
field.internalField(),
*processorVolPatchFieldDecomposerPtrs_[patchi]
)
)
);
}
else if (isA<processorFvPatch>(procMesh_.boundary()[patchi]))
{
bf.set
(
patchi,
new processorFvPatchField<Type>
(
procMesh_.boundary()[patchi],
resF.dimensionedInternalField(),
Field<Type>
(
field.internalField(),
*processorVolPatchFieldDecomposerPtrs_[patchi]
)
)
);
}
else if (allowUnknownPatchFields)
{
bf.set
(
patchi,
new emptyFvPatchField<Type>
(
procMesh_.boundary()[patchi],
resF.dimensionedInternalField()
)
);
}
else
{
FatalErrorIn("fvFieldDecomposer::decomposeField()")
<< "Unknown type." << abort(FatalError);
}
}
// Create the field for the processor
return tresF;
}
@ -188,34 +210,76 @@ Foam::fvFieldDecomposer::decomposeField
}
}
// Create and map the patch field values
// 1. Create the complete field with dummy patch fields
PtrList<fvsPatchField<Type> > patchFields(boundaryAddressing_.size());
forAll(boundaryAddressing_, patchi)
{
patchFields.set
(
patchi,
fvsPatchField<Type>::New
(
calculatedFvsPatchField<Type>::typeName,
procMesh_.boundary()[patchi],
DimensionedField<Type, surfaceMesh>::null()
)
);
}
tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > tresF
(
new GeometricField<Type, fvsPatchField, surfaceMesh>
(
IOobject
(
field.name(),
procMesh_.time().timeName(),
procMesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
procMesh_,
field.dimensions(),
Field<Type>(field.internalField(), mapAddr),
patchFields
)
);
GeometricField<Type, fvsPatchField, surfaceMesh>& resF = tresF();
// 2. Change the fvsPatchFields to the correct type using a mapper
// constructor (with reference to the now correct internal field)
typename GeometricField<Type, fvsPatchField, surfaceMesh>::
GeometricBoundaryField& bf = resF.boundaryField();
forAll(boundaryAddressing_, patchi)
{
if (patchFieldDecomposerPtrs_[patchi])
{
patchFields.set
bf.set
(
patchi,
fvsPatchField<Type>::New
(
field.boundaryField()[boundaryAddressing_[patchi]],
procMesh_.boundary()[patchi],
DimensionedField<Type, surfaceMesh>::null(),
resF.dimensionedInternalField(),
*patchFieldDecomposerPtrs_[patchi]
)
);
}
else if (isA<processorCyclicFvPatch>(procMesh_.boundary()[patchi]))
{
patchFields.set
bf.set
(
patchi,
new processorCyclicFvsPatchField<Type>
(
procMesh_.boundary()[patchi],
DimensionedField<Type, surfaceMesh>::null(),
resF.dimensionedInternalField(),
Field<Type>
(
allFaceField,
@ -226,13 +290,13 @@ Foam::fvFieldDecomposer::decomposeField
}
else if (isA<processorFvPatch>(procMesh_.boundary()[patchi]))
{
patchFields.set
bf.set
(
patchi,
new processorFvsPatchField<Type>
(
procMesh_.boundary()[patchi],
DimensionedField<Type, surfaceMesh>::null(),
resF.dimensionedInternalField(),
Field<Type>
(
allFaceField,
@ -249,24 +313,7 @@ Foam::fvFieldDecomposer::decomposeField
}
// Create the field for the processor
return tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
(
new GeometricField<Type, fvsPatchField, surfaceMesh>
(
IOobject
(
field.name(),
procMesh_.time().timeName(),
procMesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
procMesh_,
field.dimensions(),
internalField,
patchFields
)
);
return tresF;
}

7
src/parallel/reconstruct/reconstruct/fvFieldReconstructor.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -116,6 +116,11 @@ public:
return true;
}
bool hasUnmapped() const
{
return false;
}
const labelUList& directAddressing() const
{
return labelUList::null();

7
src/parallel/reconstruct/reconstruct/pointFieldReconstructor.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -112,6 +112,11 @@ public:
return true;
}
bool hasUnmapped() const
{
return false;
}
const labelUList& directAddressing() const
{
return labelUList::null();

42
src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H
View File

@ -175,48 +175,6 @@ public:
~meshToMesh();
//- Patch-field interpolation class
class patchFieldInterpolator
:
public fvPatchFieldMapper
{
const labelList& directAddressing_;
public:
// Constructors
//- Construct given addressing
patchFieldInterpolator(const labelList& addr)
:
directAddressing_(addr)
{}
//- Destructor
virtual ~patchFieldInterpolator()
{}
// Member Functions
label size() const
{
return directAddressing_.size();
}
bool direct() const
{
return true;
}
const labelList& directAddressing() const
{
return directAddressing_;
}
};
// Member Functions
// Access

38
src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -28,6 +28,7 @@ License
#include "interpolationCellPoint.H"
#include "SubField.H"
#include "mixedFvPatchField.H"
#include "directFvPatchFieldMapper.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
@ -408,7 +409,7 @@ Foam::meshToMesh::interpolate
<< exit(FatalError);
}
// Create and map the patch field values
// 1. Create the complete field with dummy patch fields
PtrList<fvPatchField<Type> > patchFields
(
boundaryAddressing_.size()
@ -421,13 +422,9 @@ Foam::meshToMesh::interpolate
patchI,
fvPatchField<Type>::New
(
fromVf.boundaryField()[patchI],
calculatedFvPatchField<Type>::typeName,
toMesh_.boundary()[patchI],
DimensionedField<Type, volMesh>::null(),
patchFieldInterpolator
(
boundaryAddressing_[patchI]
)
DimensionedField<Type, volMesh>::null()
)
);
}
@ -452,6 +449,31 @@ Foam::meshToMesh::interpolate
patchFields
)
);
GeometricField<Type, fvPatchField, volMesh>& toF = ttoF();
// 2. Change the fvPatchFields to the correct type using a mapper
// constructor (with reference to the now correct internal field)
typename GeometricField<Type, fvPatchField, volMesh>::
GeometricBoundaryField& bf = toF.boundaryField();
forAll(boundaryAddressing_, patchI)
{
bf.set
(
patchI,
fvPatchField<Type>::New
(
fromVf.boundaryField()[patchI],
toMesh_.boundary()[patchI],
toF.dimensionedInternalField(),
directFvPatchFieldMapper
(
boundaryAddressing_[patchI]
)
)
);
}
return ttoF;
}