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:
andy
2013-03-26 12:30:28 +00:00
parent 09ee234255 dd017458db
commit adc90617af
61 changed files with 1134 additions and 858 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
applications/solvers/combustion/reactingFoam/rhoReactingFoam/pEqn.H
View File

@ -27,7 +27,7 @@
fvScalarMatrix pDDtEqn
(
fvc::ddt(rho) + fvc::div(phiHbyA)
+ correction(fvm::ddt(psi, p) + fvm::div(phid, p))
+ correction(psi*fvm::ddt(p) + fvm::div(phid, p))
);
while (pimple.correctNonOrthogonal())

2
applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/correctPhi.H
View File

@ -68,4 +68,6 @@
}
}
phi.oldTime() = phi;
#include "continuityErrs.H"

7
applications/solvers/multiphase/compressibleInterFoam/TEqn.H
View File

@ -1,11 +1,11 @@
{
solve
fvScalarMatrix TEqn
(
fvm::ddt(rho, T)
+ fvm::div(rhoPhi, T)
- fvm::laplacian(twoPhaseProperties.alphaEff(turbulence->mut()), T)
+ (
p*fvc::div(phi)
fvc::div(fvc::absolute(phi, U), p)
+ fvc::ddt(rho, K) + fvc::div(rhoPhi, K)
)
*(
@ -14,5 +14,8 @@
)
);
TEqn.relax();
TEqn.solve();
twoPhaseProperties.correct();
}

6
applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/correctPhi.H
View File

@ -56,6 +56,8 @@
phi -= pcorrEqn.flux();
}
}
#include "continuityErrs.H"
}
phi.oldTime() = phi;
#include "continuityErrs.H"

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

@ -104,8 +104,6 @@ int main(int argc, char *argv[])
}
}
rho = alpha1*rho1 + alpha2*rho2;
runTime.write();
Info<< "ExecutionTime = "

17
applications/solvers/multiphase/compressibleInterFoam/createFields.H
View File

@ -38,9 +38,9 @@
volScalarField& p = twoPhaseProperties.p();
volScalarField& T = twoPhaseProperties.T();
const volScalarField& rho1 = twoPhaseProperties.thermo1().rho();
volScalarField& rho1 = twoPhaseProperties.thermo1().rho();
const volScalarField& psi1 = twoPhaseProperties.thermo1().psi();
const volScalarField& rho2 = twoPhaseProperties.thermo2().rho();
volScalarField& rho2 = twoPhaseProperties.thermo2().rho();
const volScalarField& psi2 = twoPhaseProperties.thermo2().psi();
volScalarField rho
@ -93,18 +93,5 @@
compressible::turbulenceModel::New(rho, U, rhoPhi, twoPhaseProperties)
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));

55
applications/solvers/multiphase/compressibleInterFoam/pEqn.H
View File

@ -26,28 +26,44 @@
tmp<fvScalarMatrix> p_rghEqnComp1;
tmp<fvScalarMatrix> p_rghEqnComp2;
//if (transonic)
//{
//}
//else
if (pimple.transonic())
{
surfaceScalarField phid1("phid1", fvc::interpolate(psi1)*phi);
surfaceScalarField phid2("phid2", fvc::interpolate(psi2)*phi);
p_rghEqnComp1 =
fvc::ddt(rho1) + fvc::div(phi, rho1) - fvc::Sp(fvc::div(phi), rho1)
+ correction
(
psi1*fvm::ddt(p_rgh)
+ fvm::div(phid1, p_rgh) - fvm::Sp(fvc::div(phid1), p_rgh)
);
deleteDemandDrivenData(p_rghEqnComp1().faceFluxCorrectionPtr());
p_rghEqnComp1().relax();
p_rghEqnComp2 =
fvc::ddt(rho2) + fvc::div(phi, rho2) - fvc::Sp(fvc::div(phi), rho2)
+ correction
(
psi2*fvm::ddt(p_rgh)
+ fvm::div(phid2, p_rgh) - fvm::Sp(fvc::div(phid2), p_rgh)
);
deleteDemandDrivenData(p_rghEqnComp2().faceFluxCorrectionPtr());
p_rghEqnComp2().relax();
}
else
{
p_rghEqnComp1 =
fvc::ddt(rho1) + psi1*correction(fvm::ddt(p_rgh))
+ fvc::div(phid1, p_rgh)
- fvc::Sp(fvc::div(phid1), p_rgh);
+ fvc::div(phi, rho1) - fvc::Sp(fvc::div(phi), rho1);
p_rghEqnComp2 =
fvc::ddt(rho2) + psi2*correction(fvm::ddt(p_rgh))
+ fvc::div(phid2, p_rgh)
- fvc::Sp(fvc::div(phid2), p_rgh);
+ fvc::div(phi, rho2) - fvc::Sp(fvc::div(phi), rho2);
}
// Thermodynamic density needs to be updated by psi*d(p) after the
// pressure solution - done in 2 parts. Part 1:
//twoPhaseProperties.rho() -= psi*p_rgh;
// Cache p_rgh prior to solve for density update
volScalarField p_rgh_0(p_rgh);
while (pimple.correctNonOrthogonal())
{
@ -69,8 +85,8 @@
if (pimple.finalNonOrthogonalIter())
{
// Second part of thermodynamic density update
//twoPhaseProperties.rho() += psi*p_rgh;
//p = max(p_rgh + (alpha1*rho1 + alpha2*rho2)*gh, pMin);
//p_rgh = p - (alpha1*rho1 + alpha2*rho2)*gh;
dgdt =
(
@ -88,15 +104,14 @@
p = max(p_rgh + (alpha1*rho1 + alpha2*rho2)*gh, pMin);
// twoPhaseProperties.correct();
// Update densities from change in p_rgh
rho1 += psi1*(p_rgh - p_rgh_0);
rho2 += psi2*(p_rgh - p_rgh_0);
Info<< "max(U) " << max(mag(U)).value() << endl;
Info<< "min(p_rgh) " << min(p_rgh).value() << endl;
rho = alpha1*rho1 + alpha2*rho2;
K = 0.5*magSqr(U);
if (twoPhaseProperties.dpdt())
{
dpdt = fvc::ddt(p);
}
Info<< "max(U) " << max(mag(U)).value() << endl;
Info<< "min(p_rgh) " << min(p_rgh).value() << endl;
}

10
applications/solvers/multiphase/compressibleInterFoam/twoPhaseMixtureThermo/twoPhaseMixtureThermo.H
View File

@ -94,6 +94,16 @@ public:
return thermo2_();
}
rhoThermo& thermo1()
{
return thermo1_();
}
rhoThermo& thermo2()
{
return thermo2_();
}
//- Update properties
virtual void correct();

4
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/createFields.H
View File

@ -62,10 +62,10 @@
volScalarField& p = thermo1.p();
volScalarField rho1("rho" + phase1Name, thermo1.rho());
volScalarField& rho1 = thermo1.rho();
const volScalarField& psi1 = thermo1.psi();
volScalarField rho2("rho" + phase2Name, thermo2.rho());
volScalarField& rho2 = thermo2.rho();
const volScalarField& psi2 = thermo2.psi();
volVectorField U

48
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/pEqn.H
View File

@ -1,7 +1,4 @@
{
rho1 = thermo1.rho();
rho2 = thermo2.rho();
surfaceScalarField alpha1f(fvc::interpolate(alpha1));
surfaceScalarField alpha2f(scalar(1) - alpha1f);
@ -91,10 +88,7 @@
tmp<fvScalarMatrix> pEqnComp1;
tmp<fvScalarMatrix> pEqnComp2;
//if (transonic)
//{
//}
//else
if (pimple.transonic())
{
surfaceScalarField phid1
(
@ -107,17 +101,42 @@
fvc::interpolate(psi2)*phi2
);
pEqnComp1 =
fvc::ddt(rho1)
+ fvc::div(phi1, rho1) - fvc::Sp(fvc::div(phi1), rho1)
+ correction
(
psi1*fvm::ddt(p)
+ fvm::div(phid1, p) - fvm::Sp(fvc::div(phid1), p)
);
deleteDemandDrivenData(pEqnComp1().faceFluxCorrectionPtr());
pEqnComp1().relax();
pEqnComp2 =
fvc::ddt(rho2)
+ fvc::div(phi2, rho2) - fvc::Sp(fvc::div(phi2), rho2)
+ correction
(
psi2*fvm::ddt(p)
+ fvm::div(phid2, p) - fvm::Sp(fvc::div(phid2), p)
);
deleteDemandDrivenData(pEqnComp2().faceFluxCorrectionPtr());
pEqnComp2().relax();
}
else
{
pEqnComp1 =
fvc::ddt(rho1) + psi1*correction(fvm::ddt(p))
+ fvc::div(phid1, p)
- fvc::Sp(fvc::div(phid1), p);
+ fvc::div(phi1, rho1) - fvc::Sp(fvc::div(phi1), rho1);
pEqnComp2 =
fvc::ddt(rho2) + psi2*correction(fvm::ddt(p))
+ fvc::div(phid2, p)
- fvc::Sp(fvc::div(phid2), p);
+ fvc::div(phi2, rho2) - fvc::Sp(fvc::div(phi2), rho2);
}
// Cache p prior to solve for density update
volScalarField p_0(p);
while (pimple.correctNonOrthogonal())
{
fvScalarMatrix pEqnIncomp
@ -182,10 +201,9 @@
p = max(p, pMin);
thermo1.correct();
thermo2.correct();
rho1 = thermo1.rho();
rho2 = thermo2.rho();
// Update densities from change in p
rho1 += psi1*(p - p_0);
rho2 += psi2*(p - p_0);
K1 = 0.5*magSqr(U1);
K2 = 0.5*magSqr(U2);

6
applications/solvers/multiphase/interFoam/interDyMFoam/correctPhi.H
View File

@ -53,6 +53,8 @@
fvc::makeRelative(phi, U);
}
}
#include "continuityErrs.H"
}
phi.oldTime() = phi;
#include "continuityErrs.H"

6
src/OSspecific/POSIX/signals/sigFpe.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
@ -263,8 +263,8 @@ void Foam::sigFpe::set(const bool verbose)
{
if (supported)
{
Info<< "SetNaN : Initialising allocated memory to NaN"
<< " (FOAM_SETNAN)." << endl;
Info<< "SetNaN : Initialising allocated memory to NaN"
<< " (FOAM_SETNAN)." << endl;
}
else
{

2
src/OpenFOAM/Make/files
View File

@ -367,6 +367,8 @@ $(cellShape)/cellShapeIOList.C
meshes/Identifiers/patch/patchIdentifier.C
meshes/MeshObject/meshObject.C
polyMesh = meshes/polyMesh
polyPatches = $(polyMesh)/polyPatches

10
src/OpenFOAM/containers/Lists/PtrList/PtrListI.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
@ -132,7 +132,9 @@ inline const T& Foam::PtrList<T>::operator[](const label i) const
if (!ptrs_[i])
{
FatalErrorIn("PtrList::operator[] const")
<< "hanging pointer, cannot dereference"
<< "hanging pointer at index " << i
<< " (size " << size()
<< "), cannot dereference"
<< abort(FatalError);
}
@ -146,7 +148,9 @@ inline T& Foam::PtrList<T>::operator[](const label i)
if (!ptrs_[i])
{
FatalErrorIn("PtrList::operator[]")
<< "hanging pointer, cannot dereference"
<< "hanging pointer at index " << i
<< " (size " << size()
<< "), cannot dereference"
<< abort(FatalError);
}

10
src/OpenFOAM/containers/Lists/UPtrList/UPtrListI.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
@ -107,7 +107,9 @@ inline const T& Foam::UPtrList<T>::operator[](const label i) const
if (!ptrs_[i])
{
FatalErrorIn("UPtrList::operator[] const")
<< "hanging pointer, cannot dereference"
<< "hanging pointer at index " << i
<< " (size " << size()
<< "), cannot dereference"
<< abort(FatalError);
}
@ -121,7 +123,9 @@ inline T& Foam::UPtrList<T>::operator[](const label i)
if (!ptrs_[i])
{
FatalErrorIn("UPtrList::operator[]")
<< "hanging pointer, cannot dereference"
<< "hanging pointer at index " << i
<< " (size " << size()
<< "), cannot dereference"
<< abort(FatalError);
}

70
src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchField.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,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "processorPointPatchField.H"
//#include "transformField.H"
#include "processorPolyPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -92,73 +91,6 @@ processorPointPatchField<Type>::~processorPointPatchField()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void processorPointPatchField<Type>::initSwapAddSeparated
(
const Pstream::commsTypes commsType,
Field<Type>& pField
)
const
{
// if (Pstream::parRun())
// {
// // Get internal field into correct order for opposite side
// Field<Type> pf
// (
// this->patchInternalField
// (
// pField,
// procPatch_.reverseMeshPoints()
// )
// );
//
// OPstream::write
// (
// commsType,
// procPatch_.neighbProcNo(),
// reinterpret_cast<const char*>(pf.begin()),
// pf.byteSize(),
// procPatch_.tag()
// );
// }
}
template<class Type>
void processorPointPatchField<Type>::swapAddSeparated
(
const Pstream::commsTypes commsType,
Field<Type>& pField
) const
{
// if (Pstream::parRun())
// {
// Field<Type> pnf(this->size());
//
// IPstream::read
// (
// commsType,
// procPatch_.neighbProcNo(),
// reinterpret_cast<char*>(pnf.begin()),
// pnf.byteSize(),
// procPatch_.tag()
// );
//
// if (doTransform())
// {
// const processorPolyPatch& ppp = procPatch_.procPolyPatch();
// const tensor& forwardT = ppp.forwardT();
//
// transform(pnf, forwardT, pnf);
// }
//
// addToInternalField(pField, pnf, procPatch_.separatedPoints());
// }
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

15
src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchField.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
@ -57,7 +57,6 @@ class processorPointPatchField
//- Local reference to processor patch
const processorPointPatch& procPatch_;
public:
//- Runtime type information
@ -176,19 +175,13 @@ public:
)
{}
//- Initialise swap of non-collocated patch point values
virtual void initSwapAddSeparated
(
const Pstream::commsTypes commsType,
Field<Type>&
) const;
//- Complete swap of patch point values and add to local values
//- Assume processor patch always collocated
virtual void swapAddSeparated
(
const Pstream::commsTypes commsType,
Field<Type>&
) const;
) const
{}
};

