songtianlun/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ENH: Adding surfaceFields sampling to sampledPatch

Browse Source
This commit is contained in:
sergio 2012-08-07 14:23:55 +01:00
parent 4113feb869
commit fd6f81bbf3
9 changed files with 343 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/sampling/sampledSurface/sampledPatch/sampledPatch.C
View File

@ -28,6 +28,7 @@ License
#include "polyMesh.H"
#include "polyPatch.H"
#include "volFields.H"
#include "surfaceFields.H"
#include "addToRunTimeSelectionTable.H"
@ -274,6 +275,49 @@ Foam::tmp<Foam::tensorField> Foam::sampledPatch::sample
}
Foam::tmp<Foam::scalarField> Foam::sampledPatch::sample
(
const surfaceScalarField& sField
) const
{
return sampleField(sField);
}
Foam::tmp<Foam::vectorField> Foam::sampledPatch::sample
(
const surfaceVectorField& sField
) const
{
return sampleField(sField);
}
Foam::tmp<Foam::sphericalTensorField> Foam::sampledPatch::sample
(
const surfaceSphericalTensorField& sField
) const
{
return sampleField(sField);
}
Foam::tmp<Foam::symmTensorField> Foam::sampledPatch::sample
(
const surfaceSymmTensorField& sField
) const
{
return sampleField(sField);
}
Foam::tmp<Foam::tensorField> Foam::sampledPatch::sample
(
const surfaceTensorField& sField
) const
{
return sampleField(sField);
}
Foam::tmp<Foam::scalarField> Foam::sampledPatch::interpolate
(
const interpolation<scalar>& interpolator

36
src/sampling/sampledSurface/sampledPatch/sampledPatch.H
View File

@ -87,6 +87,13 @@ class sampledPatch
const GeometricField<Type, fvPatchField, volMesh>& vField
) const;
//- sample surface field on faces
template <class Type>
tmp<Field<Type> > sampleField
(
const GeometricField<Type, fvsPatchField, surfaceMesh>& sField
) const;
template <class Type>
tmp<Field<Type> >
interpolateField(const interpolation<Type>&) const;
@ -203,6 +210,35 @@ public:
const volTensorField&
) const;
//- Surface sample field on surface
virtual tmp<scalarField> sample
(
const surfaceScalarField&
) const;
//- Surface Sample field on surface
virtual tmp<vectorField> sample
(
const surfaceVectorField&
) const;
//- Surface sample field on surface
virtual tmp<sphericalTensorField> sample
(
const surfaceSphericalTensorField&
) const;
//- Surface sample field on surface
virtual tmp<symmTensorField> sample
(
const surfaceSymmTensorField&
) const;
//- Surface sample field on surface
virtual tmp<tensorField> sample
(
const surfaceTensorField&
) const;
//- interpolate field on surface
virtual tmp<scalarField> interpolate

21
src/sampling/sampledSurface/sampledPatch/sampledPatchTemplates.C
View File

@ -48,6 +48,27 @@ Foam::sampledPatch::sampleField
}
template <class Type>
Foam::tmp<Foam::Field<Type> >
Foam::sampledPatch::sampleField
(
const GeometricField<Type, fvsPatchField, surfaceMesh>& sField
) const
{
// One value per face
tmp<Field<Type> > tvalues(new Field<Type>(patchFaceLabels_.size()));
Field<Type>& values = tvalues();
forAll(patchFaceLabels_, i)
{
label patchI = patchIDs_[patchIndex_[i]];
values[i] = sField.boundaryField()[patchI][patchFaceLabels_[i]];
}
return tvalues;
}
template <class Type>
Foam::tmp<Foam::Field<Type> >
Foam::sampledPatch::interpolateField

49
src/sampling/sampledSurface/sampledSurface/sampledSurface.C
View File

