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

ENH: simplify subsetMesh using new IOobjectList methods

Browse Source
This commit is contained in:
Mark Olesen 2017-05-17 18:35:08 +02:00
parent aeae8e70de
commit d6e721a9bd
1 changed files with 129 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

351
applications/utilities/mesh/manipulation/subsetMesh/subsetMesh.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd. \\/ M anipulation | Copyright (C) 2016-2017 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -112,7 +112,7 @@ labelList nearestPatch(const polyMesh& mesh, const labelList& patchIDs)
{ {
WarningInFunction WarningInFunction
<< "Did not visit some faces, e.g. face " << faceI << "Did not visit some faces, e.g. face " << faceI
<< " at " << mesh.faceCentres()[faceI] << endl << " at " << mesh.faceCentres()[faceI] << nl
<< "Using patch " << patchIDs[0] << " as nearest" << "Using patch " << patchIDs[0] << " as nearest"
<< endl; << endl;
haveWarned = true; haveWarned = true;
@ -129,57 +129,38 @@ labelList nearestPatch(const polyMesh& mesh, const labelList& patchIDs)
} }
template<class Type> //
void subsetVolFields // Subset field-type, availability information cached
// in the availableFields hashtable.
//
template<class Type, template<class> class PatchField, class GeoMesh>
void subsetFields
( (
const fvMeshSubset& subsetter, const fvMeshSubset& subsetter,
const wordList& fieldNames, HashTable<wordHashSet>& availableFields,
PtrList<GeometricField<Type, fvPatchField, volMesh>>& subFields PtrList<GeometricField<Type, PatchField, GeoMesh>>& subFields
) )
{ {
typedef GeometricField<Type, PatchField, GeoMesh> FieldType;
const word fieldType = FieldType::typeName;
const wordList fieldNames = availableFields(fieldType).sortedToc();
subFields.setSize(fieldNames.size());
const fvMesh& baseMesh = subsetter.baseMesh(); const fvMesh& baseMesh = subsetter.baseMesh();
if (fieldNames.empty())
{
return;
}
Info<< "Subsetting " << fieldType << " (";
forAll(fieldNames, i) forAll(fieldNames, i)
{ {
const word& fieldName = fieldNames[i]; const word& fieldName = fieldNames[i];
if (i) Info<< ' ';
Info<< fieldName;
Info<< "Subsetting field " << fieldName << endl; FieldType fld
GeometricField<Type, fvPatchField, volMesh> fld
(
IOobject
(
fieldName,
baseMesh.time().timeName(),
baseMesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
baseMesh
);
subFields.set(i, subsetter.interpolate(fld));
}
}
template<class Type>
void subsetSurfaceFields
(
const fvMeshSubset& subsetter,
const wordList& fieldNames,
PtrList<GeometricField<Type, fvsPatchField, surfaceMesh>>& subFields
)
{
const fvMesh& baseMesh = subsetter.baseMesh();
forAll(fieldNames, i)
{
const word& fieldName = fieldNames[i];
Info<< "Subsetting field " << fieldName << endl;
GeometricField<Type, fvsPatchField, surfaceMesh> fld
( (
IOobject IOobject
( (
@ -193,7 +174,11 @@ void subsetSurfaceFields
); );
subFields.set(i, subsetter.interpolate(fld)); subFields.set(i, subsetter.interpolate(fld));
// Subsetting adds 'subset' prefix - rename to match original.
subFields[i].rename(fieldName);
} }
Info<< ")" << nl;
} }
@ -202,19 +187,30 @@ void subsetPointFields
( (
const fvMeshSubset& subsetter, const fvMeshSubset& subsetter,
const pointMesh& pMesh, const pointMesh& pMesh,
const wordList& fieldNames, HashTable<wordHashSet>& availableFields,
PtrList<GeometricField<Type, pointPatchField, pointMesh>>& subFields PtrList<GeometricField<Type, pointPatchField, pointMesh>>& subFields
) )
{ {
typedef GeometricField<Type, pointPatchField, pointMesh> FieldType;
const word fieldType = FieldType::typeName;
const wordList fieldNames = availableFields(fieldType).sortedToc();
subFields.setSize(fieldNames.size());
const fvMesh& baseMesh = subsetter.baseMesh(); const fvMesh& baseMesh = subsetter.baseMesh();
if (fieldNames.empty())
{
return;
}
Info<< "Subsetting " << fieldType << " (";
forAll(fieldNames, i) forAll(fieldNames, i)
{ {
const word& fieldName = fieldNames[i]; const word& fieldName = fieldNames[i];
if (i) Info<< ' ';
Info<< fieldName;
Info<< "Subsetting field " << fieldName << endl; FieldType fld
GeometricField<Type, pointPatchField, pointMesh> fld
( (
IOobject IOobject
( (
@ -228,7 +224,11 @@ void subsetPointFields
); );
subFields.set(i, subsetter.interpolate(fld)); subFields.set(i, subsetter.interpolate(fld));
// Subsetting adds 'subset' prefix - rename to match original.
subFields[i].rename(fieldName);
} }
Info<< ")" << nl;
} }
@ -236,19 +236,30 @@ template<class Type>
void subsetDimensionedFields void subsetDimensionedFields
( (
const fvMeshSubset& subsetter, const fvMeshSubset& subsetter,
const wordList& fieldNames, HashTable<wordHashSet>& availableFields,
PtrList<DimensionedField<Type, volMesh>>& subFields PtrList<DimensionedField<Type, volMesh>>& subFields
) )
{ {
typedef DimensionedField<Type, volMesh> FieldType;
const word fieldType = FieldType::typeName;
const wordList fieldNames = availableFields(fieldType).sortedToc();
subFields.setSize(fieldNames.size());
const fvMesh& baseMesh = subsetter.baseMesh(); const fvMesh& baseMesh = subsetter.baseMesh();
if (fieldNames.empty())
{
return;
}
Info<< "Subsetting " << fieldType << " (";
forAll(fieldNames, i) forAll(fieldNames, i)
{ {
const word& fieldName = fieldNames[i]; const word& fieldName = fieldNames[i];
if (i) Info<< ' ';
Info<< fieldName;
Info<< "Subsetting field " << fieldName << endl; FieldType fld
DimensionedField<Type, volMesh> fld
( (
IOobject IOobject
( (
@ -262,7 +273,11 @@ void subsetDimensionedFields
); );
subFields.set(i, subsetter.interpolate(fld)); subFields.set(i, subsetter.interpolate(fld));
// Subsetting adds 'subset' prefix - rename to match original.
subFields[i].rename(fieldName);
} }
Info<< ")" << nl;
} }
@ -289,7 +304,7 @@ void subsetTopoSets
// Map the data // Map the data
PackedBoolList isSet(set.maxSize(mesh)); PackedBoolList isSet(set.maxSize(mesh));
forAllConstIter(labelHashSet, set, iter) forAllConstIters(set, iter)
{ {
isSet[iter.key()] = true; isSet[iter.key()] = true;
} }
@ -359,7 +374,6 @@ int main(int argc, char *argv[])
#include "createNamedMesh.H" #include "createNamedMesh.H"
const word setName = args[1]; const word setName = args[1];
word meshInstance = mesh.pointsInstance(); word meshInstance = mesh.pointsInstance();
@ -378,7 +392,7 @@ int main(int argc, char *argv[])
} }
Info<< "Reading cell set from " << setName << endl << endl; Info<< "Reading cell set from " << setName << nl << endl;
// Create mesh subsetting engine // Create mesh subsetting engine
fvMeshSubset subsetter(mesh); fvMeshSubset subsetter(mesh);
@ -389,11 +403,7 @@ int main(int argc, char *argv[])
{ {
const word patchName = args["patch"]; const word patchName = args["patch"];
exposedPatchIDs = labelList exposedPatchIDs = { mesh.boundaryMesh().findPatchID(patchName) };
(
1,
mesh.boundaryMesh().findPatchID(patchName)
);
if (exposedPatchIDs[0] == -1) if (exposedPatchIDs[0] == -1)
{ {
@ -402,8 +412,8 @@ int main(int argc, char *argv[])
<< exit(FatalError); << exit(FatalError);
} }
Info<< "Adding exposed internal faces to patch " << patchName << endl Info<< "Adding exposed internal faces to patch " << patchName
<< endl; << nl << endl;
} }
else if (args.optionFound("patches")) else if (args.optionFound("patches"))
{ {
@ -412,14 +422,14 @@ int main(int argc, char *argv[])
exposedPatchIDs = mesh.boundaryMesh().patchSet(patchNames).sortedToc(); exposedPatchIDs = mesh.boundaryMesh().patchSet(patchNames).sortedToc();
Info<< "Adding exposed internal faces to nearest of patches " Info<< "Adding exposed internal faces to nearest of patches "
<< patchNames << endl << endl; << patchNames << nl << endl;
} }
else else
{ {
Info<< "Adding exposed internal faces to a patch called" Info<< "Adding exposed internal faces to a patch called"
<< " \"oldInternalFaces\" (created if necessary)" << endl << " \"oldInternalFaces\" (created if necessary)" << endl
<< endl; << endl;
exposedPatchIDs = labelList(1, label(-1)); exposedPatchIDs = { -1 };
} }
@ -431,7 +441,6 @@ int main(int argc, char *argv[])
} }
else else
{ {
// Find per face the nearest patch // Find per face the nearest patch
labelList nearestExposedPatch(nearestPatch(mesh, exposedPatchIDs)); labelList nearestExposedPatch(nearestPatch(mesh, exposedPatchIDs));
@ -454,77 +463,45 @@ int main(int argc, char *argv[])
IOobjectList objects(mesh, runTime.timeName()); IOobjectList objects(mesh, runTime.timeName());
HashTable<wordHashSet> availableFields = objects.classes();
// Read vol fields and subset // Read vol fields and subset
// ~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~
wordList scalarNames(objects.names(volScalarField::typeName)); PtrList<volScalarField> scalarFlds;
PtrList<volScalarField> scalarFlds(scalarNames.size()); subsetFields(subsetter, availableFields, scalarFlds);
subsetVolFields(subsetter, scalarNames, scalarFlds);
wordList vectorNames(objects.names(volVectorField::typeName)); PtrList<volVectorField> vectorFlds;
PtrList<volVectorField> vectorFlds(vectorNames.size()); subsetFields(subsetter, availableFields, vectorFlds);
subsetVolFields(subsetter, vectorNames, vectorFlds);
wordList sphericalTensorNames PtrList<volSphericalTensorField> sphTensorFlds;
( subsetFields(subsetter, availableFields, sphTensorFlds);
objects.names(volSphericalTensorField::typeName)
);
PtrList<volSphericalTensorField> sphericalTensorFlds
(
sphericalTensorNames.size()
);
subsetVolFields(subsetter, sphericalTensorNames, sphericalTensorFlds);
wordList symmTensorNames(objects.names(volSymmTensorField::typeName)); PtrList<volSymmTensorField> symmTensorFlds;
PtrList<volSymmTensorField> symmTensorFlds(symmTensorNames.size()); subsetFields(subsetter, availableFields, symmTensorFlds);
subsetVolFields(subsetter, symmTensorNames, symmTensorFlds);
wordList tensorNames(objects.names(volTensorField::typeName)); PtrList<volTensorField> tensorFlds;
PtrList<volTensorField> tensorFlds(tensorNames.size()); subsetFields(subsetter, availableFields, tensorFlds);
subsetVolFields(subsetter, tensorNames, tensorFlds);
// Read surface fields and subset // Read surface fields and subset
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
wordList surfScalarNames(objects.names(surfaceScalarField::typeName)); PtrList<surfaceScalarField> surfScalarFlds;
PtrList<surfaceScalarField> surfScalarFlds(surfScalarNames.size()); subsetFields(subsetter, availableFields, surfScalarFlds);
subsetSurfaceFields(subsetter, surfScalarNames, surfScalarFlds);
wordList surfVectorNames(objects.names(surfaceVectorField::typeName)); PtrList<surfaceVectorField> surfVectorFlds;
PtrList<surfaceVectorField> surfVectorFlds(surfVectorNames.size()); subsetFields(subsetter, availableFields, surfVectorFlds);
subsetSurfaceFields(subsetter, surfVectorNames, surfVectorFlds);
wordList surfSphericalTensorNames PtrList<surfaceSphericalTensorField> surfSphTensorFlds;
( subsetFields(subsetter, availableFields, surfSphTensorFlds);
objects.names(surfaceSphericalTensorField::typeName)
);
PtrList<surfaceSphericalTensorField> surfSphericalTensorFlds
(
surfSphericalTensorNames.size()
);
subsetSurfaceFields
(
subsetter,
surfSphericalTensorNames,
surfSphericalTensorFlds
);
wordList surfSymmTensorNames PtrList<surfaceSymmTensorField> surfSymmTensorFlds;
( subsetFields(subsetter, availableFields, surfSymmTensorFlds);
objects.names(surfaceSymmTensorField::typeName)
);
PtrList<surfaceSymmTensorField> surfSymmTensorFlds
(
surfSymmTensorNames.size()
);
subsetSurfaceFields(subsetter, surfSymmTensorNames, surfSymmTensorFlds);
wordList surfTensorNames(objects.names(surfaceTensorField::typeName)); PtrList<surfaceTensorField> surfTensorFlds;
PtrList<surfaceTensorField> surfTensorFlds(surfTensorNames.size()); subsetFields(subsetter, availableFields, surfTensorFlds);
subsetSurfaceFields(subsetter, surfTensorNames, surfTensorFlds);
// Read point fields and subset // Read point fields and subset
@ -532,86 +509,39 @@ int main(int argc, char *argv[])
const pointMesh& pMesh = pointMesh::New(mesh); const pointMesh& pMesh = pointMesh::New(mesh);
wordList pointScalarNames(objects.names(pointScalarField::typeName)); PtrList<pointScalarField> pointScalarFlds;
PtrList<pointScalarField> pointScalarFlds(pointScalarNames.size()); subsetPointFields(subsetter, pMesh, availableFields, pointScalarFlds);
subsetPointFields(subsetter, pMesh, pointScalarNames, pointScalarFlds);
wordList pointVectorNames(objects.names(pointVectorField::typeName)); PtrList<pointVectorField> pointVectorFlds;
PtrList<pointVectorField> pointVectorFlds(pointVectorNames.size()); subsetPointFields(subsetter, pMesh, availableFields, pointVectorFlds);
subsetPointFields(subsetter, pMesh, pointVectorNames, pointVectorFlds);
wordList pointSphericalTensorNames PtrList<pointSphericalTensorField> pointSphTensorFlds;
( subsetPointFields(subsetter, pMesh, availableFields, pointSphTensorFlds);
objects.names(pointSphericalTensorField::typeName)
);
PtrList<pointSphericalTensorField> pointSphericalTensorFlds
(
pointSphericalTensorNames.size()
);
subsetPointFields
(
subsetter,
pMesh,
pointSphericalTensorNames,
pointSphericalTensorFlds
);
wordList pointSymmTensorNames PtrList<pointSymmTensorField> pointSymmTensorFlds;
( subsetPointFields(subsetter, pMesh, availableFields, pointSymmTensorFlds);
objects.names(pointSymmTensorField::typeName)
);
PtrList<pointSymmTensorField> pointSymmTensorFlds
(
pointSymmTensorNames.size()
);
subsetPointFields
(
subsetter,
pMesh,
pointSymmTensorNames,
pointSymmTensorFlds
);
wordList pointTensorNames(objects.names(pointTensorField::typeName)); PtrList<pointTensorField> pointTensorFlds;
PtrList<pointTensorField> pointTensorFlds(pointTensorNames.size()); subsetPointFields(subsetter, pMesh, availableFields, pointTensorFlds);
subsetPointFields(subsetter, pMesh, pointTensorNames, pointTensorFlds);
// Read dimensioned fields and subset // Read dimensioned fields and subset
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
typedef volScalarField::Internal dimScalType; PtrList<volScalarField::Internal> scalarDimFlds;
wordList scalarDimNames(objects.names(dimScalType::typeName)); subsetDimensionedFields(subsetter, availableFields, scalarDimFlds);
PtrList<dimScalType> scalarDimFlds(scalarDimNames.size());
subsetDimensionedFields(subsetter, scalarDimNames, scalarDimFlds);
typedef volVectorField::Internal dimVecType; PtrList<volVectorField::Internal> vectorDimFlds;
wordList vectorDimNames(objects.names(dimVecType::typeName)); subsetDimensionedFields(subsetter, availableFields, vectorDimFlds);
PtrList<dimVecType> vectorDimFlds(vectorDimNames.size());
subsetDimensionedFields(subsetter, vectorDimNames, vectorDimFlds);
typedef volSphericalTensorField::Internal dimSphereType; PtrList<volSphericalTensorField::Internal> sphTensorDimFlds;
wordList sphericalTensorDimNames(objects.names(dimSphereType::typeName)); subsetDimensionedFields(subsetter, availableFields, sphTensorDimFlds);
PtrList<dimSphereType> sphericalTensorDimFlds
(
sphericalTensorDimNames.size()
);
subsetDimensionedFields
(
subsetter,
sphericalTensorDimNames,
sphericalTensorDimFlds
);
typedef volSymmTensorField::Internal dimSymmTensorType; PtrList<volSymmTensorField::Internal> symmTensorDimFlds;
wordList symmTensorDimNames(objects.names(dimSymmTensorType::typeName)); subsetDimensionedFields(subsetter, availableFields, symmTensorDimFlds);
PtrList<dimSymmTensorType> symmTensorDimFlds(symmTensorDimNames.size());
subsetDimensionedFields(subsetter, symmTensorDimNames, symmTensorDimFlds);
typedef volTensorField::Internal dimTensorType; PtrList<volTensorField::Internal> tensorDimFlds;
wordList tensorDimNames(objects.names(dimTensorType::typeName)); subsetDimensionedFields(subsetter, availableFields, tensorDimFlds);
PtrList<dimTensorType> tensorDimFlds(tensorDimNames.size());
subsetDimensionedFields(subsetter, tensorDimNames, tensorDimFlds);
// topoSets and subset // topoSets and subset
@ -620,6 +550,7 @@ int main(int argc, char *argv[])
PtrList<cellSet> cellSets; PtrList<cellSet> cellSets;
PtrList<faceSet> faceSets; PtrList<faceSet> faceSets;
PtrList<pointSet> pointSets; PtrList<pointSet> pointSets;
{ {
IOobjectList objects(mesh, mesh.facesInstance(), "polyMesh/sets"); IOobjectList objects(mesh, mesh.facesInstance(), "polyMesh/sets");
objects.remove(currentSet); objects.remove(currentSet);
@ -650,7 +581,6 @@ int main(int argc, char *argv[])
} }
// Write mesh and fields to new time // Write mesh and fields to new time
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -668,123 +598,100 @@ int main(int argc, char *argv[])
subsetter.subMesh().setInstance(runTime.timeName()); subsetter.subMesh().setInstance(runTime.timeName());
} }
Info<< "Writing subsetted mesh and fields to time " << runTime.timeName() Info<< "Writing subsetted mesh and fields to time " << runTime.timeName()
<< endl; << endl;
subsetter.subMesh().write(); subsetter.subMesh().write();
processorMeshes::removeFiles(subsetter.subMesh()); processorMeshes::removeFiles(subsetter.subMesh());
// Subsetting adds 'subset' prefix. Rename field to be like original. // Volume fields
forAll(scalarFlds, i) forAll(scalarFlds, i)
{ {
scalarFlds[i].rename(scalarNames[i]);
scalarFlds[i].write(); scalarFlds[i].write();
} }
forAll(vectorFlds, i) forAll(vectorFlds, i)
{ {
vectorFlds[i].rename(vectorNames[i]);
vectorFlds[i].write(); vectorFlds[i].write();
} }
forAll(sphericalTensorFlds, i) forAll(sphTensorFlds, i)
{ {
sphericalTensorFlds[i].rename(sphericalTensorNames[i]); sphTensorFlds[i].write();
sphericalTensorFlds[i].write();
} }
forAll(symmTensorFlds, i) forAll(symmTensorFlds, i)
{ {
symmTensorFlds[i].rename(symmTensorNames[i]);
symmTensorFlds[i].write(); symmTensorFlds[i].write();
} }
forAll(tensorFlds, i) forAll(tensorFlds, i)
{ {
tensorFlds[i].rename(tensorNames[i]);
tensorFlds[i].write(); tensorFlds[i].write();
} }
// Surface ones. // Surface fields.
forAll(surfScalarFlds, i) forAll(surfScalarFlds, i)
{ {
surfScalarFlds[i].rename(surfScalarNames[i]);
surfScalarFlds[i].write(); surfScalarFlds[i].write();
} }
forAll(surfVectorFlds, i) forAll(surfVectorFlds, i)
{ {
surfVectorFlds[i].rename(surfVectorNames[i]);
surfVectorFlds[i].write(); surfVectorFlds[i].write();
} }
forAll(surfSphericalTensorFlds, i) forAll(surfSphTensorFlds, i)
{ {
surfSphericalTensorFlds[i].rename(surfSphericalTensorNames[i]); surfSphTensorFlds[i].write();
surfSphericalTensorFlds[i].write();
} }
forAll(surfSymmTensorFlds, i) forAll(surfSymmTensorFlds, i)
{ {
surfSymmTensorFlds[i].rename(surfSymmTensorNames[i]);
surfSymmTensorFlds[i].write(); surfSymmTensorFlds[i].write();
} }
forAll(surfTensorNames, i) forAll(surfTensorFlds, i)
{ {
surfTensorFlds[i].rename(surfTensorNames[i]);
surfTensorFlds[i].write(); surfTensorFlds[i].write();
} }
// Point ones // Point fields
forAll(pointScalarFlds, i) forAll(pointScalarFlds, i)
{ {
pointScalarFlds[i].rename(pointScalarNames[i]);
pointScalarFlds[i].write(); pointScalarFlds[i].write();
} }
forAll(pointVectorFlds, i) forAll(pointVectorFlds, i)
{ {
pointVectorFlds[i].rename(pointVectorNames[i]);
pointVectorFlds[i].write(); pointVectorFlds[i].write();
} }
forAll(pointSphericalTensorFlds, i) forAll(pointSphTensorFlds, i)
{ {
pointSphericalTensorFlds[i].rename(pointSphericalTensorNames[i]); pointSphTensorFlds[i].write();
pointSphericalTensorFlds[i].write();
} }
forAll(pointSymmTensorFlds, i) forAll(pointSymmTensorFlds, i)
{ {
pointSymmTensorFlds[i].rename(pointSymmTensorNames[i]);
pointSymmTensorFlds[i].write(); pointSymmTensorFlds[i].write();
} }
forAll(pointTensorNames, i) forAll(pointTensorFlds, i)
{ {
pointTensorFlds[i].rename(pointTensorNames[i]);
pointTensorFlds[i].write(); pointTensorFlds[i].write();
} }
// DimensionedFields // Dimensioned fields
forAll(scalarDimFlds, i) forAll(scalarDimFlds, i)
{ {
scalarDimFlds[i].rename(scalarDimNames[i]);
scalarDimFlds[i].write(); scalarDimFlds[i].write();
} }
forAll(vectorDimFlds, i) forAll(vectorDimFlds, i)
{ {
vectorDimFlds[i].rename(vectorDimNames[i]);
vectorDimFlds[i].write(); vectorDimFlds[i].write();
} }
forAll(sphericalTensorDimFlds, i) forAll(sphTensorDimFlds, i)
{ {
sphericalTensorDimFlds[i].rename(sphericalTensorDimNames[i]); sphTensorDimFlds[i].write();
sphericalTensorDimFlds[i].write();
} }
forAll(symmTensorDimFlds, i) forAll(symmTensorDimFlds, i)
{ {
symmTensorDimFlds[i].rename(symmTensorDimNames[i]);
symmTensorDimFlds[i].write(); symmTensorDimFlds[i].write();
} }
forAll(tensorDimFlds, i) forAll(tensorDimFlds, i)
{ {
tensorDimFlds[i].rename(tensorDimNames[i]);
tensorDimFlds[i].write(); tensorDimFlds[i].write();
} }
Info<< "End\n" << endl; Info<< "End\n" << endl;
return 0; return 0;