rPolynomialI.H
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) 2019 OpenFOAM Foundation
9 -------------------------------------------------------------------------------
10 License
11  This file is part of OpenFOAM.
12 
13  OpenFOAM is free software: you can redistribute it and/or modify it
14  under the terms of the GNU General Public License as published by
15  the Free Software Foundation, either version 3 of the License, or
16  (at your option) any later version.
17 
18  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21  for more details.
22 
23  You should have received a copy of the GNU General Public License
24  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
25 
26 \*---------------------------------------------------------------------------*/
27 
28 #include "rPolynomial.H"
29 
30 // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
31 
32 template<class Specie>
34 (
35  const Specie& sp,
36  const coeffList& coeffs
37 )
38 :
39  Specie(sp),
40  C_(coeffs)
41 {}
42 
43 
44 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
45 
46 template<class Specie>
48 (
49  const word& name,
50  const rPolynomial<Specie>& rp
51 )
52 :
53  Specie(name, rp),
54  C_(rp.C_)
55 {}
56 
57 
58 template<class Specie>
61 {
62  return autoPtr<rPolynomial<Specie>>::New(*this);
63 }
64 
65 
66 template<class Specie>
69 (
70  const dictionary& dict
71 )
72 {
74 }
75 
76 
77 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
78 
79 template<class Specie>
80 inline Foam::scalar Foam::rPolynomial<Specie>::rho(scalar p, scalar T) const
81 {
82  return 1/(C_[0] + (C_[1] + C_[2]*T - C_[4]*p)*T - C_[3]*p);
83 }
84 
85 
86 template<class Specie>
87 inline Foam::scalar Foam::rPolynomial<Specie>::H(scalar p, scalar T) const
88 {
89  return 0;
90 }
91 
92 
93 template<class Specie>
94 inline Foam::scalar Foam::rPolynomial<Specie>::Cp(scalar p, scalar T) const
95 {
96  return 0;
97 }
98 
99 
100 template<class Specie>
101 inline Foam::scalar Foam::rPolynomial<Specie>::E(scalar p, scalar T) const
102 {
103  return 0;
104 }
105 
106 
107 template<class Specie>
108 inline Foam::scalar Foam::rPolynomial<Specie>::Cv(scalar p, scalar T) const
109 {
110  return 0;
111 }
112 
113 
114 template<class Specie>
115 inline Foam::scalar Foam::rPolynomial<Specie>::S(scalar p, scalar T) const
116 {
117  return 0;
118 }
119 
120 
121 template<class Specie>
122 inline Foam::scalar Foam::rPolynomial<Specie>::psi(scalar p, scalar T) const
123 {
124  return sqr(rho(p, T))*(C_[3] + C_[4]*T);
125 }
126 
127 
128 template<class Specie>
129 inline Foam::scalar Foam::rPolynomial<Specie>::Z(scalar p, scalar T) const
130 {
131  return 1;
132 }
133 
134 
135 template<class Specie>
136 inline Foam::scalar Foam::rPolynomial<Specie>::CpMCv(scalar p, scalar T) const
137 {
138  return 0;
139 }
140 
141 
142 // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
143 
144 template<class Specie>
146 (
147  const rPolynomial<Specie>& rp
148 )
149 {
150  const scalar Y1 = this->Y();
151  Specie::operator+=(rp);
152 
153  if (mag(this->Y()) > SMALL)
154  {
155  C_ = (Y1*C_ + rp.Y()*rp.C_)/this->Y();
156  }
157 }
158 
159 
160 template<class Specie>
161 inline void Foam::rPolynomial<Specie>::operator*=(const scalar s)
162 {
163  Specie::operator*=(s);
164 }
165 
166 
167 // * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
168 
169 template<class Specie>
170 inline Foam::rPolynomial<Specie> Foam::operator+
171 (
172  const rPolynomial<Specie>& rp1,
173  const rPolynomial<Specie>& rp2
174 )
175 {
176  Specie sp
177  (
178  static_cast<const Specie&>(rp1)
179  + static_cast<const Specie&>(rp2)
180  );
181 
182  if (mag(sp.Y()) < SMALL)
183  {
184  return rPolynomial<Specie>
185  (
186  sp,
187  rp1.C_
188  );
189  }
190 
191  return rPolynomial<Specie>
192  (
193  sp,
194  (rp1.Y()*rp1.C_ + rp2.Y()*rp2.C_)/sp.Y()
195  );
196 }
197 
198 
199 template<class Specie>
200 inline Foam::rPolynomial<Specie> Foam::operator*
201 (
202  const scalar s,
203  const rPolynomial<Specie>& rp
204 )
205 {
206  return rPolynomial<Specie>
207  (
208  s*static_cast<const Specie&>(rp),
209  rp.C_
210  );
211 }
212 
213 
214 template<class Specie>
215 inline Foam::rPolynomial<Specie> Foam::operator==
216 (
217  const rPolynomial<Specie>& rp1,
218  const rPolynomial<Specie>& rp2
219 )
220 {
221  Specie sp
222  (
223  static_cast<const Specie&>(rp1)
224  == static_cast<const Specie&>(rp2)
225  );
226 
227  return rPolynomial<Specie>
228  (
229  sp,
230  (rp1.Y()*rp1.C_ - rp2.Y()*rp2.C_)/sp.Y()
231  );
232 }
233 
234 
235 // ************************************************************************* //
Foam::rPolynomial::Z
scalar Z(scalar p, scalar T) const
Return compression factor [].
Definition: rPolynomialI.H:129
p
volScalarField & p
Definition: createFieldRefs.H:8
rp
regionProperties rp(runTime)
Foam::rPolynomial::operator*=
void operator*=(const scalar)
Definition: rPolynomialI.H:161
Foam::word
A class for handling words, derived from Foam::string.
Definition: word.H:65
s
gmvFile<< "tracers "<< particles.size()<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().x()<< " ";}gmvFile<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().y()<< " ";}gmvFile<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().z()<< " ";}gmvFile<< nl;forAll(lagrangianScalarNames, i){ word name=lagrangianScalarNames[i];IOField< scalar > s(IOobject(name, runTime.timeName(), cloud::prefix, mesh, IOobject::MUST_READ, IOobject::NO_WRITE))
Definition: gmvOutputSpray.H:25
Foam::rPolynomial
Reciprocal polynomial equation of state for liquids and solids.
Definition: rPolynomial.H:81
Foam::rPolynomial::E
scalar E(const scalar p, const scalar T) const
Return internal energy departure [J/kg].
Definition: rPolynomialI.H:101
Foam::rPolynomial::S
scalar S(const scalar p, const scalar T) const
Return entropy [J/kg/K].
Definition: rPolynomialI.H:115
Foam::rPolynomial::H
scalar H(const scalar p, const scalar T) const
Return enthalpy departure [J/kg].
Definition: rPolynomialI.H:87
rho
rho
Definition: readInitialConditions.H:88
Foam::rPolynomial::rho
scalar rho(scalar p, scalar T) const
Return density [kg/m^3].
Definition: rPolynomialI.H:80
Foam::rPolynomial::clone
autoPtr< rPolynomial > clone() const
Construct and return a clone.
Definition: rPolynomialI.H:60
Foam::rPolynomial::Cv
scalar Cv(scalar p, scalar T) const
Return Cv departure [J/(kg K].
Definition: rPolynomialI.H:108
Foam::T
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
Definition: FieldFieldFunctions.C:58
dict
dictionary dict
Definition: searchingEngine.H:14
Foam::dictionary
A list of keyword definitions, which are a keyword followed by a number of values (eg,...
Definition: dictionary.H:123
Y
PtrList< volScalarField > & Y
Definition: createFieldRefs.H:7
Foam::rPolynomial::CpMCv
scalar CpMCv(scalar p, scalar T) const
Return (Cp - Cv) [J/(kg K].
Definition: rPolynomialI.H:136
Foam::New
tmp< DimensionedField< TypeR, GeoMesh > > New(const tmp< DimensionedField< TypeR, GeoMesh >> &tdf1, const word &name, const dimensionSet &dimensions)
Global function forwards to reuseTmpDimensionedField::New.
Definition: DimensionedFieldReuseFunctions.H:105
Foam::autoPtr
Pointer management similar to std::unique_ptr, with some additional methods and type checking.
Definition: HashPtrTable.H:53
Foam::sqr
dimensionedSymmTensor sqr(const dimensionedVector &dv)
Definition: dimensionedSymmTensor.C:51
Foam::mag
dimensioned< typename typeOfMag< Type >::type > mag(const dimensioned< Type > &dt)
Foam::rPolynomial::Cp
scalar Cp(scalar p, scalar T) const
Return Cp departure [J/(kg K].
Definition: rPolynomialI.H:94
Foam::name
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for INVALID.
Definition: exprTraits.C:59
Foam::rPolynomial::rPolynomial
rPolynomial(const Specie &sp, const coeffList &coeffs)
Construct from components.
Definition: rPolynomialI.H:34
Foam::rPolynomial::New
static autoPtr< rPolynomial > New(const dictionary &dict)
Definition: rPolynomialI.H:69
Foam::rPolynomial::psi
scalar psi(scalar p, scalar T) const
Return compressibility [s^2/m^2].
Definition: rPolynomialI.H:122
rPolynomial.H