Erstellung einer Parabel-Geometrie (FEM / Genormte Berechnungen/OpenFOAM)

auf der http://foam.sourceforge.net/docs/cpp/a08098_source.html habe ich das. Was ist das und kann man damit Arbeit?! Kann ich damit den Solver füttern, die Werte anpassen und dann läufts?

00001 /*---------------------------------------------------------------------------*\
00002 ========= |
00003 \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
00004 \\ / O peration |
00005 \\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
00006 \\/ M anipulation |
00007 -------------------------------------------------------------------------------
00008 License
00009 This file is part of OpenFOAM.
00010
00011 OpenFOAM is free software: you can redistribute it and/or modify it
00012 under the terms of the GNU General Public License as published by
00013 the Free Software Foundation, either version 3 of the License, or
00014 (at your option) any later version.
00015
00016 OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
00017 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00018 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
00019 for more details.
00020
00021 You should have received a copy of the GNU General Public License
00022 along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
00023
00024 \*---------------------------------------------------------------------------*/
00025
00026 #include "fvDOM.H"
00027 #include "addToRunTimeSelectionTable.H"
00028
00029 #include "absorptionEmissionModel.H"
00030 #include "scatterModel.H"
00031 #include "constants.H"
00032
00033 using namespace Foam::constant;
00034 using namespace Foam::constant::mathematical;
00035
00036 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
00037
00038 namespace Foam
00039 {
00040 namespace radiation
00041 {
00042 defineTypeNameAndDebug(fvDOM, 0);
00043
00044 addToRunTimeSelectionTable
00045 (
00046 radiationModel,
00047 fvDOM,
00048 dictionary
00049 );
00050 }
00051 }
00052
00053
00054 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
00055
00056 Foam::radiation::fvDOM::fvDOM(const volScalarField& T)
00057 :
00058 radiationModel(typeName, T),
00059 G_
00060 (
00061 IOobject
00062 (
00063 "G",
00064 mesh_.time().timeName(),
00065 mesh_,
00066 IOobject::READ_IF_PRESENT,
00067 IOobject::AUTO_WRITE
00068 ),
00069 mesh_,
00070 dimensionedScalar("G", dimMass/pow3(dimTime), 0.0)
00071 ),
00072 Qr_
00073 (
00074 IOobject
00075 (
00076 "Qr",
00077 mesh_.time().timeName(),
00078 mesh_,
00079 IOobject::READ_IF_PRESENT,
00080 IOobject::AUTO_WRITE
00081 ),
00082 mesh_,
00083 dimensionedScalar("Qr", dimMass/pow3(dimTime), 0.0)
00084 ),
00085 Qem_
00086 (
00087 IOobject
00088 (
00089 "Qem",
00090 mesh_.time().timeName(),
00091 mesh_,
00092 IOobject::NO_READ,
00093 IOobject::NO_WRITE
00094 ),
00095 mesh_,
00096 dimensionedScalar("Qem", dimMass/pow3(dimTime), 0.0)
00097 ),
00098 Qin_
00099 (
00100 IOobject
00101 (
00102 "Qin",
00103 mesh_.time().timeName(),
00104 mesh_,
00105 IOobject::READ_IF_PRESENT,
00106 IOobject::AUTO_WRITE
00107 ),
00108 mesh_,
00109 dimensionedScalar("Qin", dimMass/pow3(dimTime), 0.0)
00110 ),
00111 a_
00112 (
00113 IOobject
00114 (
00115 "a",
00116 mesh_.time().timeName(),
00117 mesh_,
00118 IOobject::NO_READ,
00119 IOobject::NO_WRITE
00120 ),
00121 mesh_,
00122 dimensionedScalar("a", dimless/dimLength, 0.0)
00123 ),
00124 nTheta_(readLabel(coeffs_.lookup("nTheta"))),
00125 nPhi_(readLabel(coeffs_.lookup("nPhi"))),
00126 nRay_(0),
00127 nLambda_(absorptionEmission_->nBands()),
00128 aLambda_(nLambda_),
00129 blackBody_(nLambda_, T),
00130 IRay_(0),
00131 convergence_(coeffs_.lookupOrDefault<scalar>("convergence", 0.0)),
00132 maxIter_(coeffs_.lookupOrDefault<label>("maxIter", 50))
00133 {
00134 if (mesh_.nSolutionD() == 3) //3D
00135 {
00136 nRay_ = 4*nPhi_*nTheta_;
00137 IRay_.setSize(nRay_);
00138 scalar deltaPhi = pi/(2.0*nPhi_);
00139 scalar deltaTheta = pi/nTheta_;
00140 label i = 0;
00141 for (label n = 1; n <= nTheta_; n++)
00142 {
00143 for (label m = 1; m <= 4*nPhi_; m++)
00144 {
00145 scalar thetai = (2.0*n - 1.0)*deltaTheta/2.0;
00146 scalar phii = (2.0*m - 1.0)*deltaPhi/2.0;
00147 IRay_.set
00148 (
00149 i,
00150 new radiativeIntensityRay
00151 (
00152 *this,
00153 mesh_,
00154 phii,
00155 thetai,
00156 deltaPhi,
00157 deltaTheta,
00158 nLambda_,
00159 absorptionEmission_,
00160 blackBody_,
00161 i
00162 )
00163 );
00164 i++;
00165 }
00166 }
00167 }
00168 else
00169 {
00170 if (mesh_.nSolutionD() == 2) //2D (X & Y)
00171 {
00172 scalar thetai = piByTwo;
00173 scalar deltaTheta = pi;
00174 nRay_ = 4*nPhi_;
00175 IRay_.setSize(nRay_);
00176 scalar deltaPhi = pi/(2.0*nPhi_);
00177 label i = 0;
00178 for (label m = 1; m <= 4*nPhi_; m++)
00179 {
00180 scalar phii = (2.0*m - 1.0)*deltaPhi/2.0;
00181 IRay_.set
00182 (
00183 i,
00184 new radiativeIntensityRay
00185 (
00186 *this,
00187 mesh_,
00188 phii,
00189 thetai,
00190 deltaPhi,
00191 deltaTheta,
00192 nLambda_,
00193 absorptionEmission_,
00194 blackBody_,
00195 i
00196 )
00197 );
00198 i++;
00199 }
00200 }
00201 else //1D (X)
00202 {
00203 scalar thetai = piByTwo;
00204 scalar deltaTheta = pi;
00205 nRay_ = 2;
00206 IRay_.setSize(nRay_);
00207 scalar deltaPhi = pi;
00208 label i = 0;
00209 for (label m = 1; m <= 2; m++)
00210 {
00211 scalar phii = (2.0*m - 1.0)*deltaPhi/2.0;
00212 IRay_.set
00213 (
00214 i,
00215 new radiativeIntensityRay
00216 (
00217 *this,
00218 mesh_,
00219 phii,
00220 thetai,
00221 deltaPhi,
00222 deltaTheta,
00223 nLambda_,
00224 absorptionEmission_,
00225 blackBody_,
00226 i
00227 )
00228 );
00229 i++;
00230 }
00231 }
00232 }
00233
00234
00235 // Construct absorption field for each wavelength
00236 forAll(aLambda_, lambdaI)
00237 {
00238 aLambda_.set
00239 (
00240 lambdaI,
00241 new volScalarField
00242 (
00243 IOobject
00244 (
00245 "aLambda_" + Foam::name(lambdaI) ,
00246 mesh_.time().timeName(),
00247 mesh_,
00248 IOobject::NO_READ,
00249 IOobject::NO_WRITE
00250 ),
00251 a_
00252 )
00253 );
00254 }
00255
00256 Info<< "fvDOM : Allocated " << IRay_.size()
00257 << " rays with average orientation:" << nl;
00258 forAll(IRay_, i)
00259 {
00260 Info<< '\t' << IRay_[i].I().name()
00261 << '\t' << IRay_[i].dAve() << nl;
00262 }
00263 Info<< endl;
00264 }
00265
00266
00267 // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
00268
00269 Foam::radiation::fvDOM::~fvDOM()
00270 {}
00271
00272
00273 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
00274
00275 bool Foam::radiation::fvDOM::read()
00276 {
00277 if (radiationModel::read())
00278 {
00279 // Only reading solution parameters - not changing ray geometry
00280
00281 coeffs_.readIfPresent("convergence", convergence_);
00282 coeffs_.readIfPresent("maxIter", maxIter_);
00283
00284 return true;
00285 }
00286 else
00287 {
00288 return false;
00289 }
00290 }
00291
00292
00293 void Foam::radiation::fvDOM::calculate()
00294 {
00295 absorptionEmission_->correct(a_, aLambda_);
00296
00297 updateBlackBodyEmission();
00298
00299 scalar maxResidual = 0.0;
00300 label radIter = 0;
00301 do
00302 {
00303 radIter++;
00304 forAll(IRay_, rayI)
00305 {
00306 maxResidual = 0.0;
00307 scalar maxBandResidual = IRay_[rayI].correct();
00308 maxResidual = max(maxBandResidual, maxResidual);
00309 }
00310
00311 Info<< "Radiation solver iter: " << radIter << endl;
00312
00313 } while (maxResidual > convergence_ && radIter < maxIter_);
00314
00315 updateG();
00316 }
00317
00318
00319 Foam::tmp<Foam::volScalarField> Foam::radiation::fvDOM::Rp() const
00320 {
00321 return tmp<volScalarField>
00322 (
00323 new volScalarField
00324 (
00325 IOobject
00326 (
00327 "Rp",
00328 mesh_.time().timeName(),
00329 mesh_,
00330 IOobject::NO_READ,
00331 IOobject::NO_WRITE,
00332 false
00333 ),
00334 4.0*a_*physicoChemical::sigma //absorptionEmission_->a()
00335 )
00336 );
00337 }
00338
00339
00340 Foam::tmp<Foam: imensionedField<Foam::scalar, Foam::volMesh> >
00341 Foam::radiation::fvDOM::Ru() const
00342 {
00343
00344 const DimensionedField<scalar, volMesh>& G =
00345 G_.dimensionedInternalField();
00346 const DimensionedField<scalar, volMesh> E =
00347 absorptionEmission_->ECont()().dimensionedInternalField();
00348 const DimensionedField<scalar, volMesh> a =
00349 a_.dimensionedInternalField(); //absorptionEmission_->aCont()()
00350
00351 return a*G - E;
00352 }
00353
00354
00355 void Foam::radiation::fvDOM::updateBlackBodyEmission()
00356 {
00357 for (label j=0; j < nLambda_; j++)
00358 {
00359 blackBody_.correct(j, absorptionEmission_->bands(j));
00360 }
00361 }
00362
00363
00364 void Foam::radiation::fvDOM::updateG()
00365 {
00366 G_ = dimensionedScalar("zero",dimMass/pow3(dimTime), 0.0);
00367 Qr_ = dimensionedScalar("zero",dimMass/pow3(dimTime), 0.0);
00368 Qem_ = dimensionedScalar("zero", dimMass/pow3(dimTime), 0.0);
00369 Qin_ = dimensionedScalar("zero", dimMass/pow3(dimTime), 0.0);
00370
00371 forAll(IRay_, rayI)
00372 {
00373 IRay_[rayI].addIntensity();
00374 G_ += IRay_[rayI].I()*IRay_[rayI].omega();
00375 Qr_.boundaryField() += IRay_[rayI].Qr().boundaryField();
00376 Qem_.boundaryField() += IRay_[rayI].Qem().boundaryField();
00377 Qin_.boundaryField() += IRay_[rayI].Qin().boundaryField();
00378 }
00379 }
00380
00381
00382 void Foam::radiation::fvDOM::setRayIdLambdaId
00383 (
00384 const word& name,
00385 label& rayId,
00386 label& lambdaId
00387 ) const
00388 {
00389 // assuming name is in the form: CHARS_rayId_lambdaId
00390 size_type i1 = name.find_first_of("_");
00391 size_type i2 = name.find_last_of("_");
00392
00393 rayId = readLabel(IStringStream(name.substr(i1+1, i2-1))());
00394 lambdaId = readLabel(IStringStream(name.substr(i2+1, name.size()-1))());
00395 }
00396
00397
00398 // ************************************************************************* //

------------------
Liebe Grüße vom OpenFOAM-Neuling,
Kosta

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP