src/thermophysicalModels/specie/thermo/hConst/hConstThermoI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 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 \*---------------------------------------------------------------------------*/
  25
  26 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  27
  28 template<class equationOfState>
  29 inline Foam::hConstThermo<equationOfState>::hConstThermo
  30 (
  31     const equationOfState& st,
  32     const scalar cp,
  33     const scalar hf
  34 )
  35 :
  36     equationOfState(st),
  37     Cp_(cp),
  38     Hf_(hf)
  39 {}
  40
  41
  42 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  43
  44 template<class equationOfState>
  45 inline Foam::hConstThermo<equationOfState>::hConstThermo
  46 (
  47     const word& name,
  48     const hConstThermo& ct
  49 )
  50 :
  51     equationOfState(name, ct),
  52     Cp_(ct.Cp_),
  53     Hf_(ct.Hf_)
  54 {}
  55
  56
  57 template<class equationOfState>
  58 inline Foam::autoPtr<Foam::hConstThermo<equationOfState> >
  59 Foam::hConstThermo<equationOfState>::clone() const
  60 {
  61     return autoPtr<hConstThermo<equationOfState> >
  62     (
  63         new hConstThermo<equationOfState>(*this)
  64     );
  65 }
  66
  67
  68 template<class equationOfState>
  69 inline Foam::autoPtr<Foam::hConstThermo<equationOfState> >
  70 Foam::hConstThermo<equationOfState>::New(Istream& is)
  71 {
  72     return autoPtr<hConstThermo<equationOfState> >
  73     (
  74         new hConstThermo<equationOfState>(is)
  75     );
  76 }
  77
  78
  79 template<class equationOfState>
  80 inline Foam::autoPtr<Foam::hConstThermo<equationOfState> >
  81 Foam::hConstThermo<equationOfState>::New(const dictionary& dict)
  82 {
  83     return autoPtr<hConstThermo<equationOfState> >
  84     (
  85         new hConstThermo<equationOfState>(dict)
  86     );
  87 }
  88
  89
  90 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  91
  92 template<class EquationOfState>
  93 inline Foam::scalar Foam::hConstThermo<EquationOfState>::limit
  94 (
  95     const scalar T
  96 ) const
  97 {
  98     return T;
  99 }
 100
 101
 102 template<class equationOfState>
 103 inline Foam::scalar Foam::hConstThermo<equationOfState>::cp
 104 (
 105     const scalar
 106 ) const
 107 {
 108     return Cp_*this->W();
 109 }
 110
 111
 112 template<class equationOfState>
 113 inline Foam::scalar Foam::hConstThermo<equationOfState>::h
 114 (
 115     const scalar T
 116 ) const
 117 {
 118     return (Cp_*T + Hf_)*this->W();
 119 }
 120
 121
 122 template<class equationOfState>
 123 inline Foam::scalar Foam::hConstThermo<equationOfState>::hs
 124 (
 125     const scalar T
 126 ) const
 127 {
 128     return Cp_*T*this->W();
 129 }
 130
 131
 132 template<class equationOfState>
 133 inline Foam::scalar Foam::hConstThermo<equationOfState>::hc() const
 134 {
 135     return Hf_*this->W();
 136 }
 137
 138
 139 template<class equationOfState>
 140 inline Foam::scalar Foam::hConstThermo<equationOfState>::s
 141 (
 142     const scalar T
 143 ) const
 144 {
 145     notImplemented
 146     (
 147         "scalar hConstThermo<equationOfState>::s(const scalar T) const"
 148     );
 149     return T;
 150 }
 151
 152
 153 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 154
 155 template<class equationOfState>
 156 inline void Foam::hConstThermo<equationOfState>::operator+=
 157 (
 158     const hConstThermo<equationOfState>& ct
 159 )
 160 {
 161     scalar molr1 = this->nMoles();
 162
 163     equationOfState::operator+=(ct);
 164
 165     molr1 /= this->nMoles();
 166     scalar molr2 = ct.nMoles()/this->nMoles();
 167
 168     Cp_ = molr1*Cp_ + molr2*ct.Cp_;
 169     Hf_ = molr1*Hf_ + molr2*ct.Hf_;
 170 }
 171
 172
 173 template<class equationOfState>
 174 inline void Foam::hConstThermo<equationOfState>::operator-=
 175 (
 176     const hConstThermo<equationOfState>& ct
 177 )
 178 {
 179     scalar molr1 = this->nMoles();
 180
 181     equationOfState::operator-=(ct);
 182
 183     molr1 /= this->nMoles();
 184     scalar molr2 = ct.nMoles()/this->nMoles();
 185
 186     Cp_ = molr1*Cp_ - molr2*ct.Cp_;
 187     Hf_ = molr1*Hf_ - molr2*ct.Hf_;
 188 }
 189
 190
 191 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 192
 193 template<class equationOfState>
 194 inline Foam::hConstThermo<equationOfState> Foam::operator+
 195 (
 196     const hConstThermo<equationOfState>& ct1,
 197     const hConstThermo<equationOfState>& ct2
 198 )
 199 {
 200     equationOfState eofs
 201     (
 202         static_cast<const equationOfState&>(ct1)
 203       + static_cast<const equationOfState&>(ct2)
 204     );
 205
 206     return hConstThermo<equationOfState>
 207     (
 208         eofs,
 209         ct1.nMoles()/eofs.nMoles()*ct1.Cp_
 210       + ct2.nMoles()/eofs.nMoles()*ct2.Cp_,
 211         ct1.nMoles()/eofs.nMoles()*ct1.Hf_
 212       + ct2.nMoles()/eofs.nMoles()*ct2.Hf_
 213     );
 214 }
 215
 216
 217 template<class equationOfState>
 218 inline Foam::hConstThermo<equationOfState> Foam::operator-
 219 (
 220     const hConstThermo<equationOfState>& ct1,
 221     const hConstThermo<equationOfState>& ct2
 222 )
 223 {
 224     equationOfState eofs
 225     (
 226         static_cast<const equationOfState&>(ct1)
 227       - static_cast<const equationOfState&>(ct2)
 228     );
 229
 230     return hConstThermo<equationOfState>
 231     (
 232         eofs,
 233         ct1.nMoles()/eofs.nMoles()*ct1.Cp_
 234       - ct2.nMoles()/eofs.nMoles()*ct2.Cp_,
 235         ct1.nMoles()/eofs.nMoles()*ct1.Hf_
 236       - ct2.nMoles()/eofs.nMoles()*ct2.Hf_
 237     );
 238 }
 239
 240
 241 template<class equationOfState>
 242 inline Foam::hConstThermo<equationOfState> Foam::operator*
 243 (
 244     const scalar s,
 245     const hConstThermo<equationOfState>& ct
 246 )
 247 {
 248     return hConstThermo<equationOfState>
 249     (
 250         s*static_cast<const equationOfState&>(ct),
 251         ct.Cp_,
 252         ct.Hf_
 253     );
 254 }
 255
 256
 257 template<class equationOfState>
 258 inline Foam::hConstThermo<equationOfState> Foam::operator==
 259 (
 260     const hConstThermo<equationOfState>& ct1,
 261     const hConstThermo<equationOfState>& ct2
 262 )
 263 {
 264     return ct2 - ct1;
 265 }
 266
 267
 268 // ************************************************************************* //