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

Merge branch 'master' of /home/dm4/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
Sergio Ferraris
2013-09-12 17:40:23 +01:00
parent c7d1a4b023 0e170be388
commit 5eb6320a74
53 changed files with 1059 additions and 500 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
applications/solvers/combustion/coldEngineFoam/coldEngineFoam.C
View File

@ -48,6 +48,7 @@ int main(int argc, char *argv[])
#include "createEngineMesh.H"
#include "createFields.H"
#include "createFvOptions.H"
#include "createRhoUf.H"
#include "initContinuityErrs.H"
#include "readEngineTimeControls.H"
#include "compressibleCourantNo.H"

1
applications/solvers/combustion/engineFoam/engineFoam.C
View File

@ -72,6 +72,7 @@ int main(int argc, char *argv[])
#include "readCombustionProperties.H"
#include "createFields.H"
#include "createFvOptions.H"
#include "createRhoUf.H"
#include "initContinuityErrs.H"
#include "readEngineTimeControls.H"
#include "compressibleCourantNo.H"

17
applications/solvers/combustion/engineFoam/pEqn.H
View File

@ -15,12 +15,12 @@ if (pimple.transonic())
*(
(
(fvc::interpolate(rho*HbyA) & mesh.Sf())
//***HGW + rhorAUf*fvc::ddtCorr(rho, U, phi)
+ rhorAUf*fvc::ddtCorr(rho, U, rhoUf)
)/fvc::interpolate(rho)
- fvc::meshPhi(rho, U)
)
);
fvc::makeRelative(phid, psi, U);
fvOptions.makeRelative(fvc::interpolate(psi), phid);
while (pimple.correctNonOrthogonal())
@ -51,11 +51,11 @@ else
"phiHbyA",
(
(fvc::interpolate(rho*HbyA) & mesh.Sf())
//***HGW + rhorAUf*fvc::ddtCorr(rho, U, phi)
+ rhorAUf*fvc::ddtCorr(rho, U, rhoUf)
)
- fvc::interpolate(rho)*fvc::meshPhi(rho, U)
);
fvc::makeRelative(phiHbyA, rho, U);
fvOptions.makeRelative(fvc::interpolate(rho), phiHbyA);
while (pimple.correctNonOrthogonal())
@ -88,6 +88,15 @@ U.correctBoundaryConditions();
fvOptions.correct(U);
K = 0.5*magSqr(U);
{
rhoUf = fvc::interpolate(rho*U);
surfaceVectorField n(mesh.Sf()/mesh.magSf());
rhoUf +=
mesh.Sf()
*(fvc::absolute(phi, rho, U) - (mesh.Sf() & rhoUf))
/sqr(mesh.magSf());
}
if (thermo.dpdt())
{
dpdt = fvc::ddt(p) - fvc::div(fvc::meshPhi(rho, U), p);

15
applications/solvers/compressible/rhoPimpleFoam/rhoPimpleDyMFoam/pEqn.H
View File

@ -22,10 +22,11 @@ if (pimple.transonic())
fvc::interpolate(psi)
*(
(fvc::interpolate(rho*HbyA) & mesh.Sf())
+ rhorAUf*fvc::ddtCorr(rho, U, phiAbs)
+ rhorAUf*fvc::ddtCorr(rho, U, rhoUf)
)/fvc::interpolate(rho)
);
fvc::makeRelative(phid, psi, U);
fvOptions.makeRelative(fvc::interpolate(psi), phid);
while (pimple.correctNonOrthogonal())
@ -55,9 +56,10 @@ else
(
"phiHbyA",
(fvc::interpolate(rho*HbyA) & mesh.Sf())
+ rhorAUf*fvc::ddtCorr(rho, U, phiAbs)
+ rhorAUf*fvc::ddtCorr(rho, U, rhoUf)
);
fvc::makeRelative(phiHbyA, rho, U);
fvOptions.makeRelative(fvc::interpolate(rho), phiHbyA);
while (pimple.correctNonOrthogonal())
@ -102,6 +104,15 @@ U.correctBoundaryConditions();
fvOptions.correct(U);
K = 0.5*magSqr(U);
{
rhoUf = fvc::interpolate(rho*U);
surfaceVectorField n(mesh.Sf()/mesh.magSf());
rhoUf +=
mesh.Sf()
*(fvc::absolute(phi, rho, U) - (mesh.Sf() & rhoUf))
/sqr(mesh.magSf());
}
if (thermo.dpdt())
{
dpdt = fvc::ddt(p);

25
applications/solvers/compressible/rhoPimpleFoam/rhoPimpleDyMFoam/rhoPimpleDyMFoam.C
View File

@ -56,13 +56,10 @@ int main(int argc, char *argv[])
#include "createFields.H"
#include "createFvOptions.H"
#include "createPcorrTypes.H"
#include "createRhoUf.H"
#include "CourantNo.H"
#include "setInitialDeltaT.H"
// Create old-time absolute flux for ddtCorr
surfaceScalarField phiAbs("phiAbs", phi);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
@ -72,12 +69,6 @@ int main(int argc, char *argv[])
#include "readControls.H"
#include "compressibleCourantNo.H"
// Make the fluxes absolute before mesh-motion
fvc::makeAbsolute(phi, rho, U);
// Update absolute flux for ddtCorr
phiAbs = phi;
#include "setDeltaT.H"
runTime++;
@ -85,21 +76,27 @@ int main(int argc, char *argv[])
Info<< "Time = " << runTime.timeName() << nl << endl;
{
// Store momentum to set rhoUf for introduced faces.
volVectorField rhoU("rhoU", rho*U);
// Store divrhoU from the previous time-step/mesh for the correctPhi
volScalarField divrhoU(fvc::div(phi));
volScalarField divrhoU(fvc::div(fvc::absolute(phi, rho, U)));
// Do any mesh changes
mesh.update();
if (mesh.changing() && correctPhi)
{
// Calculate absolute flux from the mapped surface velocity
phi = mesh.Sf() & rhoUf;
#include "correctPhi.H"
// Make the fluxes relative to the mesh-motion
fvc::makeRelative(phi, rho, U);
}
}
// Make the fluxes relative to the mesh-motion
fvc::makeRelative(phi, rho, U);
if (mesh.changing() && checkMeshCourantNo)
{
#include "meshCourantNo.H"

14
applications/solvers/compressible/sonicFoam/sonicDyMFoam/pEqn.H
View File

@ -13,12 +13,13 @@ surfaceScalarField phid
*(
(
(fvc::interpolate(rho*HbyA) & mesh.Sf())
//***HGW + rhorAUf*fvc::ddtCorr(rho, U, phi)
+ rhorAUf*fvc::ddtCorr(rho, U, rhoUf)
)/fvc::interpolate(rho)
- fvc::meshPhi(rho, U)
)
);
fvc::makeRelative(phid, psi, U);
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
@ -37,3 +38,12 @@ for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
U = HbyA - rAU*fvc::grad(p);
U.correctBoundaryConditions();
{
rhoUf = fvc::interpolate(rho*U);
surfaceVectorField n(mesh.Sf()/mesh.magSf());
rhoUf +=
mesh.Sf()
*(fvc::absolute(phi, rho, U) - (mesh.Sf() & rhoUf))
/sqr(mesh.magSf());
}

6
applications/solvers/compressible/sonicFoam/sonicDyMFoam/sonicDyMFoam.C
View File

@ -64,12 +64,6 @@ int main(int argc, char *argv[])
mesh.movePoints(motionPtr->newPoints());
// Calculate absolute flux from the mapped surface velocity
phi = mesh.Sf() & rhoUf;
// Make the flux relative to the mesh motion
fvc::makeRelative(phi, rho, U);
#include "rhoEqn.H"
// --- Pressure-velocity PIMPLE corrector loop

17
applications/solvers/lagrangian/sprayFoam/sprayEngineFoam/pEqn.H
View File

@ -15,12 +15,12 @@ if (pimple.transonic())
*(
(
(fvc::interpolate(rho*HbyA) & mesh.Sf())
//***HGW + rhorAUf*fvc::ddtCorr(rho, U, phi)
+ rhorAUf*fvc::ddtCorr(rho, U, rhoUf)
)/fvc::interpolate(rho)
- fvc::meshPhi(rho, U)
)
);
fvc::makeRelative(phid, psi, U);
fvOptions.makeRelative(fvc::interpolate(psi), phid);
while (pimple.correctNonOrthogonal())
@ -52,11 +52,11 @@ else
"phiHbyA",
(
(fvc::interpolate(HbyA) & mesh.Sf())
//***HGW + rhorAUf*fvc::ddtCorr(rho, U, phi)
+ rhorAUf*fvc::ddtCorr(rho, U, rhoUf)
)
- fvc::interpolate(rho)*fvc::meshPhi(rho, U)
);
fvc::makeRelative(phiHbyA, rho, U);
fvOptions.makeRelative(fvc::interpolate(rho), phiHbyA);
while (pimple.correctNonOrthogonal())
@ -90,6 +90,15 @@ U.correctBoundaryConditions();
fvOptions.correct(U);
K = 0.5*magSqr(U);
{
rhoUf = fvc::interpolate(rho*U);
surfaceVectorField n(mesh.Sf()/mesh.magSf());
rhoUf +=
mesh.Sf()
*(fvc::absolute(phi, rho, U) - (mesh.Sf() & rhoUf))
/sqr(mesh.magSf());
}
if (thermo.dpdt())
{
dpdt = fvc::ddt(p) - fvc::div(fvc::meshPhi(rho, U), p);

1
applications/solvers/lagrangian/sprayFoam/sprayEngineFoam/sprayEngineFoam.C
View File

@ -52,6 +52,7 @@ int main(int argc, char *argv[])
#include "readGravitationalAcceleration.H"
#include "createFields.H"
#include "createFvOptions.H"
#include "createRhoUf.H"
#include "createClouds.H"
#include "createRadiationModel.H"
#include "initContinuityErrs.H"

12
applications/solvers/multiphase/interFoam/alphaEqnSubCycle.H
View File

@ -3,7 +3,17 @@
if (nAlphaSubCycles > 1)
{
dimensionedScalar totalDeltaT = runTime.deltaT();
surfaceScalarField rhoPhiSum(0.0*rhoPhi);
surfaceScalarField rhoPhiSum
(
IOobject
(
"rhoPhiSum",
runTime.timeName(),
mesh
),
mesh,
dimensionedScalar("0", dimDensity, 0)
);
for
(

2
applications/solvers/multiphase/interFoam/interDyMFoam/interDyMFoam.C
View File

@ -100,6 +100,8 @@ int main(int argc, char *argv[])
// Make the flux relative to the mesh motion
fvc::makeRelative(phi, U);
interface.correct();
}
if (mesh.changing() && checkMeshCourantNo)

2
applications/solvers/multiphase/multiphaseEulerFoam/multiphaseEulerFoam.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

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_;

7
src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
View File

@ -27,6 +27,7 @@ License
#include "linePointRef.H"
#include "OFstream.H"
#include "ListOps.H"
#include "memInfo.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -2383,12 +2384,14 @@ Foam::indexedOctree<Type>::indexedOctree
contents_(0),
nodeTypes_(0)
{
int oldMemSize = 0;
if (debug)
{
Pout<< "indexedOctree<Type>::indexedOctree:" << nl
<< " shapes:" << shapes.size() << nl
<< " bb:" << bb << nl
<< endl;
oldMemSize = memInfo().size();
}
if (shapes.size() == 0)
@ -2503,6 +2506,9 @@ Foam::indexedOctree<Type>::indexedOctree
nEntries += contents_[i].size();
}
label memSize = memInfo().size();
Pout<< "indexedOctree<Type>::indexedOctree"
<< " : finished construction of tree of:" << shapes.typeName
<< nl
@ -2515,6 +2521,7 @@ Foam::indexedOctree<Type>::indexedOctree
<< scalar(nEntries)/contents.size() << nl
<< " per shape (duplicity):"
<< scalar(nEntries)/shapes.size() << nl
<< " total memory:" << memSize-oldMemSize
<< endl;
}
}