@ -240,6 +240,55 @@ Foam::scalar Foam::sampledSurface::area() const
}
Foam::tmp<Foam::scalarField> Foam::sampledSurface::sample
(
const surfaceScalarField& sField
) const
{
notImplemented("tmp<Foam::scalarField> sampledSurface::sample");
return tmp<scalarField>(NULL);
}
Foam::tmp<Foam::vectorField> Foam::sampledSurface::sample
(
const surfaceVectorField& sField
) const
{
notImplemented("tmp<Foam::vectorField> sampledSurface::sample");
return tmp<vectorField>(NULL);
}
Foam::tmp<Foam::sphericalTensorField> Foam::sampledSurface::sample
(
const surfaceSphericalTensorField& sField
) const
{
notImplemented("tmp<Foam::sphericalTensorField> sampledSurface::sample");
return tmp<sphericalTensorField>(NULL);
}
Foam::tmp<Foam::symmTensorField> Foam::sampledSurface::sample
(
const surfaceSymmTensorField& sField
) const
{
notImplemented("tmp<Foam::symmTensorField> sampledSurface::sample");
return tmp<symmTensorField>(NULL);
}
Foam::tmp<Foam::tensorField> Foam::sampledSurface::sample
(
const surfaceTensorField& sField
) const
{
notImplemented("tmp<Foam::tensorField> sampledSurface::sample");
return tmp<tensorField>(NULL);
}
Foam::tmp<Foam::Field<Foam::scalar> >
Foam::sampledSurface::project(const Field<scalar>& field) const
{

31
src/sampling/sampledSurface/sampledSurface/sampledSurface.H
View File

@ -57,6 +57,8 @@ SourceFiles
#include "runTimeSelectionTables.H"
#include "autoPtr.H"
#include "volFieldsFwd.H"
#include "surfaceFieldsFwd.H"
#include "surfaceMesh.H"
#include "polyMesh.H"
#include "coordinateSystems.H"
#include "interpolation.H"
@ -352,6 +354,35 @@ public:
const volTensorField&
) const = 0;
//- Surface sample field on surface
virtual tmp<scalarField> sample
(
const surfaceScalarField&
) const;
//- Surface Sample field on surface
virtual tmp<vectorField> sample
(
const surfaceVectorField&
) const;
//- Surface sample field on surface
virtual tmp<sphericalTensorField> sample
(
const surfaceSphericalTensorField&
) const;
//- Surface sample field on surface
virtual tmp<symmTensorField> sample
(
const surfaceSymmTensorField&
) const;
//- Surface sample field on surface
virtual tmp<tensorField> sample
(
const surfaceTensorField&
) const;
//- Interpolate field on surface
virtual tmp<scalarField> interpolate

32
src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.C
View File

