perfectFluid.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 | Copyright (C) 2012-2016 OpenFOAM Foundation
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
11  OpenFOAM is free software: you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation, either version 3 of the License, or
14  (at your option) any later version.
15 
16  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19  for more details.
20 
21  You should have received a copy of the GNU General Public License
22  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
23 
24 Class
25  Foam::perfectFluid
26 
27 Description
28  Perfect gas equation of state.
29 
30 SourceFiles
31  perfectFluidI.H
32  perfectFluid.C
33 
34 \*---------------------------------------------------------------------------*/
35 
36 #ifndef perfectFluid_H
37 #define perfectFluid_H
38 
39 #include "autoPtr.H"
40 
41 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
42 
43 namespace Foam
44 {
45 
46 // Forward declaration of friend functions and operators
47 
48 template<class Specie> class perfectFluid;
49 
50 template<class Specie>
51 inline perfectFluid<Specie> operator+
52 (
53  const perfectFluid<Specie>&,
54  const perfectFluid<Specie>&
55 );
56 
57 template<class Specie>
58 inline perfectFluid<Specie> operator-
59 (
60  const perfectFluid<Specie>&,
61  const perfectFluid<Specie>&
62 );
63 
64 template<class Specie>
65 inline perfectFluid<Specie> operator*
66 (
67  const scalar,
68  const perfectFluid<Specie>&
69 );
70 
71 template<class Specie>
72 inline perfectFluid<Specie> operator==
73 (
74  const perfectFluid<Specie>&,
75  const perfectFluid<Specie>&
76 );
77 
78 template<class Specie>
79 Ostream& operator<<
80 (
81  Ostream&,
82  const perfectFluid<Specie>&
83 );
84 
85 
86 /*---------------------------------------------------------------------------*\
87  Class perfectFluid Declaration
88 \*---------------------------------------------------------------------------*/
89 
90 template<class Specie>
91 class perfectFluid
92 :
93  public Specie
94 {
95  // Private data
96 
97  //- Fluid constant
98  scalar R_;
99 
100  //- The reference density
101  scalar rho0_;
102 
103 
104 public:
105 
106  // Constructors
107 
108  //- Construct from components
109  inline perfectFluid
110  (
111  const Specie& sp,
112  const scalar R,
113  const scalar rho0
114  );
115 
116  //- Construct from Istream
118 
119  //- Construct from dictionary
120  perfectFluid(const dictionary& dict);
121 
122  //- Construct as named copy
123  inline perfectFluid(const word& name, const perfectFluid&);
124 
125  //- Construct and return a clone
126  inline autoPtr<perfectFluid> clone() const;
127 
128  // Selector from Istream
129  inline static autoPtr<perfectFluid> New(Istream& is);
130 
131  // Selector from dictionary
132  inline static autoPtr<perfectFluid> New(const dictionary& dict);
133 
134 
135  // Member functions
136 
137  //- Return the instantiated type name
138  static word typeName()
139  {
140  return "perfectFluid<" + word(Specie::typeName_()) + '>';
141  }
142 
143 
144  // Fundamental properties
145 
146  //- Is the equation of state is incompressible i.e. rho != f(p)
147  static const bool incompressible = false;
148 
149  //- Is the equation of state is isochoric i.e. rho = const
150  static const bool isochoric = false;
151 
152  //- Return fluid constant [J/(kg K)]
153  inline scalar R() const;
154 
155  //- Return density [kg/m^3]
156  inline scalar rho(scalar p, scalar T) const;
157 
158  //- Return enthalpy departure [J/kmol]
159  inline scalar h(const scalar p, const scalar T) const;
160 
161  //- Return cp departure [J/(kmol K]
162  inline scalar cp(scalar p, scalar T) const;
163 
164  //- Return entropy [J/(kmol K)]
165  inline scalar s(const scalar p, const scalar T) const;
166 
167  //- Return compressibility rho/p [s^2/m^2]
168  inline scalar psi(scalar p, scalar T) const;
169 
170  //- Return compression factor []
171  inline scalar Z(scalar p, scalar T) const;
172 
173  //- Return (cp - cv) [J/(kmol K]
174  inline scalar cpMcv(scalar p, scalar T) const;
175 
176 
177  // IO
178 
179  //- Write to Ostream
180  void write(Ostream& os) const;
181 
182 
183  // Member operators
184 
185  inline void operator+=(const perfectFluid&);
186  inline void operator-=(const perfectFluid&);
187 
188  inline void operator*=(const scalar);
189 
190 
191  // Friend operators
192 
193  friend perfectFluid operator+ <Specie>
194  (
195  const perfectFluid&,
196  const perfectFluid&
197  );
198 
199  friend perfectFluid operator- <Specie>
200  (
201  const perfectFluid&,
202  const perfectFluid&
203  );
204 
205  friend perfectFluid operator* <Specie>
206  (
207  const scalar s,
208  const perfectFluid&
209  );
210 
211  friend perfectFluid operator== <Specie>
212  (
213  const perfectFluid&,
214  const perfectFluid&
215  );
216 
217 
218  // Ostream Operator
219 
220  friend Ostream& operator<< <Specie>
221  (
222  Ostream&,
223  const perfectFluid&
224  );
225 };
226 
227 
228 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
229 
230 } // End namespace Foam
231 
232 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
233 
234 #include "perfectFluidI.H"
235 
236 #ifdef NoRepository
237  #include "perfectFluid.C"
238 #endif
239 
240 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
241 
242 #endif
243 
244 // ************************************************************************* //
dictionary dict
static const bool isochoric
Is the equation of state is isochoric i.e. rho = const.
Definition: perfectFluid.H:149
static word typeName()
Return the instantiated type name.
Definition: perfectFluid.H:137
void write(Ostream &os) const
Write to Ostream.
Definition: perfectFluid.C:54
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:137
scalar R() const
Return fluid constant [J/(kg K)].
Definition: perfectFluidI.H:90
static const bool incompressible
Is the equation of state is incompressible i.e. rho != f(p)
Definition: perfectFluid.H:146
An Istream is an abstract base class for all input systems (streams, files, token lists etc)...
Definition: Istream.H:57
scalar cpMcv(scalar p, scalar T) const
Return (cp - cv) [J/(kmol K].
perfectFluid(const Specie &sp, const scalar R, const scalar rho0)
Construct from components.
Definition: perfectFluidI.H:33
scalar rho0
scalar h(const scalar p, const scalar T) const
Return enthalpy departure [J/kmol].
void operator-=(const perfectFluid &)
static autoPtr< perfectFluid > New(Istream &is)
Definition: perfectFluidI.H:70
A class for handling words, derived from string.
Definition: word.H:59
void operator*=(const scalar)
An Ostream is an abstract base class for all output systems (streams, files, token lists...
Definition: Ostream.H:53
scalar Z(scalar p, scalar T) const
Return compression factor [].
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
Perfect gas equation of state.
Definition: perfectFluid.H:47
word name(const complex &)
Return a string representation of a complex.
Definition: complex.C:47
scalar s(const scalar p, const scalar T) const
Return entropy [J/(kmol K)].
scalar psi(scalar p, scalar T) const
Return compressibility rho/p [s^2/m^2].
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:53
volScalarField & p
scalar rho(scalar p, scalar T) const
Return density [kg/m^3].
Definition: perfectFluidI.H:97
void operator+=(const perfectFluid &)
autoPtr< perfectFluid > clone() const
Construct and return a clone.
Definition: perfectFluidI.H:62
Namespace for OpenFOAM.
scalar cp(scalar p, scalar T) const
Return cp departure [J/(kmol K].