56
src/OpenFOAM/fields/Fields/Field/Field.C
View File

@ -124,6 +124,34 @@ Foam::Field<Type>::Field
}
template<class Type>
Foam::Field<Type>::Field
(
const UList<Type>& mapF,
const FieldMapper& mapper,
const Type& defaultValue
)
:
List<Type>(mapper.size(), defaultValue)
{
map(mapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field
(
const UList<Type>& mapF,
const FieldMapper& mapper,
const UList<Type>& defaultValues
)
:
List<Type>(defaultValues)
{
map(mapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field
(
@ -137,6 +165,34 @@ Foam::Field<Type>::Field
}
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type> >& tmapF,
const FieldMapper& mapper,
const Type& defaultValue
)
:
List<Type>(mapper.size(), defaultValue)
{
map(tmapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type> >& tmapF,
const FieldMapper& mapper,
const UList<Type>& defaultValues
)
:
List<Type>(defaultValues)
{
map(tmapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field(const Field<Type>& f)
:

36
src/OpenFOAM/fields/Fields/Field/Field.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
@ -160,6 +160,22 @@ public:
const FieldMapper& map
);
//- Construct by mapping from the given field
Field
(
const UList<Type>& mapF,
const FieldMapper& map,
const Type& defaultValue
);
//- Construct by mapping from the given field
Field
(
const UList<Type>& mapF,
const FieldMapper& map,
const UList<Type>& defaultValues
);
//- Construct by mapping from the given tmp field
Field
(
@ -167,6 +183,24 @@ public:
const FieldMapper& map
);
//- Construct by mapping from the given tmp field. Supplied uniform
// value for unmapped items
Field
(
const tmp<Field<Type> >& tmapF,
const FieldMapper& map,
const Type& defaultValue
);
//- Construct by mapping from the given tmp field. Supplied values
// for unmapped items
Field
(
const tmp<Field<Type> >& tmapF,
const FieldMapper& map,
const UList<Type>& defaultValues
);
//- Construct as copy
Field(const Field<Type>&);

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 * * * * * * * * * * * * * //

22
src/finiteVolume/fields/fvPatchFields/basic/directionMixed/directionMixedFvPatchField.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
@ -55,7 +55,25 @@ Foam::directionMixedFvPatchField<Type>::directionMixedFvPatchField
refValue_(ptf.refValue_, mapper),
refGrad_(ptf.refGrad_, mapper),
valueFraction_(ptf.valueFraction_, mapper)
{}
{
if (mapper.hasUnmapped())
{
WarningIn
(
"directionMixedFvPatchField<Type>::directionMixedFvPatchField\n"
"(\n"
" const directionMixedFvPatchField<Type>&,\n"
" const fvPatch&,\n"
" const DimensionedField<Type, volMesh>&,\n"
" const fvPatchFieldMapper&\n"
")\n"
) << "On field " << iF.name() << " patch " << p.name()
<< " patchField " << this->type()
<< " : mapper does not map all values." << nl
<< " To avoid this warning fully specify the mapping in derived"
<< " patch fields." << endl;
}
}
template<class Type>

22
src/finiteVolume/fields/fvPatchFields/basic/fixedGradient/fixedGradientFvPatchField.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
@ -56,7 +56,25 @@ fixedGradientFvPatchField<Type>::fixedGradientFvPatchField
:
fvPatchField<Type>(ptf, p, iF, mapper),
gradient_(ptf.gradient_, mapper)
{}
{
if (mapper.hasUnmapped())
{
WarningIn
(
"fixedGradientFvPatchField<Type>::fixedGradientFvPatchField\n"
"(\n"
" const fixedGradientFvPatchField<Type>&,\n"
" const fvPatch&,\n"
" const DimensionedField<Type, volMesh>&,\n"
" const fvPatchFieldMapper&\n"
")\n"
) << "On field " << iF.name() << " patch " << p.name()
<< " patchField " << this->type()
<< " : mapper does not map all values." << nl
<< " To avoid this warning fully specify the mapping in derived"
<< " patch fields." << endl;
}
}
template<class Type>

22
src/finiteVolume/fields/fvPatchFields/basic/fixedValue/fixedValueFvPatchField.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
@ -65,7 +65,25 @@ fixedValueFvPatchField<Type>::fixedValueFvPatchField
)
:
fvPatchField<Type>(ptf, p, iF, mapper)
{}
{
if (mapper.hasUnmapped())
{
WarningIn
(
"fixedValueFvPatchField<Type>::fixedValueFvPatchField\n"
"(\n"
" const fixedGradientFvPatchField<Type>&,\n"
" const fvPatch&,\n"
" const DimensionedField<Type, volMesh>&,\n"
" const fvPatchFieldMapper&\n"
")\n"
) << "On field " << iF.name() << " patch " << p.name()
<< " patchField " << this->type()
<< " : mapper does not map all values." << nl
<< " To avoid this warning fully specify the mapping in derived"
<< " patch fields." << endl;
}
}
template<class Type>

22
src/finiteVolume/fields/fvPatchFields/basic/mixed/mixedFvPatchField.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
@ -59,7 +59,25 @@ mixedFvPatchField<Type>::mixedFvPatchField
refValue_(ptf.refValue_, mapper),
refGrad_(ptf.refGrad_, mapper),
valueFraction_(ptf.valueFraction_, mapper)
{}
{
if (mapper.hasUnmapped())
{
WarningIn
(
"mixedFvPatchField<Type>::mixedFvPatchField\n"
"(\n"
" const mixedFvPatchField<Type>&,\n"
" const fvPatch&,\n"
" const DimensionedField<Type, volMesh>&,\n"
" const fvPatchFieldMapper&\n"
")\n"
) << "On field " << iF.name() << " patch " << p.name()
<< " patchField " << this->type()
<< " : mapper does not map all values." << nl
<< " To avoid this warning fully specify the mapping in derived"
<< " patch fields." << endl;
}
}
template<class Type>

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

@ -53,12 +53,17 @@ Foam::fixedFluxPressureFvPatchScalarField::fixedFluxPressureFvPatchScalarField
fixedGradientFvPatchScalarField(p, iF),
curTimeIndex_(-1)
{
// Map value. Set unmapped values and overwrite with mapped ptf
fvPatchField<scalar>::operator=(patchInternalField());
map(ptf, mapper);
patchType() = ptf.patchType();
// Map gradient. Set unmapped values and overwrite with mapped ptf
gradient() = 0.0;
gradient().map(ptf.gradient(), mapper);
// Evaluate the value field from the gradient if the internal field is valid
if (&iF && iF.size())
{
evaluate();
}
}

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
// ************************************************************************* //

58
src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.C
View File

@ -47,6 +47,23 @@ Foam::fvPatchField<Type>::fvPatchField
{}
template<class Type>
Foam::fvPatchField<Type>::fvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const word& patchType
)
:
Field<Type>(p.size()),
patch_(p),
internalField_(iF),
updated_(false),
manipulatedMatrix_(false),
patchType_(patchType)
{}
template<class Type>
Foam::fvPatchField<Type>::fvPatchField
(
@ -73,7 +90,7 @@ Foam::fvPatchField<Type>::fvPatchField
const fvPatchFieldMapper& mapper
)
:
Field<Type>(ptf, mapper),
Field<Type>(p.size()),
patch_(p),
internalField_(iF),
updated_(false),
@ -83,44 +100,9 @@ Foam::fvPatchField<Type>::fvPatchField
// For unmapped faces set to internal field value (zero-gradient)
if (&iF && iF.size())
{
Field<Type>& f = *this;
if
(
mapper.direct()
&& &mapper.directAddressing()
&& mapper.directAddressing().size()
)
{
Field<Type> pif(this->patchInternalField());
const labelList& mapAddressing = mapper.directAddressing();
forAll(mapAddressing, i)
{
if (mapAddressing[i] < 0)
{
f[i] = pif[i];
}
}
}
else if (!mapper.direct() && mapper.addressing().size())
{
Field<Type> pif(this->patchInternalField());
const labelListList& mapAddressing = mapper.addressing();
forAll(mapAddressing, i)
{
const labelList& localAddrs = mapAddressing[i];
if (!localAddrs.size())
{
f[i] = pif[i];
}
}
}
fvPatchField<Type>::operator=(this->patchInternalField());
}
this->map(ptf, mapper);
}

8
src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.H
View File

@ -166,6 +166,14 @@ public:
const DimensionedField<Type, volMesh>&
);
//- Construct from patch and internal field and patch type
fvPatchField
(
const fvPatch&,
const DimensionedField<Type, volMesh>&,
const word& patchType
);
//- Construct from patch and internal field and patch field
fvPatchField
(

4
src/finiteVolume/finiteVolume/fvc/fvcMeshPhi.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -174,7 +174,7 @@ Foam::tmp<Foam::surfaceScalarField> Foam::fvc::absolute
{
if (tphi().mesh().moving())
{
return tphi + fvc::meshPhi(rho, U);
return tphi + fvc::interpolate(rho)*fvc::meshPhi(rho, U);
}
else
{

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();

26
src/postProcessing/functionObjects/IO/controlDict
View File

@ -86,34 +86,36 @@ functions
dumpObjects
{
// Forcibly write registered objects. E.g. fields that have been
// created with NO_WRITE.
// Forcibly write registered objects
type writeRegisteredObject;
// Where to load it from
functionObjectLibs ("libIOFunctionObjects.so");
// Execute upon outputTime:
// timeStep
// outputTime
// When to write:
// timeStep (with optional outputInterval)
// outputTime (with optional outputInterval)
// adjustableTime
// runTime
// clockTime
// cpuTime
outputControl outputTime;
// Is the object written by this function Object alone
exclusiveWriting true;
// Write every writeInterval (only valid for timeStemp, outputTime)
outputInterval 1;
// Interval of time (sec) to write down(
writeInterval 10.5 //(adjustableTime, runTime, clockTime, cpuTime)
// Write as normal every writeInterval'th outputTime.
outputInterval 1; // (timeStep, outputTime)
// Interval of time (valid for adjustableTime, runTime, clockTime,
// cpuTime)
writeInterval 10.5;
// Objects to write
objectNames ();
// Is the object written by this function Object alone
// (default is false)
//exclusiveWriting true;
}
}

2
src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObject.C
View File

@ -46,7 +46,7 @@ Foam::writeRegisteredObject::writeRegisteredObject
)
:
name_(name),
exclusiveWriting_(true),
exclusiveWriting_(false),
obr_(obr),
objectNames_()
{

1
src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayerI.H
View File

@ -26,6 +26,7 @@ License
#include "thermoSingleLayer.H"
#include "heatTransferModel.H"
#include "filmRadiationModel.H"
#include "phaseChangeModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

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;
}