filmPyrolysisVelocityCoupledFvPatchVectorField.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | www.openfoam.com
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8  Copyright (C) 2011-2017 OpenFOAM Foundation
9  Copyright (C) 2020 OpenCFD Ltd.
10 -------------------------------------------------------------------------------
11 License
12  This file is part of OpenFOAM.
13 
14  OpenFOAM is free software: you can redistribute it and/or modify it
15  under the terms of the GNU General Public License as published by
16  the Free Software Foundation, either version 3 of the License, or
17  (at your option) any later version.
18 
19  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
20  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22  for more details.
23 
24  You should have received a copy of the GNU General Public License
25  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
26 
27 \*---------------------------------------------------------------------------*/
28 
31 #include "surfaceFields.H"
32 #include "pyrolysisModel.H"
33 #include "surfaceFilmRegionModel.H"
34 
35 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
36 
39 (
40  const fvPatch& p,
42 )
43 :
44  fixedValueFvPatchVectorField(p, iF),
45  filmRegionName_("surfaceFilmProperties"),
46  pyrolysisRegionName_("pyrolysisProperties"),
47  phiName_("phi"),
48  rhoName_("rho")
49 {}
50 
51 
54 (
56  const fvPatch& p,
58  const fvPatchFieldMapper& mapper
59 )
60 :
61  fixedValueFvPatchVectorField(ptf, p, iF, mapper),
62  filmRegionName_(ptf.filmRegionName_),
63  pyrolysisRegionName_(ptf.pyrolysisRegionName_),
64  phiName_(ptf.phiName_),
65  rhoName_(ptf.rhoName_)
66 {}
67 
68 
71 (
72  const fvPatch& p,
74  const dictionary& dict
75 )
76 :
77  fixedValueFvPatchVectorField(p, iF, dict),
78  filmRegionName_
79  (
80  dict.getOrDefault<word>("filmRegion", "surfaceFilmProperties")
81  ),
82  pyrolysisRegionName_
83  (
84  dict.getOrDefault<word>("pyrolysisRegion", "pyrolysisProperties")
85  ),
86  phiName_(dict.getOrDefault<word>("phi", "phi")),
87  rhoName_(dict.getOrDefault<word>("rho", "rho"))
88 {}
89 
90 
93 (
95 )
96 :
97  fixedValueFvPatchVectorField(fpvpvf),
98  filmRegionName_(fpvpvf.filmRegionName_),
99  pyrolysisRegionName_(fpvpvf.pyrolysisRegionName_),
100  phiName_(fpvpvf.phiName_),
101  rhoName_(fpvpvf.rhoName_)
102 {}
103 
104 
107 (
110 )
111 :
112  fixedValueFvPatchVectorField(fpvpvf, iF),
113  filmRegionName_(fpvpvf.filmRegionName_),
114  pyrolysisRegionName_(fpvpvf.pyrolysisRegionName_),
115  phiName_(fpvpvf.phiName_),
116  rhoName_(fpvpvf.rhoName_)
117 {}
118 
119 
120 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
121 
123 {
124  if (updated())
125  {
126  return;
127  }
128 
129  // Film model
130  const auto* filmModelPtr = db().time().findObject
132  (filmRegionName_);
133 
134  // Pyrolysis model
135  const auto* pyrModelPtr = db().time().findObject
137  (pyrolysisRegionName_);
138 
139 
140  if (!filmModelPtr || !pyrModelPtr)
141  {
142  // Do nothing on construction - film model doesn't exist yet
143  return;
144  }
145 
146  const auto& filmModel = *filmModelPtr;
147  const auto& pyrModel = *pyrModelPtr;
148 
149 
150  // Since we're inside initEvaluate/evaluate there might be processor
151  // comms underway. Change the tag we use.
152  int oldTag = UPstream::msgType();
153  UPstream::msgType() = oldTag+1;
154 
155 
156  vectorField& Up = *this;
157 
158  const label patchi = patch().index();
159 
160  // The film model
161  const label filmPatchi = filmModel.regionPatchID(patchi);
162 
163  scalarField alphaFilm = filmModel.alpha().boundaryField()[filmPatchi];
164  filmModel.toPrimary(filmPatchi, alphaFilm);
165 
166  vectorField UFilm = filmModel.Us().boundaryField()[filmPatchi];
167  filmModel.toPrimary(filmPatchi, UFilm);
168 
169  // The pyrolysis model
170  const label pyrPatchi = pyrModel.regionPatchID(patchi);
171 
172  scalarField phiPyr = pyrModel.phiGas().boundaryField()[pyrPatchi];
173  pyrModel.toPrimary(pyrPatchi, phiPyr);
174 
175 
176  const surfaceScalarField& phi =
177  db().lookupObject<surfaceScalarField>(phiName_);
178 
179  if (phi.dimensions() == dimVelocity*dimArea)
180  {}
181  else if (phi.dimensions() == dimDensity*dimVelocity*dimArea)
182  {
183  const fvPatchField<scalar>& rhop =
184  patch().lookupPatchField<volScalarField, scalar>(rhoName_);
185  phiPyr /= rhop;
186  }
187  else
188  {
190  << "Unable to process flux field phi with dimensions "
191  << phi.dimensions() << nl
192  << " on patch " << patch().name()
193  << " of field " << internalField().name()
194  << " in file " << internalField().objectPath()
195  << exit(FatalError);
196  }
197 
198  const scalarField UAvePyr(-phiPyr/patch().magSf());
199  const vectorField& nf = patch().nf();
200 
201 
202  // Evaluate velocity
203  Up = alphaFilm*UFilm + (1.0 - alphaFilm)*UAvePyr*nf;
204 
205  // Restore tag
206  UPstream::msgType() = oldTag;
207 
208  fixedValueFvPatchVectorField::updateCoeffs();
209 }
210 
211 
213 (
214  Ostream& os
215 ) const
216 {
219  (
220  "filmRegion",
221  "surfaceFilmProperties",
222  filmRegionName_
223  );
225  (
226  "pyrolysisRegion",
227  "pyrolysisProperties",
228  pyrolysisRegionName_
229  );
230  os.writeEntryIfDifferent<word>("phi", "phi", phiName_);
231  os.writeEntryIfDifferent<word>("rho", "rho", rhoName_);
232  writeEntry("value", os);
233 }
234 
235 
236 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
237 
238 namespace Foam
239 {
241  (
244  );
245 }
246 
247 
248 // ************************************************************************* //
Foam::regionModels::pyrolysisModels::pyrolysisModel
Base class for pyrolysis models.
Definition: pyrolysisModel.H:61
Foam::fvPatchField< scalar >
Foam::filmPyrolysisVelocityCoupledFvPatchVectorField::write
virtual void write(Ostream &) const
Write.
Definition: filmPyrolysisVelocityCoupledFvPatchVectorField.C:213
Foam::fvPatchField< vector >::write
virtual void write(Ostream &) const
Write.
Definition: fvPatchField.C:384
Foam::Ostream::writeEntryIfDifferent
Ostream & writeEntryIfDifferent(const word &key, const T &value1, const T &value2)
Write a keyword/value entry only when the two values differ.
Definition: Ostream.H:248
p
volScalarField & p
Definition: createFieldRefs.H:8
Foam::word
A class for handling words, derived from Foam::string.
Definition: word.H:65
Foam::dimVelocity
const dimensionSet dimVelocity
Foam::dimDensity
const dimensionSet dimDensity
Foam::filmPyrolysisVelocityCoupledFvPatchVectorField
This boundary condition is designed to be used in conjunction with surface film and pyrolysis modelli...
Definition: filmPyrolysisVelocityCoupledFvPatchVectorField.H:69
Foam::regionModels::regionModel::time
const Time & time() const
Return the reference to the time database.
Definition: regionModelI.H:40
surfaceFields.H
Foam::surfaceFields.
surfaceFilmRegionModel.H
pyrolysisModel.H
Foam::dimArea
const dimensionSet dimArea(sqr(dimLength))
Definition: dimensionSets.H:59
Foam::filmPyrolysisVelocityCoupledFvPatchVectorField::filmPyrolysisVelocityCoupledFvPatchVectorField
filmPyrolysisVelocityCoupledFvPatchVectorField(const fvPatch &, const DimensionedField< vector, volMesh > &)
Construct from patch and internal field.
Definition: filmPyrolysisVelocityCoupledFvPatchVectorField.C:39
Foam::Field< vector >
Foam::regionModels::surfaceFilmModels::surfaceFilmRegionModel
Base class for surface film models.
Definition: surfaceFilmRegionModel.H:55
Foam::fvPatch
A finiteVolume patch using a polyPatch and a fvBoundaryMesh.
Definition: fvPatch.H:65
phi
surfaceScalarField & phi
Definition: setRegionFluidFields.H:8
Foam::volScalarField
GeometricField< scalar, fvPatchField, volMesh > volScalarField
Definition: volFieldsFwd.H:57
dict
dictionary dict
Definition: searchingEngine.H:14
Foam::FatalError
error FatalError
Foam::dictionary
A list of keyword definitions, which are a keyword followed by a number of values (eg,...
Definition: dictionary.H:123
os
OBJstream os(runTime.globalPath()/outputName)
addToRunTimeSelectionTable.H
Macros for easy insertion into run-time selection tables.
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:33
Foam::exit
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:130
filmPyrolysisVelocityCoupledFvPatchVectorField.H
FatalErrorInFunction
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:453
Foam::UPstream::msgType
static int & msgType() noexcept
Message tag of standard messages.
Definition: UPstream.H:540
Foam::objectRegistry::findObject
const Type * findObject(const word &name, const bool recursive=false) const
Return const pointer to the object of the given Type.
Definition: objectRegistryTemplates.C:401
Foam::nl
constexpr char nl
Definition: Ostream.H:404
Foam::foamVersion::patch
const std::string patch
OpenFOAM patch number as a std::string.
Foam::fvPatchFieldMapper
Foam::fvPatchFieldMapper.
Definition: fvPatchFieldMapper.H:47
Foam::Ostream
An Ostream is an abstract base class for all output systems (streams, files, token lists,...
Definition: Ostream.H:56
Foam::makePatchTypeField
makePatchTypeField(fvPatchScalarField, atmBoundaryLayerInletEpsilonFvPatchScalarField)
Foam::filmPyrolysisVelocityCoupledFvPatchVectorField::updateCoeffs
virtual void updateCoeffs()
Update the coefficients associated with the patch field.
Definition: filmPyrolysisVelocityCoupledFvPatchVectorField.C:122
Foam::GeometricField< scalar, fvsPatchField, surfaceMesh >
Foam::DimensionedField
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
Definition: DimensionedField.H:54