53
src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.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
@ -38,7 +38,8 @@ Foam::processorCyclicPointPatchField<Type>::processorCyclicPointPatchField
)
:
coupledPointPatchField<Type>(p, iF),
procPatch_(refCast<const processorCyclicPointPatch>(p))
procPatch_(refCast<const processorCyclicPointPatch>(p)),
receiveBuf_(0)
{}
@ -51,7 +52,8 @@ Foam::processorCyclicPointPatchField<Type>::processorCyclicPointPatchField
)
:
coupledPointPatchField<Type>(p, iF, dict),
procPatch_(refCast<const processorCyclicPointPatch>(p))
procPatch_(refCast<const processorCyclicPointPatch>(p)),
receiveBuf_(0)
{}
@ -65,7 +67,8 @@ Foam::processorCyclicPointPatchField<Type>::processorCyclicPointPatchField
)
:
coupledPointPatchField<Type>(ptf, p, iF, mapper),
procPatch_(refCast<const processorCyclicPointPatch>(ptf.patch()))
procPatch_(refCast<const processorCyclicPointPatch>(ptf.patch())),
receiveBuf_(0)
{}
@ -77,7 +80,8 @@ Foam::processorCyclicPointPatchField<Type>::processorCyclicPointPatchField
)
:
coupledPointPatchField<Type>(ptf, iF),
procPatch_(refCast<const processorCyclicPointPatch>(ptf.patch()))
procPatch_(refCast<const processorCyclicPointPatch>(ptf.patch())),
receiveBuf_(0)
{}
@ -109,6 +113,18 @@ void Foam::processorCyclicPointPatchField<Type>::initSwapAddSeparated
)
);
if (commsType == Pstream::nonBlocking)
{
receiveBuf_.setSize(pf.size());
IPstream::read
(
commsType,
procPatch_.neighbProcNo(),
reinterpret_cast<char*>(receiveBuf_.begin()),
receiveBuf_.byteSize(),
procPatch_.tag()
);
}
OPstream::write
(
commsType,
@ -130,16 +146,19 @@ void Foam::processorCyclicPointPatchField<Type>::swapAddSeparated
{
if (Pstream::parRun())
{
Field<Type> pnf(this->size());
IPstream::read
(
commsType,
procPatch_.neighbProcNo(),
reinterpret_cast<char*>(pnf.begin()),
pnf.byteSize(),
procPatch_.tag()
);
// If nonblocking data has already been received into receiveBuf_
if (commsType != Pstream::nonBlocking)
{
receiveBuf_.setSize(this->size());
IPstream::read
(
commsType,
procPatch_.neighbProcNo(),
reinterpret_cast<char*>(receiveBuf_.begin()),
receiveBuf_.byteSize(),
procPatch_.tag()
);
}
if (doTransform())
{
@ -147,11 +166,11 @@ void Foam::processorCyclicPointPatchField<Type>::swapAddSeparated
procPatch_.procCyclicPolyPatch();
const tensor& forwardT = ppp.forwardT()[0];
transform(pnf, forwardT, pnf);
transform(receiveBuf_, forwardT, receiveBuf_);
}
// All points are separated
this->addToInternalField(pField, pnf);
this->addToInternalField(pField, receiveBuf_);
}
}

5
src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.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
@ -57,6 +57,9 @@ class processorCyclicPointPatchField
//- Local reference to processor patch
const processorCyclicPointPatch& procPatch_;
//- Receive buffer for non-blocking communication
mutable Field<Type> receiveBuf_;
public:

60
src/OpenFOAM/meshes/MeshObject/MeshObject.C
View File

@ -25,6 +25,7 @@ License
#include "MeshObject.H"
#include "objectRegistry.H"
#include "IOstreams.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -59,6 +60,11 @@ const Type& Foam::MeshObject<Mesh, MeshObjectType, Type>::New
}
else
{
if (meshObject::debug)
{
Pout<< "MeshObject::New(const Mesh&) : constructing new "
<< Type::typeName << endl;
}
return regIOobject::store(new Type(mesh));
}
}
@ -87,6 +93,11 @@ const Type& Foam::MeshObject<Mesh, MeshObjectType, Type>::New
}
else
{
if (meshObject::debug)
{
Pout<< "MeshObject::New(const Mesh&) : constructing new "
<< Type::typeName << endl;
}
return regIOobject::store(new Type(mesh, d));
}
}
@ -116,6 +127,11 @@ const Type& Foam::MeshObject<Mesh, MeshObjectType, Type>::New
}
else
{
if (meshObject::debug)
{
Pout<< "MeshObject(const Mesh&) : constructing new "
<< Type::typeName << endl;
}
return regIOobject::store(new Type(mesh, d1, d2));
}
}
@ -146,6 +162,11 @@ const Type& Foam::MeshObject<Mesh, MeshObjectType, Type>::New
}
else
{
if (meshObject::debug)
{
Pout<< "MeshObject(const Mesh&) : constructing new "
<< Type::typeName << endl;
}
return regIOobject::store(new Type(mesh, d1, d2, d3));
}
}
@ -177,6 +198,11 @@ const Type& Foam::MeshObject<Mesh, MeshObjectType, Type>::New
}
else
{
if (meshObject::debug)
{
Pout<< "MeshObject(const Mesh&) : constructing new "
<< Type::typeName << endl;
}
return regIOobject::store(new Type(mesh, d1, d2, d3, d4));
}
}
@ -195,6 +221,12 @@ bool Foam::MeshObject<Mesh, MeshObjectType, Type>::Delete(const Mesh& mesh)
)
)
{
if (meshObject::debug)
{
Pout<< "MeshObject::Delete(const Mesh&) : deleting "
<< Type::typeName << endl;
}
return mesh.thisDb().checkOut
(
const_cast<Type&>
@ -237,10 +269,22 @@ void Foam::meshObject::movePoints(objectRegistry& obr)
{
if (isA<MoveableMeshObject<Mesh> >(*iter()))
{
if (meshObject::debug)
{
Pout<< "meshObject::movePoints(objectRegistry&) :"
<< " movePoints on "
<< iter()->name() << endl;
}
dynamic_cast<MoveableMeshObject<Mesh>*>(iter())->movePoints();
}
else
{
if (meshObject::debug)
{
Pout<< "meshObject::movePoints(objectRegistry&) :"
<< " destroying "
<< iter()->name() << endl;
}
obr.checkOut(*iter());
}
}
@ -264,10 +308,21 @@ void Foam::meshObject::updateMesh(objectRegistry& obr, const mapPolyMesh& mpm)
{
if (isA<UpdateableMeshObject<Mesh> >(*iter()))
{
if (meshObject::debug)
{
Pout<< "meshObject::updateMesh(objectRegistry&) :"
<< " updateMesh on "
<< iter()->name() << endl;
}
dynamic_cast<UpdateableMeshObject<Mesh>*>(iter())->updateMesh(mpm);
}
else
{
if (meshObject::debug)
{
Pout<< "meshObject::updateMesh(objectRegistry&) : destroying "
<< iter()->name() << endl;
}
obr.checkOut(*iter());
}
}
@ -284,6 +339,11 @@ void Foam::meshObject::clear(objectRegistry& obr)
forAllIter(typename HashTable<MeshObjectType<Mesh>*>, meshObjects, iter)
{
if (meshObject::debug)
{
Pout<< "meshObject::clear(objectRegistry&) : destroying "
<< iter()->name() << endl;
}
obr.checkOut(*iter());
}
}

16
src/OpenFOAM/meshes/MeshObject/MeshObject.H
View File

@ -164,20 +164,12 @@ class meshObject
{
public:
// Declare name of the class and its debug switch
ClassName("meshObject");
// Constructors
meshObject(const word& typeName, const objectRegistry& obr)
:
regIOobject
(
IOobject
(
typeName,
obr.instance(),
obr
)
)
{}
meshObject(const word& typeName, const objectRegistry& obr);
// Static member functions

52
src/OpenFOAM/meshes/MeshObject/meshObject.C Normal file
View File

@ -0,0 +1,52 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-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/>.
\*---------------------------------------------------------------------------*/
#include "MeshObject.H"
/* * * * * * * * * * * * * * * Static Member Data * * * * * * * * * * * * * */
namespace Foam
{
defineTypeNameAndDebug(meshObject, 0);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::meshObject::meshObject(const word& typeName, const objectRegistry& obr)
:
regIOobject
(
IOobject
(
typeName,
obr.instance(),
obr
)
)
{}
// ************************************************************************* //

85
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.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
@ -37,10 +37,7 @@ namespace Foam
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
(
@ -66,20 +63,10 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
neighbProcNo,
transform
),
tag_
(
Pstream::nProcs()*max(myProcNo, neighbProcNo)
+ min(myProcNo, neighbProcNo)
),
referPatchName_(referPatchName),
tag_(-1),
referPatchID_(-1)
{
if (debug)
{
Pout<< "processorCyclicPolyPatch " << name << " uses tag " << tag_
<< endl;
}
}
{}
Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
@ -92,20 +79,10 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
)
:
processorPolyPatch(name, dict, index, bm, patchType),
tag_
(
Pstream::nProcs()*max(myProcNo(), neighbProcNo())
+ min(myProcNo(), neighbProcNo())
),
referPatchName_(dict.lookup("referPatch")),
tag_(dict.lookupOrDefault<int>("tag", -1)),
referPatchID_(-1)
{
if (debug)
{
Pout<< "processorCyclicPolyPatch " << name << " uses tag " << tag_
<< endl;
}
}
{}
Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
@ -115,8 +92,8 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
)
:
processorPolyPatch(pp, bm),
tag_(pp.tag_),
referPatchName_(pp.referPatchName()),
tag_(pp.tag()),
referPatchID_(-1)
{}
@ -132,8 +109,8 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
)
:
processorPolyPatch(pp, bm, index, newSize, newStart),
tag_(pp.tag_),
referPatchName_(referPatchName),
tag_(-1),
referPatchID_(-1)
{}
@ -148,8 +125,8 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
)
:
processorPolyPatch(pp, bm, index, mapAddressing, newStart),
tag_(pp.tag_),
referPatchName_(pp.referPatchName()),
tag_(-1),
referPatchID_(-1)
{}
@ -162,6 +139,45 @@ Foam::processorCyclicPolyPatch::~processorCyclicPolyPatch()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
int Foam::processorCyclicPolyPatch::tag() const
{
if (tag_ == -1)
{
// Get unique tag to use for all comms. Make sure that both sides
// use the same tag
const cyclicPolyPatch& cycPatch = refCast<const cyclicPolyPatch>
(
referPatch()
);
if (cycPatch.owner())
{
tag_ = Hash<word>()(cycPatch.name());
}
else
{
tag_ = Hash<word>()(cycPatch.neighbPatch().name());
}
if (tag_ == Pstream::msgType() || tag_ == -1)
{
FatalErrorIn("processorCyclicPolyPatch::tag() const")
<< "Tag calculated from cyclic patch name " << tag_
<< " is the same as the current message type "
<< Pstream::msgType() << " or -1" << nl
<< "Please set a non-conflicting, unique, tag by hand"
<< " using the 'tag' entry"
<< exit(FatalError);
}
if (debug)
{
Pout<< "processorCyclicPolyPatch " << name() << " uses tag " << tag_
<< endl;
}
}
return tag_;
}
void Foam::processorCyclicPolyPatch::initGeometry(PstreamBuffers& pBufs)
{
@ -283,6 +299,11 @@ void Foam::processorCyclicPolyPatch::write(Ostream& os) const
processorPolyPatch::write(os);
os.writeKeyword("referPatch") << referPatchName_
<< token::END_STATEMENT << nl;
if (tag_ != -1)
{
os.writeKeyword("tag") << tag_
<< token::END_STATEMENT << nl;
}
}

13
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
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
@ -54,12 +54,12 @@ class processorCyclicPolyPatch
{
// Private data
//- Message tag to use for communication
const int tag_;
//- Name of originating patch
const word referPatchName_;
//- Message tag to use for communication
mutable int tag_;
//- Index of originating patch
mutable label referPatchID_;
@ -264,10 +264,7 @@ public:
}
//- Return message tag to use for communication
virtual int tag() const
{
return tag_;
}
virtual int tag() const;
//- Does this side own the patch ?
virtual bool owner() const

