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

GIT: Initial commit after latest foundation merge

Browse Source
This commit is contained in:
andy
2016-04-25 11:40:48 +01:00
parent 69ae5a9a78 e5a029c187
commit fd9d801e2d
4003 changed files with 74634 additions and 37783 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
applications/utilities/parallelProcessing/decomposePar/decomposePar.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -422,8 +422,7 @@ int main(int argc, char *argv[])
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("cellDist", dimless, 0),
zeroGradientFvPatchScalarField::typeName
dimensionedScalar("cellDist", dimless, 0)
);
forAll(procIds, celli)
@ -484,16 +483,16 @@ int main(int argc, char *argv[])
// Construct the dimensioned fields
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
PtrList<DimensionedField<scalar, volMesh> > dimScalarFields;
PtrList<DimensionedField<scalar, volMesh>> dimScalarFields;
readFields(mesh, objects, dimScalarFields);
PtrList<DimensionedField<vector, volMesh> > dimVectorFields;
PtrList<DimensionedField<vector, volMesh>> dimVectorFields;
readFields(mesh, objects, dimVectorFields);
PtrList<DimensionedField<sphericalTensor, volMesh> >
PtrList<DimensionedField<sphericalTensor, volMesh>>
dimSphericalTensorFields;
readFields(mesh, objects, dimSphericalTensorFields);
PtrList<DimensionedField<symmTensor, volMesh> > dimSymmTensorFields;
PtrList<DimensionedField<symmTensor, volMesh>> dimSymmTensorFields;
readFields(mesh, objects, dimSymmTensorFields);
PtrList<DimensionedField<tensor, volMesh> > dimTensorFields;
PtrList<DimensionedField<tensor, volMesh>> dimTensorFields;
readFields(mesh, objects, dimTensorFields);
@ -536,64 +535,64 @@ int main(int argc, char *argv[])
);
// Particles
PtrList<Cloud<indexedParticle> > lagrangianPositions
PtrList<Cloud<indexedParticle>> lagrangianPositions
(
cloudDirs.size()
);
// Particles per cell
PtrList< List<SLList<indexedParticle*>*> > cellParticles
PtrList<List<SLList<indexedParticle*>*>> cellParticles
(
cloudDirs.size()
);
PtrList<PtrList<labelIOField> > lagrangianLabelFields
PtrList<PtrList<labelIOField>> lagrangianLabelFields
(
cloudDirs.size()
);
PtrList<PtrList<labelFieldCompactIOField> >
PtrList<PtrList<labelFieldCompactIOField>>
lagrangianLabelFieldFields
(
cloudDirs.size()
);
PtrList<PtrList<scalarIOField> > lagrangianScalarFields
PtrList<PtrList<scalarIOField>> lagrangianScalarFields
(
cloudDirs.size()
);
PtrList<PtrList<scalarFieldCompactIOField> >
PtrList<PtrList<scalarFieldCompactIOField>>
lagrangianScalarFieldFields
(
cloudDirs.size()
);
PtrList<PtrList<vectorIOField> > lagrangianVectorFields
PtrList<PtrList<vectorIOField>> lagrangianVectorFields
(
cloudDirs.size()
);
PtrList<PtrList<vectorFieldCompactIOField> >
PtrList<PtrList<vectorFieldCompactIOField>>
lagrangianVectorFieldFields
(
cloudDirs.size()
);
PtrList<PtrList<sphericalTensorIOField> >
PtrList<PtrList<sphericalTensorIOField>>
lagrangianSphericalTensorFields
(
cloudDirs.size()
);
PtrList<PtrList<sphericalTensorFieldCompactIOField> >
PtrList<PtrList<sphericalTensorFieldCompactIOField>>
lagrangianSphericalTensorFieldFields(cloudDirs.size());
PtrList<PtrList<symmTensorIOField> > lagrangianSymmTensorFields
PtrList<PtrList<symmTensorIOField>> lagrangianSymmTensorFields
(
cloudDirs.size()
);
PtrList<PtrList<symmTensorFieldCompactIOField> >
PtrList<PtrList<symmTensorFieldCompactIOField>>
lagrangianSymmTensorFieldFields
(
cloudDirs.size()
);
PtrList<PtrList<tensorIOField> > lagrangianTensorFields
PtrList<PtrList<tensorIOField>> lagrangianTensorFields
(
cloudDirs.size()
);
PtrList<PtrList<tensorFieldCompactIOField> >
PtrList<PtrList<tensorFieldCompactIOField>>
lagrangianTensorFieldFields
(
cloudDirs.size()

4
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-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -100,7 +100,7 @@ public:
//- Decompose field
template<class Type>
tmp<DimensionedField<Type, volMesh> > decomposeField
tmp<DimensionedField<Type, volMesh>> decomposeField
(
const DimensionedField<Type, volMesh>& field
) const;

6
applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposerDecomposeFields.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
Foam::tmp<Foam::DimensionedField<Type, Foam::volMesh> >
Foam::tmp<Foam::DimensionedField<Type, Foam::volMesh>>
Foam::dimFieldDecomposer::decomposeField
(
const DimensionedField<Type, volMesh>& field
@ -38,7 +38,7 @@ Foam::dimFieldDecomposer::decomposeField
Field<Type> mappedField(field, cellAddressing_);
// Create the field for the processor
return tmp<DimensionedField<Type, volMesh> >
return tmp<DimensionedField<Type, volMesh>>
(
new DimensionedField<Type, volMesh>
(

59
applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -416,29 +416,12 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
label nInterProcPatches = 0;
forAll(curSubPatchIDs, procPatchI)
{
//Info<< "For processor " << procI
// << " have to destination processor "
// << curNeighbourProcessors[procPatchI] << endl;
//
//forAll(curSubPatchIDs[procPatchI], i)
//{
// Info<< " from patch:" << curSubPatchIDs[procPatchI][i]
// << " starting at:" << curSubStarts[procPatchI][i]
// << endl;
//}
nInterProcPatches += curSubPatchIDs[procPatchI].size();
}
//Info<< "For processor " << procI
// << " have " << nInterProcPatches
// << " patches to neighbouring processors" << endl;
List<polyPatch*> procPatches
(
curPatchSizes.size()
+ nInterProcPatches, //curProcessorPatchSizes.size(),
curPatchSizes.size() + nInterProcPatches,
reinterpret_cast<polyPatch*>(0)
);
@ -489,22 +472,12 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
: curProcessorPatchSizes[procPatchI] - subStarts[i]
);
// Info<< "From processor:" << procI << endl
// << " to processor:" << curNeighbourProcessors[procPatchI]
// << endl
// << " via patch:" << subPatchID[i] << endl
// << " start :" << curStart << endl
// << " size :" << size << endl;
if (subPatchID[i] == -1)
{
// From internal faces
procPatches[nPatches] =
new processorPolyPatch
(
word("procBoundary") + Foam::name(procI)
+ "to"
+ Foam::name(curNeighbourProcessors[procPatchI]),
size,
curStart,
nPatches,
@ -521,24 +494,16 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
boundaryMesh()[subPatchID[i]]
);
// From cyclic
const word& referPatch = pcPatch.name();
procPatches[nPatches] =
new processorCyclicPolyPatch
(
word("procBoundary") + Foam::name(procI)
+ "to"
+ Foam::name(curNeighbourProcessors[procPatchI])
+ "through"
+ referPatch,
size,
curStart,
nPatches,
procMesh.boundaryMesh(),
procI,
curNeighbourProcessors[procPatchI],
referPatch,
pcPatch.name(),
pcPatch.transform()
);
}
@ -549,16 +514,6 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
}
}
//forAll(procPatches, patchI)
//{
// Pout<< " " << patchI
// << '\t' << "name:" << procPatches[patchI]->name()
// << '\t' << "type:" << procPatches[patchI]->type()
// << '\t' << "size:" << procPatches[patchI]->size()
// << endl;
//}
// Add boundary patches
procMesh.addPatches(procPatches);
@ -571,7 +526,7 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
// Go through all the zoned points and find out if they
// belong to a zone. If so, add it to the zone as
// necessary
List<DynamicList<label> > zonePoints(pz.size());
List<DynamicList<label>> zonePoints(pz.size());
// Estimate size
forAll(zonePoints, zoneI)
@ -637,8 +592,8 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
// Go through all the zoned face and find out if they
// belong to a zone. If so, add it to the zone as
// necessary
List<DynamicList<label> > zoneFaces(fz.size());
List<DynamicList<bool> > zoneFaceFlips(fz.size());
List<DynamicList<label>> zoneFaces(fz.size());
List<DynamicList<bool>> zoneFaceFlips(fz.size());
// Estimate size
forAll(zoneFaces, zoneI)
@ -731,7 +686,7 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
// Go through all the zoned cells and find out if they
// belong to a zone. If so, add it to the zone as
// necessary
List<DynamicList<label> > zoneCells(cz.size());
List<DynamicList<label>> zoneCells(cz.size());
// Estimate size
forAll(zoneCells, zoneI)

14
applications/utilities/parallelProcessing/decomposePar/domainDecomposition.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -84,7 +84,7 @@ class domainDecomposition
// indices will be incremented by 1 and the decremented as
// necessary to avoid the problem of face number zero having no
// sign.
List<DynamicList<label> > procFaceAddressing_;
List<DynamicList<label>> procFaceAddressing_;
//- Labels of cells for each processor
labelListList procCellAddressing_;
@ -137,17 +137,17 @@ class domainDecomposition
const label ownerProc,
const label nbrProc,
List<Map<label> >&,
List<DynamicList<DynamicList<label> > >&
List<Map<label>>&,
List<DynamicList<DynamicList<label>>>&
) const;
//- Generate sub patch info for processor cyclics
template <class BinaryOp>
template<class BinaryOp>
void processInterCyclics
(
const polyBoundaryMesh& patches,
List<DynamicList<DynamicList<label> > >& interPatchFaces,
List<Map<label> >& procNbrToInterPatch,
List<DynamicList<DynamicList<label>>>& interPatchFaces,
List<Map<label>>& procNbrToInterPatch,
List<labelListList>& subPatchIDs,
List<labelListList>& subPatchStarts,
bool owner,

12
applications/utilities/parallelProcessing/decomposePar/domainDecompositionMesh.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -51,8 +51,8 @@ void Foam::domainDecomposition::addInterProcFace
const label ownerProc,
const label nbrProc,
List<Map<label> >& nbrToInterPatch,
List<DynamicList<DynamicList<label> > >& interPatchFaces
List<Map<label>>& nbrToInterPatch,
List<DynamicList<DynamicList<label>>>& interPatchFaces
) const
{
Map<label>::iterator patchIter = nbrToInterPatch[ownerProc].find(nbrProc);
@ -209,10 +209,10 @@ void Foam::domainDecomposition::decomposeMesh()
// Per processor, from neighbour processor to the inter-processor patch
// that communicates with that neighbour
List<Map<label> > procNbrToInterPatch(nProcs_);
List<Map<label>> procNbrToInterPatch(nProcs_);
// Per processor the faces per inter-processor patch
List<DynamicList<DynamicList<label> > > interPatchFaces(nProcs_);
List<DynamicList<DynamicList<label>>> interPatchFaces(nProcs_);
// Processor boundaries from internal faces
forAll(neighbour, facei)
@ -336,7 +336,7 @@ void Foam::domainDecomposition::decomposeMesh()
sortedOrder(nbrs, order);
DynamicList<DynamicList<label> >& curInterPatchFaces =
DynamicList<DynamicList<label>>& curInterPatchFaces =
interPatchFaces[procI];
forAll(nbrs, i)

8
applications/utilities/parallelProcessing/decomposePar/domainDecompositionTemplates.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -27,12 +27,12 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template <class BinaryOp>
template<class BinaryOp>
void Foam::domainDecomposition::processInterCyclics
(
const polyBoundaryMesh& patches,
List<DynamicList<DynamicList<label> > >& interPatchFaces,
List<Map<label> >& procNbrToInterPatch,
List<DynamicList<DynamicList<label>>>& interPatchFaces,
List<Map<label>>& procNbrToInterPatch,
List<labelListList>& subPatchIDs,
List<labelListList>& subPatchStarts,
bool owner,

4
applications/utilities/parallelProcessing/decomposePar/lagrangianFieldDecomposer.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -97,7 +97,7 @@ Foam::lagrangianFieldDecomposer::lagrangianFieldDecomposer
particleIndices_.setSize(pi);
IOPosition<Cloud<passiveParticle> >(positions_).write();
IOPosition<Cloud<passiveParticle>>(positions_).write();
}

14
applications/utilities/parallelProcessing/decomposePar/lagrangianFieldDecomposer.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -100,8 +100,8 @@ public:
(
const label cloudI,
const IOobjectList& lagrangianObjects,
PtrList<PtrList<IOField<Type> > >& lagrangianFields
// PtrList<IOField<Type> >& lagrangianFields
PtrList<PtrList<IOField<Type>>>& lagrangianFields
// PtrList<IOField<Type>>& lagrangianFields
);
template<class Type>
@ -111,22 +111,22 @@ public:
const IOobjectList& lagrangianObjects,
PtrList
<
PtrList<CompactIOField<Field<Type>, Type> >
PtrList<CompactIOField<Field<Type>, Type>>
>& lagrangianFields
// PtrList<CompactIOField<Field<Type>, Type > >& lagrangianFields
// PtrList<CompactIOField<Field<Type>, Type >>& lagrangianFields
);
//- Decompose volume field
template<class Type>
tmp<IOField<Type> > decomposeField
tmp<IOField<Type>> decomposeField
(
const word& cloudName,
const IOField<Type>& field
) const;
template<class Type>
tmp<CompactIOField<Field<Type>, Type> > decomposeFieldField
tmp<CompactIOField<Field<Type>, Type>> decomposeFieldField
(
const word& cloudName,
const CompactIOField<Field<Type>, Type>& field

22
applications/utilities/parallelProcessing/decomposePar/lagrangianFieldDecomposerDecomposeFields.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -33,7 +33,7 @@ void Foam::lagrangianFieldDecomposer::readFields
(
const label cloudI,
const IOobjectList& lagrangianObjects,
PtrList<PtrList<IOField<Type> > >& lagrangianFields
PtrList<PtrList<IOField<Type>>>& lagrangianFields
)
{
// Search list of objects for lagrangian fields
@ -45,7 +45,7 @@ void Foam::lagrangianFieldDecomposer::readFields
lagrangianFields.set
(
cloudI,
new PtrList<IOField<Type> >
new PtrList<IOField<Type>>
(
lagrangianTypeObjects.size()
)
@ -68,13 +68,13 @@ void Foam::lagrangianFieldDecomposer::readFieldFields
(
const label cloudI,
const IOobjectList& lagrangianObjects,
PtrList<PtrList<CompactIOField<Field<Type>, Type> > >& lagrangianFields
PtrList<PtrList<CompactIOField<Field<Type>, Type>>>& lagrangianFields
)
{
// Search list of objects for lagrangian fields
IOobjectList lagrangianTypeObjectsA
(
lagrangianObjects.lookupClass(IOField<Field<Type> >::typeName)
lagrangianObjects.lookupClass(IOField<Field<Type>>::typeName)
);
IOobjectList lagrangianTypeObjectsB
@ -89,7 +89,7 @@ void Foam::lagrangianFieldDecomposer::readFieldFields
lagrangianFields.set
(
cloudI,
new PtrList<CompactIOField<Field<Type>, Type> >
new PtrList<CompactIOField<Field<Type>, Type>>
(
lagrangianTypeObjectsA.size() + lagrangianTypeObjectsB.size()
)
@ -118,7 +118,7 @@ void Foam::lagrangianFieldDecomposer::readFieldFields
template<class Type>
Foam::tmp<Foam::IOField<Type> >
Foam::tmp<Foam::IOField<Type>>
Foam::lagrangianFieldDecomposer::decomposeField
(
const word& cloudName,
@ -129,7 +129,7 @@ Foam::lagrangianFieldDecomposer::decomposeField
Field<Type> procField(field, particleIndices_);
// Create the field for the processor
return tmp<IOField<Type> >
return tmp<IOField<Type>>
(
new IOField<Type>
(
@ -150,7 +150,7 @@ Foam::lagrangianFieldDecomposer::decomposeField
template<class Type>
Foam::tmp<Foam::CompactIOField<Foam::Field<Type>, Type> >
Foam::tmp<Foam::CompactIOField<Foam::Field<Type>, Type>>
Foam::lagrangianFieldDecomposer::decomposeFieldField
(
const word& cloudName,
@ -158,10 +158,10 @@ Foam::lagrangianFieldDecomposer::decomposeFieldField
) const
{
// Create and map the internal field values
Field<Field<Type> > procField(field, particleIndices_);
Field<Field<Type>> procField(field, particleIndices_);
// Create the field for the processor
return tmp<CompactIOField<Field<Type>, Type> >
return tmp<CompactIOField<Field<Type>, Type>>
(
new CompactIOField<Field<Type>, Type>
(

4
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-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -154,7 +154,7 @@ public:
//- Decompose point field
template<class Type>
tmp<GeometricField<Type, pointPatchField, pointMesh> >
tmp<GeometricField<Type, pointPatchField, pointMesh>>
decomposeField
(
const GeometricField<Type, pointPatchField, pointMesh>&

8
applications/utilities/parallelProcessing/decomposePar/pointFieldDecomposerDecomposeFields.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -29,7 +29,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
Foam::tmp<Foam::GeometricField<Type, Foam::pointPatchField, Foam::pointMesh> >
Foam::tmp<Foam::GeometricField<Type, Foam::pointPatchField, Foam::pointMesh>>
Foam::pointFieldDecomposer::decomposeField
(
const GeometricField<Type, pointPatchField, pointMesh>& field
@ -39,7 +39,7 @@ Foam::pointFieldDecomposer::decomposeField
Field<Type> internalField(field.internalField(), pointAddressing_);
// Create a list of pointers for the patchFields
PtrList<pointPatchField<Type> > patchFields(boundaryAddressing_.size());
PtrList<pointPatchField<Type>> patchFields(boundaryAddressing_.size());
// Create and map the patch field values
forAll(boundaryAddressing_, patchi)
@ -73,7 +73,7 @@ Foam::pointFieldDecomposer::decomposeField
}
// Create the field for the processor
return tmp<GeometricField<Type, pointPatchField, pointMesh> >
return tmp<GeometricField<Type, pointPatchField, pointMesh>>
(
new GeometricField<Type, pointPatchField, pointMesh>
(