zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-12-28 03:37:59 +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-01-23 10:30:30 +00:00
parent c063a100f0 1bd6b1bbb7
commit 91300187a6
40 changed files with 1792 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionFoam.C
View File

@ -40,13 +40,14 @@ Description
#include "rhoThermo.H"
#include "turbulenceModel.H"
#include "fixedGradientFvPatchFields.H"
#include "zeroGradientFvPatchFields.H"
#include "regionProperties.H"
#include "compressibleCourantNo.H"
#include "solidRegionDiffNo.H"
#include "solidThermo.H"
#include "radiationModel.H"
#include "fvIOoptionList.H"
#include "coordinateSystem.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

1
applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/chtMultiRegionSimpleFoam.C
View File

@ -37,6 +37,7 @@ Description
#include "solidThermo.H"
#include "radiationModel.H"
#include "fvIOoptionList.H"
#include "coordinateSystem.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/solid/solveSolid.H
View File

@ -3,7 +3,9 @@
{
fvScalarMatrix hEqn
(
- fvm::laplacian(betav*alpha, h, "laplacian(alpha,h)")
thermo.isotropic()
? -fvm::laplacian(betav*thermo.alpha(), h, "laplacian(alpha,h)")
: -fvm::laplacian(betav*tAnialpha(), h, "laplacian(alpha,h)")
+ fvOptions(rho, h)
);

11
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/createSolidFields.H
View File

@ -1,4 +1,5 @@
// Initialise solid field pointer lists
PtrList<coordinateSystem> coordinates(solidRegions.size());
PtrList<solidThermo> thermos(solidRegions.size());
PtrList<radiation::radiationModel> radiations(solidRegions.size());
PtrList<fv::IOoptionList> solidHeatSources(solidRegions.size());
@ -23,6 +24,16 @@
new fv::IOoptionList(solidRegions[i])
);
if (!thermos[i].isotropic())
{
Info<< " Adding coordinateSystems\n" << endl;
coordinates.set
(
i,
coordinateSystem::New(solidRegions[i], thermos[i])
);
}
IOobject betavSolidIO
(
"betavSolid",

34
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/setRegionSolidFields.H
View File

@ -8,10 +8,36 @@
tmp<volScalarField> tcp = thermo.Cp();
const volScalarField& cp = tcp();
tmp<volScalarField> talpha = thermo.alpha();
const volScalarField& alpha = talpha();
tmp<volScalarField> tkappa = thermo.kappa();
const volScalarField& kappa = tkappa();
tmp<volSymmTensorField> tAnialpha;
if (!thermo.isotropic())
{
tmp<volVectorField> tkappaCp = thermo.Kappa()/cp;
const coordinateSystem& coodSys = coordinates[i];
tAnialpha =
tmp<volSymmTensorField>
(
new volSymmTensorField
(
IOobject
(
"Anialpha",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
tkappaCp().dimensions(),
zeroGradientFvPatchVectorField::typeName
)
);
volSymmTensorField& Anialpha = tAnialpha();
Anialpha.internalField() = coodSys.R().transformVector(tkappaCp());
Anialpha.correctBoundaryConditions();
}
volScalarField& h = thermo.he();

36
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffNo.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) 2013-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -56,38 +56,4 @@ Foam::scalar Foam::solidRegionDiffNo
return DiNum;
}
Foam::scalar Foam::solidRegionDiffNo
(
const fvMesh& mesh,
const Time& runTime,
const volScalarField& Cprho,
const volSymmTensorField& kappadirectional
)
{
scalar DiNum = 0.0;
scalar meanDiNum = 0.0;
volScalarField kappa(mag(kappadirectional));
//- Take care: can have fluid domains with 0 cells so do not test for
// zero internal faces.
surfaceScalarField kapparhoCpbyDelta
(
mesh.surfaceInterpolation::deltaCoeffs()
* fvc::interpolate(kappa)
/ fvc::interpolate(Cprho)
);
DiNum = gMax(kapparhoCpbyDelta.internalField())*runTime.deltaT().value();
meanDiNum = (average(kapparhoCpbyDelta)).value()*runTime.deltaT().value();
Info<< "Region: " << mesh.name() << " Diffusion Number mean: " << meanDiNum
<< " max: " << DiNum << endl;
return DiNum;
}
// ************************************************************************* //

11
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffNo.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) 2013-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -41,15 +41,6 @@ namespace Foam
const volScalarField& Cprho,
const volScalarField& kappa
);
scalar solidRegionDiffNo
(
const fvMesh& mesh,
const Time& runTime,
const volScalarField& Cprho,
const volSymmTensorField& kappa
);
}
#endif

41
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffusionNo.H
View File

@ -1,18 +1,29 @@
scalar DiNum = -GREAT;
scalar DiNum = -GREAT;
forAll(solidRegions, i)
forAll(solidRegions, i)
{
#include "setRegionSolidFields.H"
tmp<volScalarField> magKappa;
if (thermo.isotropic())
{
#include "setRegionSolidFields.H"
DiNum = max
(
solidRegionDiffNo
(
solidRegions[i],
runTime,
rho*cp,
kappa
),
DiNum
);
magKappa = thermo.kappa();
}
else
{
magKappa = mag(thermo.Kappa());
}
DiNum = max
(
solidRegionDiffNo
(
solidRegions[i],
runTime,
rho*cp,
magKappa()
),
DiNum
);
}

6
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solveSolid.H
View File

@ -9,7 +9,11 @@ if (finalIter)
tmp<fvScalarMatrix> hEqn
(
fvm::ddt(betav*rho, h)
- fvm::laplacian(betav*alpha, h, "laplacian(alpha,h)")
- (
thermo.isotropic()
? fvm::laplacian(betav*thermo.alpha(), h, "laplacian(alpha,h)")
: fvm::laplacian(betav*tAnialpha(), h, "laplacian(alpha,h)")
)
==
fvOptions(rho, h)
);

3
applications/test/PatchTools/Make/files Normal file
View File

@ -0,0 +1,3 @@
Test-PatchTools.C
EXE = $(FOAM_USER_APPBIN)/Test-PatchTools

7
applications/test/PatchTools/Make/options Normal file
View File

@ -0,0 +1,7 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/surfMesh/lnInclude
EXE_LIBS = \
-lfiniteVolume

297
applications/test/PatchTools/Test-PatchTools.C Normal file
View File