243
src/finiteVolume/fields/fvPatchFields/derived/mappedField/mappedFieldFvPatchField.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
@ -42,12 +42,9 @@ mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
const DimensionedField<Type, volMesh>& iF
)
:
mappedPatchBase(p.patch()),
fixedValueFvPatchField<Type>(p, iF),
fieldName_(iF.name()),
setAverage_(false),
average_(pTraits<Type>::zero),
interpolationScheme_(interpolationCell<Type>::typeName)
mappedPatchBase(p.patch()),
mappedPatchFieldBase<Type>(*this, *this)
{}
@ -60,12 +57,9 @@ mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
const fvPatchFieldMapper& mapper
)
:
mappedPatchBase(p.patch(), ptf),
fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
fieldName_(ptf.fieldName_),
setAverage_(ptf.setAverage_),
average_(ptf.average_),
interpolationScheme_(ptf.interpolationScheme_)
mappedPatchBase(p.patch(), ptf),
mappedPatchFieldBase<Type>(*this, *this, ptf)
{}
@ -77,18 +71,10 @@ mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
const dictionary& dict
)
:
mappedPatchBase(p.patch(), dict),
fixedValueFvPatchField<Type>(p, iF, dict),
fieldName_(dict.template lookupOrDefault<word>("fieldName", iF.name())),
setAverage_(readBool(dict.lookup("setAverage"))),
average_(pTraits<Type>(dict.lookup("average"))),
interpolationScheme_(interpolationCell<Type>::typeName)
{
if (mode() == mappedPatchBase::NEARESTCELL)
{
dict.lookup("interpolationScheme") >> interpolationScheme_;
}
}
mappedPatchBase(p.patch(), dict),
mappedPatchFieldBase<Type>(*this, *this, dict)
{}
template<class Type>
@ -110,6 +96,7 @@ mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
const word& interpolationScheme
)
:
fixedValueFvPatchField<Type>(p, iF),
mappedPatchBase
(
p.patch(),
@ -118,11 +105,15 @@ mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
samplePatch,
distance
),
fixedValueFvPatchField<Type>(p, iF),
fieldName_(fieldName),
setAverage_(setAverage),
average_(average),
interpolationScheme_(interpolationScheme)
mappedPatchFieldBase<Type>
(
*this,
*this,
fieldName,
setAverage,
average,
interpolationScheme
)
{}
@ -132,12 +123,9 @@ mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
const mappedFieldFvPatchField<Type>& ptf
)
:
mappedPatchBase(ptf.patch().patch(), ptf),
fixedValueFvPatchField<Type>(ptf),
fieldName_(ptf.fieldName_),
setAverage_(ptf.setAverage_),
average_(ptf.average_),
interpolationScheme_(ptf.interpolationScheme_)
mappedPatchBase(ptf.patch().patch(), ptf),
mappedPatchFieldBase<Type>(ptf)
{}
@ -148,65 +136,14 @@ mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
const DimensionedField<Type, volMesh>& iF
)
:
mappedPatchBase(ptf.patch().patch(), ptf),
fixedValueFvPatchField<Type>(ptf, iF),
fieldName_(ptf.fieldName_),
setAverage_(ptf.setAverage_),
average_(ptf.average_),
interpolationScheme_(ptf.interpolationScheme_)
mappedPatchBase(ptf.patch().patch(), ptf),
mappedPatchFieldBase<Type>(*this, *this, ptf)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
const GeometricField<Type, fvPatchField, volMesh>&
mappedFieldFvPatchField<Type>::sampleField() const
{
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
const fvMesh& nbrMesh = refCast<const fvMesh>(sampleMesh());
if (sameRegion())
{
if (fieldName_ == this->dimensionedInternalField().name())
{
// Optimisation: bypass field lookup
return
dynamic_cast<const fieldType&>
(
this->dimensionedInternalField()
);
}
else
{
const fvMesh& thisMesh = this->patch().boundaryMesh().mesh();
return thisMesh.template lookupObject<fieldType>(fieldName_);
}
}
else
{
return nbrMesh.template lookupObject<fieldType>(fieldName_);
}
}
template<class Type>
const interpolation<Type>&
mappedFieldFvPatchField<Type>::interpolator() const
{
if (!interpolator_.valid())
{
interpolator_ = interpolation<Type>::New
(
interpolationScheme_,
sampleField()
);
}
return interpolator_();
}
template<class Type>
void mappedFieldFvPatchField<Type>::updateCoeffs()
{
@ -215,132 +152,7 @@ void mappedFieldFvPatchField<Type>::updateCoeffs()
return;
}
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
// Since we're inside initEvaluate/evaluate there might be processor
// comms underway. Change the tag we use.
int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag + 1;
const fvMesh& thisMesh = this->patch().boundaryMesh().mesh();
const fvMesh& nbrMesh = refCast<const fvMesh>(sampleMesh());
// Result of obtaining remote values
Field<Type> newValues;
switch (mode())
{
case NEARESTCELL:
{
const mapDistribute& mapDist = this->mappedPatchBase::map();
if (interpolationScheme_ != interpolationCell<Type>::typeName)
{
// Need to do interpolation so need cells to sample
// Send back sample points to the processor that holds the cell
vectorField samples(samplePoints());
mapDist.reverseDistribute
(
(sameRegion() ? thisMesh.nCells() : nbrMesh.nCells()),
point::max,
samples
);
const interpolation<Type>& interp = interpolator();
newValues.setSize(samples.size(), pTraits<Type>::max);
forAll(samples, cellI)
{
if (samples[cellI] != point::max)
{
newValues[cellI] = interp.interpolate
(
samples[cellI],
cellI
);
}
}
}
else
{
newValues = sampleField();
}
mapDist.distribute(newValues);
break;
}
case NEARESTPATCHFACE: case NEARESTPATCHFACEAMI:
{
const label nbrPatchID =
nbrMesh.boundaryMesh().findPatchID(samplePatch());
if (nbrPatchID < 0)
{
FatalErrorIn
(
"void mappedFieldFvPatchField<Type>::updateCoeffs()"
)<< "Unable to find sample patch " << samplePatch()
<< " in region " << sampleRegion()
<< " for patch " << this->patch().name() << nl
<< abort(FatalError);
}
const fieldType& nbrField = sampleField();
newValues = nbrField.boundaryField()[nbrPatchID];
this->distribute(newValues);
break;
}
case NEARESTFACE:
{
Field<Type> allValues(nbrMesh.nFaces(), pTraits<Type>::zero);
const fieldType& nbrField = sampleField();
forAll(nbrField.boundaryField(), patchI)
{
const fvPatchField<Type>& pf =
nbrField.boundaryField()[patchI];
label faceStart = pf.patch().patch().start();
forAll(pf, faceI)
{
allValues[faceStart++] = pf[faceI];
}
}
this->distribute(allValues);
newValues.transfer(allValues);
break;
}
default:
{
FatalErrorIn("mappedFieldFvPatchField<Type>::updateCoeffs()")
<< "Unknown sampling mode: " << mode()
<< nl << abort(FatalError);
}
}
if (setAverage_)
{
Type averagePsi =
gSum(this->patch().magSf()*newValues)
/gSum(this->patch().magSf());
if (mag(averagePsi)/mag(average_) > 0.5)
{
newValues *= mag(average_)/mag(averagePsi);
}
else
{
newValues += (average_ - averagePsi);
}
}
this->operator==(newValues);
this->operator==(this->mappedField());
if (debug)
{
@ -352,9 +164,6 @@ void mappedFieldFvPatchField<Type>::updateCoeffs()
<< endl;
}
// Restore tag
UPstream::msgType() = oldTag;
fixedValueFvPatchField<Type>::updateCoeffs();
}
@ -364,11 +173,7 @@ void mappedFieldFvPatchField<Type>::write(Ostream& os) const
{
fvPatchField<Type>::write(os);
mappedPatchBase::write(os);
os.writeKeyword("fieldName") << fieldName_ << token::END_STATEMENT << nl;
os.writeKeyword("setAverage") << setAverage_ << token::END_STATEMENT << nl;
os.writeKeyword("average") << average_ << token::END_STATEMENT << nl;
os.writeKeyword("interpolationScheme") << interpolationScheme_
<< token::END_STATEMENT << nl;
mappedPatchFieldBase<Type>::write(os);
this->writeEntry("value", os);
}