@ -95,12 +95,7 @@ Foam::sampledSurfaces::sampledSurfaces
fieldSelection_(),
interpolationScheme_(word::null),
mergeList_(),
formatter_(NULL),
scalarFields_(),
vectorFields_(),
sphericalTensorFields_(),
symmTensorFields_(),
tensorFields_()
formatter_(NULL)
{
if (Pstream::parRun())
{
@ -154,13 +149,6 @@ void Foam::sampledSurfaces::write()
{
if (debug)
{
Pout<< "timeName = " << mesh_.time().timeName() << nl
<< "scalarFields " << scalarFields_ << nl
<< "vectorFields " << vectorFields_ << nl
<< "sphTensorFields " << sphericalTensorFields_ << nl
<< "symTensorFields " << symmTensorFields_ <<nl
<< "tensorFields " << tensorFields_ <<nl;
Pout<< "Creating directory "
<< outputPath_/mesh_.time().timeName() << nl << endl;
@ -176,11 +164,19 @@ void Foam::sampledSurfaces::write()
writeGeometry();
}
sampleAndWrite(scalarFields_);
sampleAndWrite(vectorFields_);
sampleAndWrite(sphericalTensorFields_);
sampleAndWrite(symmTensorFields_);
sampleAndWrite(tensorFields_);
const IOobjectList objects(mesh_, mesh_.time().timeName());
sampleAndWrite<volScalarField>(objects);
sampleAndWrite<volVectorField>(objects);
sampleAndWrite<volSphericalTensorField>(objects);
sampleAndWrite<volSymmTensorField>(objects);
sampleAndWrite<volTensorField>(objects);
sampleAndWrite<surfaceScalarField>(objects);
sampleAndWrite<surfaceVectorField>(objects);
sampleAndWrite<surfaceSphericalTensorField>(objects);
sampleAndWrite<surfaceSymmTensorField>(objects);
sampleAndWrite<surfaceTensorField>(objects);
}
}

48
src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.H
View File

@ -40,7 +40,9 @@ SourceFiles
#include "sampledSurface.H"
#include "surfaceWriter.H"
#include "volFieldsFwd.H"
#include "surfaceFieldsFwd.H"
#include "wordReList.H"
#include "IOobjectList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -60,21 +62,6 @@ class sampledSurfaces
{
// Private classes
//- Class used for grouping field types
template<class Type>
class fieldGroup
:
public DynamicList<word>
{
public:
//- Construct null
fieldGroup()
:
DynamicList<word>(0)
{}
};
//- Class used for surface merging information
class mergeInfo
@ -137,13 +124,6 @@ class sampledSurfaces
//- Surface formatter
autoPtr<surfaceWriter> formatter_;
//- Categorized scalar/vector/tensor fields
fieldGroup<scalar> scalarFields_;
fieldGroup<vector> vectorFields_;
fieldGroup<sphericalTensor> sphericalTensorFields_;
fieldGroup<symmTensor> symmTensorFields_;
fieldGroup<tensor> tensorFields_;
// Private Member Functions
@ -159,13 +139,33 @@ class sampledSurfaces
//- Write geometry only
void writeGeometry() const;
//- Write sampled fieldName on surface and on outputDir path
template<class Type>
void writeSurface
(
const Field<Type>& values,
const label surfI,
const word& fieldName,
const fileName& outputDir
);
//- Sample and write a particular volume field
template<class Type>
void sampleAndWrite(const GeometricField<Type, fvPatchField, volMesh>&);
void sampleAndWrite
(
const GeometricField<Type, fvPatchField, volMesh>&
);
//- Sample and write a particular surface field
template<class Type>
void sampleAndWrite
(
const GeometricField<Type, fvsPatchField, surfaceMesh>&
);
//- Sample and write all the fields of the given type
template<class Type>
void sampleAndWrite(fieldGroup<Type>&);
void sampleAndWrite(const IOobjectList& allObjects);
//- Disallow default bitwise copy construct and assignment
sampledSurfaces(const sampledSurfaces&);

78
src/sampling/sampledSurface/sampledSurfaces/sampledSurfacesGrouping.C
View File

@ -30,94 +30,22 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::sampledSurfaces::clearFieldGroups()
{
scalarFields_.clear();
vectorFields_.clear();
sphericalTensorFields_.clear();
symmTensorFields_.clear();
tensorFields_.clear();
}
Foam::label Foam::sampledSurfaces::appendFieldGroup
(
const word& fieldName,
const word& fieldType
)
{
if (fieldType == volScalarField::typeName)
{
scalarFields_.append(fieldName);
return 1;
}
else if (fieldType == volVectorField::typeName)
{
vectorFields_.append(fieldName);
return 1;
}
else if (fieldType == volSphericalTensorField::typeName)
{
sphericalTensorFields_.append(fieldName);
return 1;
}
else if (fieldType == volSymmTensorField::typeName)
{
symmTensorFields_.append(fieldName);
return 1;
}
else if (fieldType == volTensorField::typeName)
{
tensorFields_.append(fieldName);
return 1;
}
return 0;
}
Foam::label Foam::sampledSurfaces::classifyFields()
{
label nFields = 0;
clearFieldGroups();
// check files for a particular time
// check files for a particular time
if (loadFromFiles_)
{
IOobjectList objects(mesh_, mesh_.time().timeName());
wordList allFields = objects.sortedNames();
labelList indices = findStrings(fieldSelection_, allFields);
forAll(indices, fieldI)
{
const word& fieldName = allFields[indices[fieldI]];
nFields += appendFieldGroup
(
fieldName,
objects.find(fieldName)()->headerClassName()
);
}
return indices.size();
}
else
{
wordList allFields = mesh_.sortedNames();
labelList indices = findStrings(fieldSelection_, allFields);
forAll(indices, fieldI)
{
const word& fieldName = allFields[indices[fieldI]];
nFields += appendFieldGroup
(
fieldName,
mesh_.find(fieldName)()->type()
);
}
return indices.size();
}
return nFields;
}

227
src/sampling/sampledSurface/sampledSurfaces/sampledSurfacesTemplates.C
View File

@ -25,10 +25,86 @@ License
#include "sampledSurfaces.H"
#include "volFields.H"
#include "surfaceFields.H"
#include "ListListOps.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class Type>
void Foam::sampledSurfaces::writeSurface
(
const Field<Type>& values,
const label surfI,
const word& fieldName,
const fileName& outputDir
)
{
const sampledSurface& s = operator[](surfI);
if (Pstream::parRun())
{
// Collect values from all processors
List<Field<Type> > gatheredValues(Pstream::nProcs());
gatheredValues[Pstream::myProcNo()] = values;
Pstream::gatherList(gatheredValues);
if (Pstream::master())
{
// Combine values into single field
Field<Type> allValues
(
ListListOps::combine<Field<Type> >
(
gatheredValues,
accessOp<Field<Type> >()
)
);
// Renumber (point data) to correspond to merged points
if (mergeList_[surfI].pointsMap.size() == allValues.size())
{
inplaceReorder(mergeList_[surfI].pointsMap, allValues);
allValues.setSize(mergeList_[surfI].points.size());
}
// Write to time directory under outputPath_
// skip surface without faces (eg, a failed cut-plane)
if (mergeList_[surfI].faces.size())
{
formatter_->write
(
outputDir,
s.name(),
mergeList_[surfI].points,
mergeList_[surfI].faces,
fieldName,
allValues,
s.interpolate()
);
}
}
}
else
{
// Write to time directory under outputPath_
// skip surface without faces (eg, a failed cut-plane)
if (s.faces().size())
{
formatter_->write
(
outputDir,
s.name(),
s.points(),
s.faces(),
fieldName,
values,
s.interpolate()
);
}
}
}
template<class Type>
void Foam::sampledSurfaces::sampleAndWrite
(
@ -65,125 +141,64 @@ void Foam::sampledSurfaces::sampleAndWrite
values = s.sample(vField);
}
if (Pstream::parRun())
{
// Collect values from all processors
List<Field<Type> > gatheredValues(Pstream::nProcs());
gatheredValues[Pstream::myProcNo()] = values;
Pstream::gatherList(gatheredValues);
if (Pstream::master())
{
// Combine values into single field
Field<Type> allValues
(
ListListOps::combine<Field<Type> >
(
gatheredValues,
accessOp<Field<Type> >()
)
);
// Renumber (point data) to correspond to merged points
if (mergeList_[surfI].pointsMap.size() == allValues.size())
{
inplaceReorder(mergeList_[surfI].pointsMap, allValues);
allValues.setSize(mergeList_[surfI].points.size());
}
// Write to time directory under outputPath_
// skip surface without faces (eg, a failed cut-plane)
if (mergeList_[surfI].faces.size())
{
formatter_->write
(
outputDir,
s.name(),
mergeList_[surfI].points,
mergeList_[surfI].faces,
fieldName,
allValues,
s.interpolate()
);
}
}
}
else
{
// Write to time directory under outputPath_
// skip surface without faces (eg, a failed cut-plane)
if (s.faces().size())
{
formatter_->write
(
outputDir,
s.name(),
s.points(),
s.faces(),
fieldName,
values,
s.interpolate()
);
}
}
writeSurface<Type>(values, surfI, fieldName, outputDir);
}
}
template<class Type>
void Foam::sampledSurfaces::sampleAndWrite
(
fieldGroup<Type>& fields
const GeometricField<Type, fvsPatchField, surfaceMesh>& sField
)
{
if (fields.size())
const word& fieldName = sField.name();
const fileName outputDir = outputPath_/sField.time().timeName();
forAll(*this, surfI)
{
forAll(fields, fieldI)
const sampledSurface& s = operator[](surfI);
Field<Type> values = s.sample(sField);
writeSurface<Type>(values, surfI, fieldName, outputDir);
}
}
template<class GeoField>
void Foam::sampledSurfaces::sampleAndWrite(const IOobjectList& allObjects)
{
IOobjectList fields = allObjects.lookupClass(GeoField::typeName);
forAllConstIter(IOobjectList, fields, fieldIter)
{
forAll (fieldSelection_, fieldI)
{
if (Pstream::master() && verbose_)
const wordRe field = fieldSelection_[fieldI];
if (field.match(fieldIter()->name()))
{
Pout<< "sampleAndWrite: " << fields[fieldI] << endl;
}
if (loadFromFiles_)
{
sampleAndWrite
(
GeometricField<Type, fvPatchField, volMesh>
(
IOobject
(
fields[fieldI],
mesh_.time().timeName(),
mesh_,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
),
mesh_
)
);
}
else
{
objectRegistry::const_iterator iter =
mesh_.find(fields[fieldI]);
if
(
iter != objectRegistry::end()
&& iter()->type()
== GeometricField<Type, fvPatchField, volMesh>::typeName
)
if (Pstream::master() && verbose_)
{
sampleAndWrite
(
mesh_.lookupObject
<GeometricField<Type, fvPatchField, volMesh> >
(
fields[fieldI]
)
);
Pout<< "sampleAndWrite: " << field << endl;
}
if (loadFromFiles_)
{
fieldIter()->readOpt() = IOobject::MUST_READ;
sampleAndWrite
(
GeoField
(
*fieldIter(),
mesh_
)
);
}
else
{
sampleAndWrite
(
mesh_.lookupObject<GeoField>(fieldIter()->name())
);
}
}
}