src/engine/engineTime/engineTime.C

   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 #include "engineTime.H"
  27 #include "unitConversion.H"
  28
  29 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  30
  31 void Foam::engineTime::timeAdjustment()
  32 {
  33     deltaT_  = degToTime(deltaT_);
  34     endTime_ = degToTime(endTime_);
  35
  36     if
  37     (
  38         writeControl_ == wcRunTime
  39      || writeControl_ == wcAdjustableRunTime
  40     )
  41     {
  42         writeInterval_ = degToTime(writeInterval_);
  43     }
  44 }
  45
  46
  47 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  48
  49 //- Construct from objectRegistry arguments
  50 Foam::engineTime::engineTime
  51 (
  52     const word& name,
  53     const fileName& rootPath,
  54     const fileName& caseName,
  55     const fileName& systemName,
  56     const fileName& constantName,
  57     const fileName& dictName
  58 )
  59 :
  60     Time
  61     (
  62         name,
  63         rootPath,
  64         caseName,
  65         systemName,
  66         constantName
  67     ),
  68     dict_
  69     (
  70         IOobject
  71         (
  72             "engineGeometry",
  73             constant(),
  74             *this,
  75             IOobject::MUST_READ_IF_MODIFIED,
  76             IOobject::NO_WRITE,
  77             false
  78         )
  79     ),
  80     rpm_(dict_.lookup("rpm")),
  81     conRodLength_(dimensionedScalar("conRodLength", dimLength, 0)),
  82     bore_(dimensionedScalar("bore", dimLength, 0)),
  83     stroke_(dimensionedScalar("stroke", dimLength, 0)),
  84     clearance_(dimensionedScalar("clearance", dimLength, 0))
  85 {
  86     // geometric parameters are not strictly required for Time
  87     dict_.readIfPresent("conRodLength", conRodLength_);
  88     dict_.readIfPresent("bore", bore_);
  89     dict_.readIfPresent("stroke", stroke_);
  90     dict_.readIfPresent("clearance", clearance_);
  91
  92     timeAdjustment();
  93
  94     startTime_ = degToTime(startTime_);
  95     value()    = degToTime(value());
  96     deltaT0_   = deltaT_;
  97 }
  98
  99
 100 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 101
 102 // Read the controlDict and set all the parameters
 103 void Foam::engineTime::readDict()
 104 {
 105     Time::readDict();
 106     timeAdjustment();
 107 }
 108
 109
 110 // Read the controlDict and set all the parameters
 111 bool Foam::engineTime::read()
 112 {
 113     if (Time::read())
 114     {
 115         timeAdjustment();
 116         return true;
 117     }
 118     else
 119     {
 120         return false;
 121     }
 122 }
 123
 124
 125 Foam::scalar Foam::engineTime::degToTime(const scalar theta) const
 126 {
 127     // 6 * rpm => deg/s
 128     return theta/(6.0*rpm_.value());
 129 }
 130
 131
 132 Foam::scalar Foam::engineTime::timeToDeg(const scalar t) const
 133 {
 134     // 6 * rpm => deg/s
 135     return t*(6.0*rpm_.value());
 136 }
 137
 138
 139 Foam::scalar Foam::engineTime::theta() const
 140 {
 141     return timeToDeg(value());
 142 }
 143
 144
 145 // Return current crank-angle translated to a single revolution
 146 // (value between -180 and 180 with 0 = top dead centre)
 147 Foam::scalar Foam::engineTime::thetaRevolution() const
 148 {
 149     scalar t = theta();
 150
 151     while (t > 180.0)
 152     {
 153         t -= 360.0;
 154     }
 155
 156     while (t < -180.0)
 157     {
 158         t += 360.0;
 159     }
 160
 161     return t;
 162 }
 163
 164
 165 Foam::scalar Foam::engineTime::deltaTheta() const
 166 {
 167     return timeToDeg(deltaTValue());
 168 }
 169
 170
 171 Foam::scalar Foam::engineTime::pistonPosition(const scalar theta) const
 172 {
 173     return
 174     (
 175         conRodLength_.value()
 176       + stroke_.value()/2.0
 177       + clearance_.value()
 178     )
 179   - (
 180         stroke_.value()*::cos(degToRad(theta))/2.0
 181       + ::sqrt
 182         (
 183             sqr(conRodLength_.value())
 184             - sqr(stroke_.value()*::sin(degToRad(theta))/2.0)
 185         )
 186     );
 187 }
 188
 189
 190 Foam::dimensionedScalar Foam::engineTime::pistonPosition() const
 191 {
 192     return dimensionedScalar
 193     (
 194         "pistonPosition",
 195         dimLength,
 196         pistonPosition(theta())
 197     );
 198 }
 199
 200
 201 Foam::dimensionedScalar Foam::engineTime::pistonDisplacement() const
 202 {
 203     return dimensionedScalar
 204     (
 205         "pistonDisplacement",
 206         dimLength,
 207         pistonPosition(theta() - deltaTheta()) - pistonPosition().value()
 208     );
 209 }
 210
 211
 212 Foam::dimensionedScalar Foam::engineTime::pistonSpeed() const
 213 {
 214     return dimensionedScalar
 215     (
 216         "pistonSpeed",
 217         dimVelocity,
 218         pistonDisplacement().value()/(deltaTValue() + VSMALL)
 219     );
 220 }
 221
 222
 223 Foam::scalar Foam::engineTime::userTimeToTime(const scalar theta) const
 224 {
 225     return degToTime(theta);
 226 }
 227
 228
 229 Foam::scalar Foam::engineTime::timeToUserTime(const scalar t) const
 230 {
 231     return timeToDeg(t);
 232 }
 233
 234
 235 // ************************************************************************* //