34
src/finiteVolume/fields/fvPatchFields/derived/mappedField/mappedFieldFvPatchField.H
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
@ -75,6 +75,7 @@ SourceFiles
#define mappedFieldFvPatchField_H
#include "mappedPatchBase.H"
#include "mappedPatchFieldBase.H"
#include "fixedValueFvPatchFields.H"
#include "interpolation.H"
@ -90,37 +91,10 @@ namespace Foam
template<class Type>
class mappedFieldFvPatchField
:
public fixedValueFvPatchField<Type>,
public mappedPatchBase,
public fixedValueFvPatchField<Type>
public mappedPatchFieldBase<Type>
{
// Private data
//- Name of field to sample - defaults to field associated with this
// patchField if not specified
word fieldName_;
//- If true adjust the mapped field to maintain average value average_
const bool setAverage_;
//- Average value the mapped field is adjusted to maintain if
// setAverage_ is set true
const Type average_;
//- Interpolation scheme to use for nearestCell mode
word interpolationScheme_;
//- Pointer to the cell interpolator
mutable autoPtr<interpolation<Type> > interpolator_;
// Private Member Functions
//- Field to sample. Either on my or nbr mesh
const GeometricField<Type, fvPatchField, volMesh>& sampleField() const;
//- Access the interpolation method
const interpolation<Type>& interpolator() const;
public:

340
src/finiteVolume/fields/fvPatchFields/derived/mappedField/mappedPatchFieldBase.C Normal file
View File

@ -0,0 +1,340 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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/>.
\*---------------------------------------------------------------------------*/
#include "mappedPatchFieldBase.H"
#include "mappedPatchBase.H"
#include "interpolationCell.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
mappedPatchFieldBase<Type>::mappedPatchFieldBase
(
const mappedPatchBase& mapper,
const fvPatchField<Type>& patchField,
const word& fieldName,
const bool setAverage,
const Type average,
const word& interpolationScheme
)
:
mapper_(mapper),
patchField_(patchField),
fieldName_(fieldName),
setAverage_(setAverage),
average_(average),
interpolationScheme_(interpolationScheme)
{}
template<class Type>
mappedPatchFieldBase<Type>::mappedPatchFieldBase
(
const mappedPatchBase& mapper,
const fvPatchField<Type>& patchField,
const dictionary& dict
)
:
mapper_(mapper),
patchField_(patchField),
fieldName_
(
dict.template lookupOrDefault<word>
(
"fieldName",
patchField_.dimensionedInternalField().name()
)
),
setAverage_(readBool(dict.lookup("setAverage"))),
average_(pTraits<Type>(dict.lookup("average"))),
interpolationScheme_(interpolationCell<Type>::typeName)
{
if (mapper_.mode() == mappedPatchBase::NEARESTCELL)
{
dict.lookup("interpolationScheme") >> interpolationScheme_;
}
}
template<class Type>
mappedPatchFieldBase<Type>::mappedPatchFieldBase
(
const mappedPatchBase& mapper,
const fvPatchField<Type>& patchField
)
:
mapper_(mapper),
patchField_(patchField),
fieldName_(patchField_.dimensionedInternalField().name()),
setAverage_(false),
average_(pTraits<Type>::zero),
interpolationScheme_(interpolationCell<Type>::typeName)
{}
template<class Type>
mappedPatchFieldBase<Type>::mappedPatchFieldBase
(
const mappedPatchFieldBase<Type>& mapper
)
:
mapper_(mapper.mapper_),
patchField_(mapper.patchField_),
fieldName_(mapper.fieldName_),
setAverage_(mapper.setAverage_),
average_(mapper.average_),
interpolationScheme_(mapper.interpolationScheme_)
{}
template<class Type>
mappedPatchFieldBase<Type>::mappedPatchFieldBase
(
const mappedPatchBase& mapper,
const fvPatchField<Type>& patchField,
const mappedPatchFieldBase<Type>& base
)
:
mapper_(mapper),
patchField_(patchField),
fieldName_(base.fieldName_),
setAverage_(base.setAverage_),
average_(base.average_),
interpolationScheme_(base.interpolationScheme_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
const GeometricField<Type, fvPatchField, volMesh>&
mappedPatchFieldBase<Type>::sampleField() const
{
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
const fvMesh& nbrMesh = refCast<const fvMesh>(mapper_.sampleMesh());
if (mapper_.sameRegion())
{
if (fieldName_ == patchField_.dimensionedInternalField().name())
{
// Optimisation: bypass field lookup
return
dynamic_cast<const fieldType&>
(
patchField_.dimensionedInternalField()
);
}
else
{
const fvMesh& thisMesh = patchField_.patch().boundaryMesh().mesh();
return thisMesh.template lookupObject<fieldType>(fieldName_);
}
}
else
{
return nbrMesh.template lookupObject<fieldType>(fieldName_);
}
}
template<class Type>
const interpolation<Type>& mappedPatchFieldBase<Type>::interpolator() const
{
if (!interpolator_.valid())
{
interpolator_ = interpolation<Type>::New
(
interpolationScheme_,
sampleField()
);
}
return interpolator_();
}
template<class Type>
tmp<Field<Type> > mappedPatchFieldBase<Type>::mappedField() const
{
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
// Since we're inside initEvaluate/evaluate there might be processor
// comms underway. Change the tag we use.
int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag + 1;
const fvMesh& thisMesh = patchField_.patch().boundaryMesh().mesh();
const fvMesh& nbrMesh = refCast<const fvMesh>(mapper_.sampleMesh());
// Result of obtaining remote values
tmp<Field<Type> > tnewValues(new Field<Type>(0));
Field<Type>& newValues = tnewValues();
switch (mapper_.mode())
{
case mappedPatchBase::NEARESTCELL:
{
const mapDistribute& distMap = mapper_.map();
if (interpolationScheme_ != interpolationCell<Type>::typeName)
{
// Send back sample points to the processor that holds the cell
vectorField samples(mapper_.samplePoints());
distMap.reverseDistribute
(
(
mapper_.sameRegion()
? thisMesh.nCells()
: nbrMesh.nCells()
),
point::max,
samples
);
const interpolation<Type>& interp = interpolator();
newValues.setSize(samples.size(), pTraits<Type>::max);
forAll(samples, cellI)
{
if (samples[cellI] != point::max)
{
newValues[cellI] = interp.interpolate
(
samples[cellI],
cellI
);
}
}
}
else
{
newValues = sampleField();
}
distMap.distribute(newValues);
break;
}
case mappedPatchBase::NEARESTPATCHFACE:
case mappedPatchBase::NEARESTPATCHFACEAMI:
{
const label nbrPatchID =
nbrMesh.boundaryMesh().findPatchID(mapper_.samplePatch());
if (nbrPatchID < 0)
{
FatalErrorIn
(
"void mappedPatchFieldBase<Type>::updateCoeffs()"
)<< "Unable to find sample patch " << mapper_.samplePatch()
<< " in region " << mapper_.sampleRegion()
<< " for patch " << patchField_.patch().name() << nl
<< abort(FatalError);
}
const fieldType& nbrField = sampleField();
newValues = nbrField.boundaryField()[nbrPatchID];
mapper_.distribute(newValues);
break;
}
case mappedPatchBase::NEARESTFACE:
{
Field<Type> allValues(nbrMesh.nFaces(), pTraits<Type>::zero);
const fieldType& nbrField = sampleField();
forAll(nbrField.boundaryField(), patchI)
{
const fvPatchField<Type>& pf =
nbrField.boundaryField()[patchI];
label faceStart = pf.patch().start();
forAll(pf, faceI)
{
allValues[faceStart++] = pf[faceI];
}
}
mapper_.distribute(allValues);
newValues.transfer(allValues);
break;
}
default:
{
FatalErrorIn
(
"mappedPatchFieldBase<Type>::updateCoeffs()"
)<< "Unknown sampling mode: " << mapper_.mode()
<< nl << abort(FatalError);
}
}
if (setAverage_)
{
Type averagePsi =
gSum(patchField_.patch().magSf()*newValues)
/gSum(patchField_.patch().magSf());
if (mag(averagePsi)/mag(average_) > 0.5)
{
newValues *= mag(average_)/mag(averagePsi);
}
else
{
newValues += (average_ - averagePsi);
}
}
// Restore tag
UPstream::msgType() = oldTag;
return tnewValues;
}
template<class Type>
void mappedPatchFieldBase<Type>::write(Ostream& os) const
{
os.writeKeyword("fieldName") << fieldName_ << token::END_STATEMENT << nl;
os.writeKeyword("setAverage") << setAverage_ << token::END_STATEMENT << nl;
os.writeKeyword("average") << average_ << token::END_STATEMENT << nl;
os.writeKeyword("interpolationScheme") << interpolationScheme_
<< token::END_STATEMENT << nl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

166
src/finiteVolume/fields/fvPatchFields/derived/mappedField/mappedPatchFieldBase.H Normal file
View File

@ -0,0 +1,166 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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::mappedPatchFieldBase
Description
Functionality for sampling fields using mappedPatchBase.
SourceFiles
mappedPatchFieldBase.C
\*---------------------------------------------------------------------------*/
#ifndef mappedPatchFieldBase_H
#define mappedPatchFieldBase_H
#include "fixedValueFvPatchFields.H"
#include "volFieldsFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class mappedPatchBase;
template<class> class interpolation;
/*---------------------------------------------------------------------------*\
Class mappedPatchFieldBase Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class mappedPatchFieldBase
{
protected:
// Protected data
//- Mapping engine
const mappedPatchBase& mapper_;
//- Underlying patch field
const fvPatchField<Type>& patchField_;
//- Name of field to sample
word fieldName_;
//- If true adjust the mapped field to maintain average value average_
const bool setAverage_;
//- Average value the mapped field is adjusted to maintain if
// setAverage_ is set true
const Type average_;
//- Interpolation scheme to use for nearestcell mode
word interpolationScheme_;
mutable autoPtr<interpolation<Type> > interpolator_;
// Protected Member Functions
public:
// Constructors
//- Construct from components
mappedPatchFieldBase
(
const mappedPatchBase& mapper,
const fvPatchField<Type>& patchField,
const word& fieldName,
const bool setAverage,
const Type average,
const word& interpolationScheme
);
//- Construct from dictionary
mappedPatchFieldBase
(
const mappedPatchBase& mapper,
const fvPatchField<Type>& patchField,
const dictionary& dict
);
//- Construct empty
mappedPatchFieldBase
(
const mappedPatchBase& mapper,
const fvPatchField<Type>& patchField
);
//- Construct copy
mappedPatchFieldBase
(
const mappedPatchFieldBase<Type>& mapper
);
//- Construct copy, resetting patch and field
mappedPatchFieldBase
(
const mappedPatchBase& mapper,
const fvPatchField<Type>& patchField,
const mappedPatchFieldBase<Type>& base
);
//- Destructor
virtual ~mappedPatchFieldBase<Type>()
{}
// Member functions
//- Field to sample. Either on my or nbr mesh
const GeometricField<Type, fvPatchField, volMesh>& sampleField() const;
//- Access the interpolation method
const interpolation<Type>& interpolator() const;
//- Map sampleField onto *this patch
virtual tmp<Field<Type> > mappedField() const;
//- Write
virtual void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "mappedPatchFieldBase.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

283
src/finiteVolume/fields/fvPatchFields/derived/mappedFixedValue/mappedFixedValueFvPatchField.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
@ -26,7 +26,6 @@ License
#include "mappedFixedValueFvPatchField.H"
#include "mappedPatchBase.H"
#include "volFields.H"
#include "interpolationCell.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -43,10 +42,7 @@ mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
)
:
fixedValueFvPatchField<Type>(p, iF),
fieldName_(iF.name()),
setAverage_(false),
average_(pTraits<Type>::zero),
interpolationScheme_(interpolationCell<Type>::typeName)
mappedPatchFieldBase<Type>(this->mapper(p, iF), *this)
{}
@ -60,31 +56,8 @@ mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
)
:
fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
fieldName_(ptf.fieldName_),
setAverage_(ptf.setAverage_),
average_(ptf.average_),
interpolationScheme_(ptf.interpolationScheme_)
{
if (!isA<mappedPatchBase>(this->patch().patch()))
{
FatalErrorIn
(
"mappedFixedValueFvPatchField<Type>::"
"mappedFixedValueFvPatchField\n"
"(\n"
" const mappedFixedValueFvPatchField<Type>&,\n"
" const fvPatch&,\n"
" const Field<Type>&,\n"
" const fvPatchFieldMapper&\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not type '" << mappedPatchBase::typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalError);
}
}
mappedPatchFieldBase<Type>(this->mapper(p, iF), *this, ptf)
{}
template<class Type>
@ -96,39 +69,8 @@ mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
)
:
fixedValueFvPatchField<Type>(p, iF, dict),
fieldName_(dict.lookupOrDefault<word>("fieldName", iF.name())),
setAverage_(readBool(dict.lookup("setAverage"))),
average_(pTraits<Type>(dict.lookup("average"))),
interpolationScheme_(interpolationCell<Type>::typeName)
{
if (!isA<mappedPatchBase>(this->patch().patch()))
{
FatalErrorIn
(
"mappedFixedValueFvPatchField<Type>::"
"mappedFixedValueFvPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<Type, volMesh>& iF,\n"
" const dictionary& dict\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not type '" << mappedPatchBase::typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalError);
}
const mappedPatchBase& mpp = refCast<const mappedPatchBase>
(
mappedFixedValueFvPatchField<Type>::patch().patch()
);
if (mpp.mode() == mappedPatchBase::NEARESTCELL)
{
dict.lookup("interpolationScheme") >> interpolationScheme_;
}
}
mappedPatchFieldBase<Type>(this->mapper(p, iF), *this, dict)
{}
template<class Type>
@ -138,10 +80,7 @@ mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
)
:
fixedValueFvPatchField<Type>(ptf),
fieldName_(ptf.fieldName_),
setAverage_(ptf.setAverage_),
average_(ptf.average_),
interpolationScheme_(ptf.interpolationScheme_)
mappedPatchFieldBase<Type>(ptf)
{}
@ -153,64 +92,32 @@ mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
)
:
fixedValueFvPatchField<Type>(ptf, iF),
fieldName_(ptf.fieldName_),
setAverage_(ptf.setAverage_),
average_(ptf.average_),
interpolationScheme_(ptf.interpolationScheme_)
mappedPatchFieldBase<Type>(this->mapper(this->patch(), iF), *this, ptf)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
const GeometricField<Type, fvPatchField, volMesh>&
mappedFixedValueFvPatchField<Type>::sampleField() const
const mappedPatchBase& mappedFixedValueFvPatchField<Type>::mapper
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
)
{
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
const mappedPatchBase& mpp = refCast<const mappedPatchBase>
(
mappedFixedValueFvPatchField<Type>::patch().patch()
);
const fvMesh& nbrMesh = refCast<const fvMesh>(mpp.sampleMesh());
if (mpp.sameRegion())
if (!isA<mappedPatchBase>(p.patch()))
{
if (fieldName_ == this->dimensionedInternalField().name())
{
// Optimisation: bypass field lookup
return
dynamic_cast<const fieldType&>
(
this->dimensionedInternalField()
);
}
else
{
const fvMesh& thisMesh = this->patch().boundaryMesh().mesh();
return thisMesh.lookupObject<fieldType>(fieldName_);
}
}
else
{
return nbrMesh.lookupObject<fieldType>(fieldName_);
}
}
template<class Type>
const interpolation<Type>&
mappedFixedValueFvPatchField<Type>::interpolator() const
{
if (!interpolator_.valid())
{
interpolator_ = interpolation<Type>::New
FatalErrorIn
(
interpolationScheme_,
sampleField()
);
"mappedFixedValueFvPatchField<Type>::mapper()"
) << "\n patch type '" << p.patch().type()
<< "' not type '" << mappedPatchBase::typeName << "'"
<< "\n for patch " << p.patch().name()
<< " of field " << iF.name()
<< " in file " << iF.objectPath()
<< exit(FatalError);
}
return interpolator_();
return refCast<const mappedPatchBase>(p.patch());
}
@ -222,140 +129,7 @@ void mappedFixedValueFvPatchField<Type>::updateCoeffs()
return;
}
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
// Since we're inside initEvaluate/evaluate there might be processor
// comms underway. Change the tag we use.
int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag + 1;
// Get the scheduling information from the mappedPatchBase
const mappedPatchBase& mpp = refCast<const mappedPatchBase>
(
mappedFixedValueFvPatchField<Type>::patch().patch()
);
const fvMesh& thisMesh = this->patch().boundaryMesh().mesh();
const fvMesh& nbrMesh = refCast<const fvMesh>(mpp.sampleMesh());
// Result of obtaining remote values
Field<Type> newValues;
switch (mpp.mode())
{
case mappedPatchBase::NEARESTCELL:
{
const mapDistribute& distMap = mpp.map();
if (interpolationScheme_ != interpolationCell<Type>::typeName)
{
// Send back sample points to the processor that holds the cell
vectorField samples(mpp.samplePoints());
distMap.reverseDistribute
(
(mpp.sameRegion() ? thisMesh.nCells() : nbrMesh.nCells()),
point::max,
samples
);
const interpolation<Type>& interp = interpolator();
newValues.setSize(samples.size(), pTraits<Type>::max);
forAll(samples, cellI)
{
if (samples[cellI] != point::max)
{
newValues[cellI] = interp.interpolate
(
samples[cellI],
cellI
);
}
}
}
else
{
newValues = sampleField();
}
distMap.distribute(newValues);
break;
}
case mappedPatchBase::NEARESTPATCHFACE:
case mappedPatchBase::NEARESTPATCHFACEAMI:
{
const label nbrPatchID =
nbrMesh.boundaryMesh().findPatchID(mpp.samplePatch());
if (nbrPatchID < 0)
{
FatalErrorIn
(
"void mappedFixedValueFvPatchField<Type>::updateCoeffs()"
)<< "Unable to find sample patch " << mpp.samplePatch()
<< " in region " << mpp.sampleRegion()
<< " for patch " << this->patch().name() << nl
<< abort(FatalError);
}
const fieldType& nbrField = sampleField();
newValues = nbrField.boundaryField()[nbrPatchID];
mpp.distribute(newValues);
break;
}
case mappedPatchBase::NEARESTFACE:
{
Field<Type> allValues(nbrMesh.nFaces(), pTraits<Type>::zero);
const fieldType& nbrField = sampleField();
forAll(nbrField.boundaryField(), patchI)
{
const fvPatchField<Type>& pf =
nbrField.boundaryField()[patchI];
label faceStart = pf.patch().start();
forAll(pf, faceI)
{
allValues[faceStart++] = pf[faceI];
}
}
mpp.distribute(allValues);
newValues.transfer(allValues);
break;
}
default:
{
FatalErrorIn
(
"mappedFixedValueFvPatchField<Type>::updateCoeffs()"
)<< "Unknown sampling mode: " << mpp.mode()
<< nl << abort(FatalError);
}
}
if (setAverage_)
{
Type averagePsi =
gSum(this->patch().magSf()*newValues)
/gSum(this->patch().magSf());
if (mag(averagePsi)/mag(average_) > 0.5)
{
newValues *= mag(average_)/mag(averagePsi);
}
else
{
newValues += (average_ - averagePsi);
}
}
this->operator==(newValues);
this->operator==(this->mappedField());
if (debug)
{
@ -368,9 +142,6 @@ void mappedFixedValueFvPatchField<Type>::updateCoeffs()
<< endl;
}
// Restore tag
UPstream::msgType() = oldTag;
fixedValueFvPatchField<Type>::updateCoeffs();
}
@ -379,11 +150,7 @@ template<class Type>
void mappedFixedValueFvPatchField<Type>::write(Ostream& os) const
{
fvPatchField<Type>::write(os);
os.writeKeyword("fieldName") << fieldName_ << token::END_STATEMENT << nl;
os.writeKeyword("setAverage") << setAverage_ << token::END_STATEMENT << nl;
os.writeKeyword("average") << average_ << token::END_STATEMENT << nl;
os.writeKeyword("interpolationScheme") << interpolationScheme_
<< token::END_STATEMENT << nl;
mappedPatchFieldBase<Type>::write(os);
this->writeEntry("value", os);
}

37
src/finiteVolume/fields/fvPatchFields/derived/mappedFixedValue/mappedFixedValueFvPatchField.H
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
@ -83,7 +83,8 @@ SourceFiles
#define mappedFixedValueFvPatchField_H
#include "fixedValueFvPatchFields.H"
#include "interpolation.H"
//#include "interpolation.H"
#include "mappedPatchFieldBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -97,37 +98,19 @@ namespace Foam
template<class Type>
class mappedFixedValueFvPatchField
:
public fixedValueFvPatchField<Type>
public fixedValueFvPatchField<Type>,
public mappedPatchFieldBase<Type>
{
protected:
// Protected data
//- Name of field to sample - defaults to field associated with this
// patchField if not specified
word fieldName_;
//- If true adjust the mapped field to maintain average value average_
const bool setAverage_;
//- Average value the mapped field is adjusted to maintain if
// setAverage_ is set true
const Type average_;
//- Interpolation scheme to use for nearestcell mode
word interpolationScheme_;
mutable autoPtr<interpolation<Type> > interpolator_;
// Protected Member Functions
//- Field to sample. Either on my or nbr mesh
const GeometricField<Type, fvPatchField, volMesh>& sampleField() const;
//- Access the interpolation method
const interpolation<Type>& interpolator() const;
const mappedPatchBase& mapper
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
);
public:

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

@ -198,10 +198,61 @@ void Foam::fvPatchField<Type>::patchInternalField(Field<Type>& pif) const
template<class Type>
void Foam::fvPatchField<Type>::autoMap
(
const fvPatchFieldMapper& m
const fvPatchFieldMapper& mapper
)
{
Field<Type>::autoMap(m);
Field<Type>& f = *this;
if (!this->size())
{
f.setSize(mapper.size());
if (f.size())
{
f = this->patchInternalField();
}
}
else
{
// Map all faces provided with mapping data
Field<Type>::autoMap(mapper);
// For unmapped faces set to internal field value (zero-gradient)
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];
}
}
}
}
}

17
src/finiteVolume/interpolation/surfaceInterpolation/surfaceInterpolationScheme/surfaceInterpolationScheme.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
@ -171,7 +171,10 @@ surfaceInterpolationScheme<Type>::interpolate
"(const GeometricField<Type, fvPatchField, volMesh>&, "
"const tmp<surfaceScalarField>&, "
"const tmp<surfaceScalarField>&) : "
"interpolating volTypeField from cells to faces "
"interpolating "
<< vf.type() << " "
<< vf.name()
<< " from cells to faces "
"without explicit correction"
<< endl;
}
@ -252,7 +255,10 @@ surfaceInterpolationScheme<Type>::interpolate
Info<< "surfaceInterpolationScheme<Type>::interpolate"
"(const GeometricField<Type, fvPatchField, volMesh>&, "
"const tmp<surfaceScalarField>&) : "
"interpolating volTypeField from cells to faces "
"interpolating "
<< vf.type() << " "
<< vf.name()
<< " from cells to faces "
"without explicit correction"
<< endl;
}
@ -326,7 +332,10 @@ surfaceInterpolationScheme<Type>::interpolate
{
Info<< "surfaceInterpolationScheme<Type>::interpolate"
"(const GeometricField<Type, fvPatchField, volMesh>&) : "
<< "interpolating volTypeField from cells to faces"
"interpolating "
<< vf.type() << " "
<< vf.name()
<< " from cells to faces"
<< endl;
}

6
src/meshTools/sets/topoSets/faceZoneSet.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
@ -49,8 +49,8 @@ void faceZoneSet::updateSet()
{
labelList order;
sortedOrder(addressing_, order);
inplaceReorder(order, addressing_);
inplaceReorder(order, flipMap_);
addressing_ = UIndirectList<label>(addressing_, order)();
flipMap_ = UIndirectList<bool>(flipMap_, order)();
faceSet::clearStorage();
faceSet::resize(2*addressing_.size());

11
src/thermophysicalModels/specie/transport/const/constTransport.H
View File

@ -161,10 +161,13 @@ public:
// Member operators
inline constTransport& operator=
(
const constTransport&
);
inline constTransport& operator=(const constTransport&);
inline void operator+=(const constTransport&);
inline void operator-=(const constTransport&);
inline void operator*=(const scalar);
// Friend operators

46
src/thermophysicalModels/specie/transport/const/constTransportI.H
View File

@ -143,6 +143,52 @@ inline Foam::constTransport<Thermo>& Foam::constTransport<Thermo>::operator=
}
template<class Thermo>
inline void Foam::constTransport<Thermo>::operator+=
(
const constTransport<Thermo>& st
)
{
scalar molr1 = this->nMoles();
Thermo::operator+=(st);
molr1 /= this->nMoles();
scalar molr2 = st.nMoles()/this->nMoles();
mu_ = molr1*mu_ + molr2*st.mu_;
rPr_ = molr1*rPr_ + molr2*st.rPr_;
}
template<class Thermo>
inline void Foam::constTransport<Thermo>::operator-=
(
const constTransport<Thermo>& st
)
{
scalar molr1 = this->nMoles();
Thermo::operator-=(st);
molr1 /= this->nMoles();
scalar molr2 = st.nMoles()/this->nMoles();
mu_ = molr1*mu_ - molr2*st.mu_;
rPr_ = molr1*rPr_ - molr2*st.rPr_;
}
template<class Thermo>
inline void Foam::constTransport<Thermo>::operator*=
(
const scalar s
)
{
Thermo::operator*=(s);
}
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
template<class Thermo>

11
src/thermophysicalModels/specie/transport/sutherland/sutherlandTransport.H
View File

@ -180,10 +180,13 @@ public:
// Member operators
inline sutherlandTransport& operator=
(
const sutherlandTransport&
);
inline sutherlandTransport& operator=(const sutherlandTransport&);
inline void operator+=(const sutherlandTransport&);
inline void operator-=(const sutherlandTransport&);
inline void operator*=(const scalar);
// Friend operators

46
src/thermophysicalModels/specie/transport/sutherland/sutherlandTransportI.H
View File

@ -180,6 +180,52 @@ Foam::sutherlandTransport<Thermo>::operator=
}
template<class Thermo>
inline void Foam::sutherlandTransport<Thermo>::operator+=
(
const sutherlandTransport<Thermo>& st
)
{
scalar molr1 = this->nMoles();
Thermo::operator+=(st);
molr1 /= this->nMoles();
scalar molr2 = st.nMoles()/this->nMoles();
As_ = molr1*As_ + molr2*st.As_;
Ts_ = molr1*Ts_ + molr2*st.Ts_;
}
template<class Thermo>
inline void Foam::sutherlandTransport<Thermo>::operator-=
(
const sutherlandTransport<Thermo>& st
)
{
scalar molr1 = this->nMoles();
Thermo::operator-=(st);
molr1 /= this->nMoles();
scalar molr2 = st.nMoles()/this->nMoles();
As_ = molr1*As_ - molr2*st.As_;
Ts_ = molr1*Ts_ - molr2*st.Ts_;
}
template<class Thermo>
inline void Foam::sutherlandTransport<Thermo>::operator*=
(
const scalar s
)
{
Thermo::operator*=(s);
}
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
template<class Thermo>

2
src/triSurface/triSurface/interfaces/STL/readSTLASCII.L
View File

@ -55,7 +55,7 @@ int yyFlexLexer::yylex()
// It is called by yylex but is not used as the mechanism to change file.
// See <<EOF>>
//! \cond dummy
#if YY_FLEX_SUBMINOR_VERSION < 34 || YY_FLEX_SUBMINOR_VERSION > 36
#if YY_FLEX_SUBMINOR_VERSION < 34
extern "C" int yywrap()
#else
int yyFlexLexer::yywrap()

18
src/turbulenceModels/LES/LESfilters/anisotropicFilter/anisotropicFilter.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
@ -66,8 +66,12 @@ Foam::anisotropicFilter::anisotropicFilter
coeff_.internalField().replace
(
d,
(2.0/widthCoeff_)*mesh.V()
/fvc::surfaceSum(mag(mesh.Sf().component(d)))().internalField()
(1/widthCoeff_)*
sqr
(
2.0*mesh.V()
/fvc::surfaceSum(mag(mesh.Sf().component(d)))().internalField()
)
);
}
}
@ -99,8 +103,12 @@ Foam::anisotropicFilter::anisotropicFilter
coeff_.internalField().replace
(
d,
(2.0/widthCoeff_)*mesh.V()
/fvc::surfaceSum(mag(mesh.Sf().component(d)))().internalField()
(1/widthCoeff_)*
sqr
(
2.0*mesh.V()
/fvc::surfaceSum(mag(mesh.Sf().component(d)))().internalField()
)
);
}
}

6
src/turbulenceModels/LES/LESfilters/laplaceFilter/laplaceFilter.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
@ -57,7 +57,7 @@ Foam::laplaceFilter::laplaceFilter(const fvMesh& mesh, scalar widthCoeff)
calculatedFvPatchScalarField::typeName
)
{
coeff_.internalField() = pow(mesh.V(), 2.0/3.0)/widthCoeff_;
coeff_.dimensionedInternalField() = pow(mesh.V(), 2.0/3.0)/widthCoeff_;
}
@ -78,7 +78,7 @@ Foam::laplaceFilter::laplaceFilter(const fvMesh& mesh, const dictionary& bd)
calculatedFvPatchScalarField::typeName
)
{
coeff_.internalField() = pow(mesh.V(), 2.0/3.0)/widthCoeff_;
coeff_.dimensionedInternalField() = pow(mesh.V(), 2.0/3.0)/widthCoeff_;
}

4
src/turbulenceModels/incompressible/LES/dynOneEqEddy/dynOneEqEddy.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
@ -66,7 +66,7 @@ volScalarField dynOneEqEddy::ck
const volSymmTensorField MM
(
simpleFilter_(-2.0*delta()*pow(KK, 0.5)*filter_(D))
simpleFilter_(-2.0*delta()*sqrt(KK)*filter_(D))
);
const volScalarField ck

11
tutorials/multiphase/compressibleInterFoam/laminar/depthCharge2D/system/fvSchemes
View File

@ -27,14 +27,17 @@ gradSchemes
divSchemes
{
div(rho*phi,U) Gauss upwind;
div(phi,alpha) Gauss vanLeer;
div(phirb,alpha) Gauss interfaceCompression 1;
div(phid1,p_rgh) Gauss upwind;
div(phid2,p_rgh) Gauss upwind;
div(rho*phi,U) Gauss upwind;
div(phi,thermo:rhowater) Gauss upwind;
div(phi,thermo:rhoair) Gauss upwind;
div(rho*phi,T) Gauss upwind;
div(rho*phi,K) Gauss upwind;
div(phi,k) Gauss vanLeer;
div(phi,p) Gauss upwind;
div(phi,k) Gauss upwind;
div((muEff*dev2(T(grad(U))))) Gauss linear;
}

6
tutorials/multiphase/compressibleInterFoam/laminar/depthCharge2D/system/fvSolution
View File

@ -103,9 +103,9 @@ solvers
PIMPLE
{
momentumPredictor no;
transSonic no;
nOuterCorrectors 3;
nCorrectors 1;
transonic no;
nOuterCorrectors 1;
nCorrectors 2;
nNonOrthogonalCorrectors 0;
nAlphaCorr 1;
nAlphaSubCycles 1;

59
tutorials/multiphase/compressibleInterFoam/laminar/depthCharge3D/constant/transportProperties
View File

@ -1,59 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object transportProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
phases (water air);
water
{
transportModel Newtonian;
nu 1e-06;
rho 1000;
k 0; // 0.613;
Cv 4179;
equationOfState
{
type perfectFluid;
rho0 1000;
R 3000;
}
}
air
{
transportModel Newtonian;
nu 1.589e-05;
rho 1;
k 0; // 2.63e-2;
Cv 721;
equationOfState
{
type perfectFluid;
rho0 0;
R 287;
}
}
pMin pMin [ 1 -1 -2 0 0 0 0 ] 10000;
sigma sigma [ 1 0 -2 0 0 0 0 ] 0.07;
// ************************************************************************* //

11
tutorials/multiphase/compressibleInterFoam/laminar/depthCharge3D/system/fvSchemes
View File

@ -27,14 +27,17 @@ gradSchemes
divSchemes
{
div(rho*phi,U) Gauss upwind;
div(phi,alpha) Gauss vanLeer;
div(phirb,alpha) Gauss interfaceCompression 1;
div(phid1,p_rgh) Gauss upwind;
div(phid2,p_rgh) Gauss upwind;
div(rho*phi,U) Gauss upwind;
div(phi,thermo:rhowater) Gauss upwind;
div(phi,thermo:rhoair) Gauss upwind;
div(rho*phi,T) Gauss upwind;
div(rho*phi,K) Gauss upwind;
div(phi,k) Gauss vanLeer;
div(phi,p) Gauss upwind;
div(phi,k) Gauss upwind;
div((muEff*dev2(T(grad(U))))) Gauss linear;
}

6
tutorials/multiphase/compressibleInterFoam/laminar/depthCharge3D/system/fvSolution
View File

@ -103,9 +103,9 @@ solvers
PIMPLE
{
momentumPredictor no;
transSonic no;
nOuterCorrectors 3;
nCorrectors 1;
transonic no;
nOuterCorrectors 1;
nCorrectors 2;
nNonOrthogonalCorrectors 0;
nAlphaCorr 1;
nAlphaSubCycles 1;

1
tutorials/multiphase/compressibleTwoPhaseEulerFoam/bubbleColumn/0/epsilon
View File

@ -29,6 +29,7 @@ boundaryField
outlet
{
type inletOutlet;
phi phiwater;
inletValue uniform 0.1;
value uniform 0.1;
}

1
tutorials/multiphase/compressibleTwoPhaseEulerFoam/bubbleColumn/0/k
View File

@ -29,6 +29,7 @@ boundaryField
outlet
{
type inletOutlet;
phi phiwater;
inletValue uniform 1e-8;
value uniform 1e-8;
}

2
tutorials/multiphase/compressibleTwoPhaseEulerFoam/bubbleColumn/system/fvSchemes
View File

@ -35,7 +35,7 @@ divSchemes
"div\(alphaPhi.*,U.*\)" Gauss limitedLinearV 1;
"div\(phi.*,U.*\)" Gauss limitedLinearV 1;
"div\(\(alpha.*Rc\)\)" Gauss linear;
"div\(phid.*,p\)" Gauss upwind;
"div\(phi.*,.*rho.*\)" Gauss linear;
"div\(alphaPhi.*,h.*\)" Gauss limitedLinear 1;
"div\(alphaPhi.*,K.*\)" Gauss limitedLinear 1;

1
tutorials/multiphase/compressibleTwoPhaseEulerFoam/fluidisedBed/0/epsilon
View File

@ -31,6 +31,7 @@ boundaryField
outlet
{
type inletOutlet;
phi phi2;
inletValue uniform 10.0;
value uniform 10.0;
}

1
tutorials/multiphase/compressibleTwoPhaseEulerFoam/fluidisedBed/0/k
View File

@ -31,6 +31,7 @@ boundaryField
outlet
{
type inletOutlet;
phi phi2;
inletValue uniform 1.0;
value uniform 1.0;
}

2
tutorials/multiphase/compressibleTwoPhaseEulerFoam/fluidisedBed/system/fvSchemes
View File

@ -35,7 +35,7 @@ divSchemes
"div\(alphaPhi.,U.\)" Gauss limitedLinearV 1;
"div\(phi.,U.\)" Gauss limitedLinearV 1;
"div\(\(alpha.*Rc\)\)" Gauss linear;
"div\(phid.,p\)" Gauss upwind;
"div\(phi.*,.*rho.*\)" Gauss linear;
"div\(alphaPhi.,(h|e).\)" Gauss limitedLinear 1;
"div\(alphaPhi.,(K.|p)\)" Gauss limitedLinear 1;

2
tutorials/multiphase/compressibleTwoPhaseEulerFoam/mixerVessel2D/system/fvSchemes
View File

@ -35,7 +35,7 @@ divSchemes
"div\(alphaPhi.,U.\)" Gauss limitedLinearV 1;
"div\(phi.,U.\)" Gauss limitedLinearV 1;
"div\(\(alpha.*Rc\)\)" Gauss linear;
"div\(phid.,p\)" Gauss linear;
"div\(phi.*,.*rho.*\)" Gauss linear;
"div\(alphaPhi.,h.\)" Gauss limitedLinear 1;
"div\(alphaPhi.,K.\)" Gauss limitedLinear 1;

1
tutorials/multiphase/twoPhaseEulerFoam/bed/0/Theta
View File

@ -30,6 +30,7 @@ boundaryField
top
{
type inletOutlet;
phi phi1;
inletValue uniform 1.0e-8;
}

1
tutorials/multiphase/twoPhaseEulerFoam/bed/0/epsilon
View File

@ -29,6 +29,7 @@ boundaryField
top
{
type inletOutlet;
phi phi2;
inletValue uniform 10.0;
value uniform 10.0;
}

1
tutorials/multiphase/twoPhaseEulerFoam/bed/0/k
View File

@ -29,6 +29,7 @@ boundaryField
top
{
type inletOutlet;
phi phi2;
inletValue uniform 1.0;
value uniform 1.0;
}

1
tutorials/multiphase/twoPhaseEulerFoam/bed2/0/epsilon
View File

@ -27,6 +27,7 @@ boundaryField
outlet
{
type inletOutlet;
phi phi2;
inletValue uniform 10.0;
value uniform 10.0;
}

1
tutorials/multiphase/twoPhaseEulerFoam/bed2/0/k
View File

@ -27,6 +27,7 @@ boundaryField
outlet
{
type inletOutlet;
phi phi2;
inletValue uniform 1.0;
value uniform 1.0;
}

1
tutorials/multiphase/twoPhaseEulerFoam/bubbleColumn/0/Theta
View File

@ -29,6 +29,7 @@ boundaryField
outlet
{
type inletOutlet;
phi phi1;
inletValue uniform 1.0e-7;
value uniform 1.0e-7;
}

1
tutorials/multiphase/twoPhaseEulerFoam/bubbleColumn/0/epsilon
View File

@ -29,6 +29,7 @@ boundaryField
outlet
{
type inletOutlet;
phi phi2;
inletValue uniform 0.1;
value uniform 0.1;
}

1
tutorials/multiphase/twoPhaseEulerFoam/bubbleColumn/0/k
View File

@ -29,6 +29,7 @@ boundaryField
outlet
{
type inletOutlet;
phi phi2;
inletValue uniform 1e-8;
value uniform 1e-8;
}