@ -0,0 +1,297 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-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/>.
Application
testPatchTools
Description
Test app for PatchTools functionality
\*---------------------------------------------------------------------------*/
#include "PatchTools.H"
#include "argList.H"
#include "fvMesh.H"
#include "volFields.H"
#include "Time.H"
#include "OBJstream.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
//template<class PatchType>
//Foam::tmp<Foam::pointField>
//areaPointNormals
//(
// const polyMesh& mesh,
// const PatchType& p,
// const labelList& meshFaces
//)
//{
// // Assume patch is smaller than the globalData().coupledPatch() (?) so
// // loop over patch meshPoints.
//
// const labelList& meshPoints = p.meshPoints();
//
// const globalMeshData& globalData = mesh.globalData();
// const indirectPrimitivePatch& coupledPatch = globalData.coupledPatch();
// const Map<label>& coupledPatchMP = coupledPatch.meshPointMap();
// const mapDistribute& map = globalData.globalPointSlavesMap();
// const globalIndexAndTransform& transforms =
// globalData.globalTransforms();
//
//
// // 1. Start off with local (area-weighted) normals
// // (note:without calculating pointNormals
// // to avoid them being stored)
//
// tmp<pointField> textrudeN(new pointField(p.nPoints(), vector::zero));
// pointField& extrudeN = textrudeN();
// {
// const faceList& localFaces = p.localFaces();
// const vectorField& faceAreas = mesh.faceAreas();
//
// forAll(localFaces, faceI)
// {
// const face& f = localFaces[faceI];
// const vector& n = faceAreas[meshFaces[faceI]];
// forAll(f, fp)
// {
// extrudeN[f[fp]] += n;
// }
// }
// }
//
//
// // Collect local pointFaces
// List<List<point> > pointFaceNormals(map.constructSize());
// {
// const vectorField& faceAreas = mesh.faceAreas();
//
// forAll(meshPoints, patchPointI)
// {
// label meshPointI = meshPoints[patchPointI];
// Map<label>::const_iterator fnd = coupledPatchMP.find(meshPointI);
// if (fnd != coupledPatchMP.end())
// {
// label coupledPointI = fnd();
//
// List<point>& pNormals = pointFaceNormals[coupledPointI];
// const labelList& pFaces = p.pointFaces()[patchPointI];
// pNormals.setSize(pFaces.size());
// forAll(pFaces, i)
// {
// pNormals[i] = faceAreas[meshFaces[pFaces[i]]];
// }
// }
// }
// }
//
// // Pull remote data into local slots
// map.distribute
// (
// transforms,
// pointFaceNormals,
// listTransform()
// );
//
//
// // Combine normals
// const labelListList& slaves = globalData.globalPointSlaves();
// const labelListList& transformedSlaves =
// globalData.globalPointTransformedSlaves();
//
//
// pointField coupledPointNormals(map.constructSize(), vector::zero);
//
// forAll(meshPoints, patchPointI)
// {
// label meshPointI = meshPoints[patchPointI];
// Map<label>::const_iterator fnd = coupledPatchMP.find(meshPointI);
// if (fnd != coupledPatchMP.end())
// {
// label coupledPointI = fnd();
// const labelList& slaveSlots = slaves[coupledPointI];
// const labelList& transformedSlaveSlots =
// transformedSlaves[coupledPointI];
//
// label nFaces = slaveSlots.size()+transformedSlaveSlots.size();
// if (nFaces > 0)
// {
// // Combine
// point& n = coupledPointNormals[coupledPointI];
//
// n += sum(pointFaceNormals[coupledPointI]);
//
// forAll(slaveSlots, i)
// {
// n += sum(pointFaceNormals[slaveSlots[i]]);
// }
// forAll(transformedSlaveSlots, i)
// {
// n += sum(pointFaceNormals[transformedSlaveSlots[i]]);
// }
//
// // Put back into slave slots
// forAll(slaveSlots, i)
// {
// coupledPointNormals[slaveSlots[i]] = n;
// }
// forAll(transformedSlaveSlots, i)
// {
// coupledPointNormals[transformedSlaveSlots[i]] = n;
// }
// }
// }
// }
//
//
// // Send back
// map.reverseDistribute
// (
// transforms,
// coupledPointNormals.size(),
// coupledPointNormals,
// mapDistribute::transform()
// );
//
//
// // Override patch normals
// forAll(meshPoints, patchPointI)
// {
// label meshPointI = meshPoints[patchPointI];
// Map<label>::const_iterator fnd = coupledPatchMP.find(meshPointI);
// if (fnd != coupledPatchMP.end())
// {
// label coupledPointI = fnd();
// extrudeN[patchPointI] = coupledPointNormals[coupledPointI];
// }
// }
//
// extrudeN /= mag(extrudeN)+VSMALL;
//
// return textrudeN;
//}
// Main program:
int main(int argc, char *argv[])
{
# include "addTimeOptions.H"
argList::validArgs.append("patch");
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
const word patchName = args[1];
label patchI = mesh.boundaryMesh().findPatchID(patchName);
const polyPatch& pp = mesh.boundaryMesh()[patchI];
const indirectPrimitivePatch& cpp = mesh.globalData().coupledPatch();
{
OBJstream str(runTime.path()/"edgePatchNormals.obj");
labelList patchEdges;
labelList coupledEdges;
PackedBoolList sameEdgeOrientation;
PatchTools::matchEdges
(
pp,
cpp,
patchEdges,
coupledEdges,
sameEdgeOrientation
);
const pointField en
(
PatchTools::edgeNormals
(
mesh,
pp,
patchEdges,
coupledEdges
)
);
forAll(en, patchEdgeI)
{
const edge& patchE = pp.edges()[patchEdgeI];
//str.write(pp.localPoints()[pointI], en[pointI]);
const point pt = patchE.centre(pp.localPoints());
str.write(linePointRef(pt, pt + 0.1*en[patchEdgeI]));
}
}
return 0;
// {
// OBJstream str(runTime.path()/"unweightedPatchNormals.obj");
//
// const pointField pn
// (
// PatchTools::pointNormals
// (
// mesh,
// pp,
// identity(pp.size())+pp.start()
// )
// );
// forAll(pn, pointI)
// {
// str.write(linePointRef(pp.localPoints()[pointI], pn[pointI]));
// }
// }
// {
// OBJstream str(runTime.path()/"areaWeightedPatchNormals.obj");
//
// const pointField pn
// (
// areaPointNormals
// (
// mesh,
// pp,
// identity(pp.size())+pp.start()
// )
// );
// forAll(pn, pointI)
// {
// str.write(linePointRef(pp.localPoints()[pointI], pn[pointI]));
// }
// }
Pout<< "End\n" << endl;
return 0;
}
// ************************************************************************* //