OpenWAM
TTurbPosition.cpp
1 /* --------------------------------------------------------------------------------*\
2 ==========================|
3  \\ /\ /\ // O pen | OpenWAM: The Open Source 1D Gas-Dynamic Code
4  \\ | X | // W ave |
5  \\ \/_\/ // A ction | CMT-Motores Termicos / Universidad Politecnica Valencia
6  \\/ \// M odel |
7  ----------------------------------------------------------------------------------
8  License
9 
10  This file is part of OpenWAM.
11 
12  OpenWAM is free software: you can redistribute it and/or modify
13  it under the terms of the GNU General Public License as published by
14  the Free Software Foundation, either version 3 of the License, or
15  (at your option) any later version.
16 
17  OpenWAM is distributed in the hope that it will be useful,
18  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  GNU General Public License for more details.
21 
22  You should have received a copy of the GNU General Public License
23  along with OpenWAM. If not, see <http://www.gnu.org/licenses/>.
24 
25 
26  \*-------------------------------------------------------------------------------- */
27 
28 // ---------------------------------------------------------------------------
29 #pragma hdrstop
30 
31 #include "TTurbPosition.h"
32 #include "Globales.h"
33 
34 // ---------------------------------------------------------------------------
35 
36 TTurbPosition::TTurbPosition() {
37 
38 }
39 
40 TTurbPosition::~TTurbPosition() {
41  FSpeedLine.clear();
42 
43 }
44 
45 void TTurbPosition::ReadTurbinPosition(FILE *Input, int rows, double pos, double ang) {
46  double SP = 0., ER = 0., MF = 0., EF = 0., SP0 = 0., ER0 = 0.;
47 
48  FPosition = pos;
49  FAngle = ang;
50 
51  for(int i = 0; i < rows; i++) {
52  fscanf(Input, "%lf %lf %lf %lf", &SP, &ER, &MF, &EF);
53  if(i == 0) {
54  FLines = 1;
55  FSpeedLine.resize(1);
56  FSpeedLine[0].AsignaValores(ER, MF, EF);
57  FSpeedLine[0].PutSpeed(SP);
58  } else {
59  if(SP == SP0) {
60  if(ER > ER0) {
61  FSpeedLine[FLines - 1].AsignaValores(ER, MF, EF);
62  } else {
63  // error
64  }
65  } else if(SP > SP0) {
66  FLines++;
67  FSpeedLine.resize(FLines);
68  FSpeedLine[FLines - 1].AsignaValores(ER, MF, EF);
69  FSpeedLine[FLines - 1].PutSpeed(SP);
70  }
71  }
72  SP0 = SP;
73  ER0 = ER;
74  }
75  FSpeedMin = FSpeedLine[0].Speed();
76  FSpeedMax = FSpeedLine[FLines - 1].Speed();
77 
78 }
79 
80 void TTurbPosition::EffectiveArea(double Area, bool CalculaGR, double Diam1, double Diam2, double Diam3,
81  double n_limit) {
82  for(int i = 0; i < FLines; i++) {
83  FSpeedLine[i].EffectiveSection(Area, CalculaGR, FAngle, Diam1, Diam2, Diam3, n_limit);
84  FSpeedLine[i].Adimensionaliza();
85  }
86 }
87 
88 void TTurbPosition::CalculatePower(double Tin) {
89  for(int i = 0; i < FLines; i++) {
90  FSpeedLine[i].CalculatePower(Tin);
91  }
92 }
93 
94 void TTurbPosition::PutPosition(double Pos) {
95  FPosition = Pos;
96 }
97 
98 void TTurbPosition::SearchMapLimits() {
99  for(int i = 0; i < FLines; i++) {
100  FSpeed.push_back(FSpeedLine[i].Speed());
101  FERMax.push_back(FSpeedLine[i].ERMax());
102  FERMin.push_back(FSpeedLine[i].ERMin());
103  }
104  h_FERMax.resize(FLines);
105  h_FERMin.resize(FLines);
106 
107  Hermite(FLines, FSpeed, FERMax, &h_FERMax);
108  Hermite(FLines, FSpeed, FERMin, &h_FERMin);
109 
110 }
111 
112 void TTurbPosition::InterpolaPosicion(double n, double er) {
113  double CDStator0, CDStator1, CDRotor0, CDRotor1, ERAdim, DeltaN, ERMax, ERMin, Eff0, Eff1;
114 
115  if(n <= FSpeedMin) {
116  if(er < FSpeedLine[0].ERMin()) {
117  ERAdim = 0;
118  } else if(er > FSpeedLine[0].ERMax()) {
119  ERAdim = 1;
120  } else {
121  ERAdim = (er - FSpeedLine[0].ERMin()) / (FSpeedLine[0].ERMax() - FSpeedLine[0].ERMin());
122  }
123 
124  FStatorSec = FSpeedLine[0].Stator(ERAdim);
125  FRotorSec = FSpeedLine[0].Rotor(ERAdim);
126  FEfficiency = FSpeedLine[0].Efficiency(ERAdim);
127  } else if(n >= FSpeedMax) {
128  if(er < FSpeedLine[FLines - 1].ERMin()) {
129  ERAdim = 0;
130  } else if(er > FSpeedLine[FLines - 1].ERMax()) {
131  ERAdim = 1;
132  } else {
133  ERAdim = (er - FSpeedLine[FLines - 1].ERMin()) / (FSpeedLine[FLines - 1].ERMax() - FSpeedLine[FLines - 1].ERMin());
134  }
135 
136  FStatorSec = FSpeedLine[FLines - 1].Stator(ERAdim);
137  FRotorSec = FSpeedLine[FLines - 1].Rotor(ERAdim);
138  FEfficiency = FSpeedLine[FLines - 1].Efficiency(ERAdim);
139  } else {
140  int i = 0;
141  while(FSpeedLine[i].Speed() < n) {
142  ++i;
143  }
144 
145  ERMax = EvaluaHermite(n, FLines, FSpeed, FERMax, h_FERMax);
146  ERMin = EvaluaHermite(n, FLines, FSpeed, FERMin, h_FERMin);
147  ERAdim = (er - ERMin) / (ERMax - ERMin);
148  CDStator0 = FSpeedLine[i - 1].Stator(ERAdim);
149  CDStator1 = FSpeedLine[i].Stator(ERAdim);
150  CDRotor0 = FSpeedLine[i - 1].Rotor(ERAdim);
151  CDRotor1 = FSpeedLine[i].Rotor(ERAdim);
152  Eff0 = FSpeedLine[i - 1].Efficiency(ERAdim);
153  Eff1 = FSpeedLine[i].Efficiency(ERAdim);
154  DeltaN = (n - FSpeed[i - 1]) / (FSpeed[i] - FSpeed[i - 1]);
155  FStatorSec = CDStator0 * (1 - DeltaN) + CDStator1 * DeltaN;
156  FRotorSec = CDRotor0 * (1 - DeltaN) + CDRotor1 * DeltaN;
157  FEfficiency = Eff0 * (1 - DeltaN) + Eff1 * DeltaN;
158  }
159 }
160 
161 void TTurbPosition::PrintTurbinePosition(FILE *fich) {
162  for(int i = 0; i < FLines; i++) {
163  FSpeedLine[i].PrintEffectiveSection(fich);
164  }
165 }
166 
167 double TTurbPosition::StatorSec() {
168  return FStatorSec;
169 }
170 
171 double TTurbPosition::RotorSec() {
172  return FRotorSec;
173 }
174 
175 double TTurbPosition::Rack() {
176  return FPosition;
177 }
178 
179 double TTurbPosition::Efficiency() {
180  return FEfficiency;
181 }
182 
183 double TTurbPosition::MaxPowerLimit(double rtc) {
184 
185  int i = 0;
186  while(FSpeedLine[i].Speed() < rtc) {
187  ++i;
188  }
189  double DeltaN = (rtc - FSpeed[i - 1]) / (FSpeed[i] - FSpeed[i - 1]);
190  double PowerMax0 = FSpeedLine[i - 1].PowerMax();
191  double PowerMax1 = FSpeedLine[i].PowerMax();
192  return PowerMax0 * (1 - DeltaN) + PowerMax1 * DeltaN;
193 
194 }
195 
196 double TTurbPosition::MinPowerLimit(double rtc) {
197 
198  int i = 0;
199  while(FSpeedLine[i].Speed() < rtc) {
200  ++i;
201  }
202  double DeltaN = (rtc - FSpeed[i - 1]) / (FSpeed[i] - FSpeed[i - 1]);
203  double PowerMin0 = FSpeedLine[i - 1].PowerMin();
204  double PowerMin1 = FSpeedLine[i].PowerMin();
205  return PowerMin0 * (1 - DeltaN) + PowerMin1 * DeltaN;
206 
207 }
208 
209 void TTurbPosition::AdiabaticEfficiency(TTC_HTM *HTM, double TinT, double TinC) {
210  for(int i = 0; i < FLines; ++i) {
211  FSpeedLine[i].GetAdiabaticEfficiency(HTM, TinT, TinC);
212  }
213 }
214 
215 #pragma package(smart_init)
TTC_HTM
Definition: TTC_HTM.h:307