1 /**********************************************************************
2
3 FILENAME: uiuc_menu_Cn.cpp
4
5 ----------------------------------------------------------------------
6
7 DESCRIPTION: reads input data for specified aircraft and creates
8 approporiate data storage space
9
10 ----------------------------------------------------------------------
11
12 STATUS: alpha version
13
14 ----------------------------------------------------------------------
15
16 REFERENCES: based on "menu reader" format of Michael Selig
17
18 ----------------------------------------------------------------------
19
20 HISTORY: 04/04/2003 initial release
21 06/30/2003 (RD) replaced istrstream with istringstream
22 to get rid of the annoying warning about
23 using the strstream header
24
25 ----------------------------------------------------------------------
26
27 AUTHOR(S): Robert Deters <rdeters@uiuc.edu>
28 Michael Selig <m-selig@uiuc.edu>
29
30 ----------------------------------------------------------------------
31
32 VARIABLES:
33
34 ----------------------------------------------------------------------
35
36 INPUTS: n/a
37
38 ----------------------------------------------------------------------
39
40 OUTPUTS: n/a
41
42 ----------------------------------------------------------------------
43
44 CALLED BY: uiuc_menu()
45
46 ----------------------------------------------------------------------
47
48 CALLS TO: check_float() if needed
49 d_2_to_3() if needed
50 d_1_to_2() if needed
51 i_1_to_2() if needed
52 d_1_to_1() if needed
53
54 ----------------------------------------------------------------------
55
56 COPYRIGHT: (C) 2003 by Michael Selig
57
58 This program is free software; you can redistribute it and/or
59 modify it under the terms of the GNU General Public License
60 as published by the Free Software Foundation.
61
62 This program is distributed in the hope that it will be useful,
63 but WITHOUT ANY WARRANTY; without even the implied warranty of
64 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
65 GNU General Public License for more details.
66
67 You should have received a copy of the GNU General Public License
68 along with this program; if not, write to the Free Software
69 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
70
71 **********************************************************************/
72
73 #include <simgear/compiler.h>
74
75
76 #include <cstdlib>
77 #include <string>
78 #include <iostream>
79
80 #include "uiuc_menu_Cn.h"
81
82 using std::cerr;
83 using std::cout;
84 using std::endl;
85
86 #ifndef _MSC_VER
87 using std::exit;
88 #endif
89
parse_Cn(const string & linetoken2,const string & linetoken3,const string & linetoken4,const string & linetoken5,const string & linetoken6,const string & linetoken7,const string & linetoken8,const string & linetoken9,const string & linetoken10,const string & aircraft_directory,LIST command_line)90 void parse_Cn( const string& linetoken2, const string& linetoken3,
91 const string& linetoken4, const string& linetoken5,
92 const string& linetoken6, const string& linetoken7,
93 const string& linetoken8, const string& linetoken9,
94 const string& linetoken10, const string& aircraft_directory,
95 LIST command_line ) {
96 double token_value;
97 int token_value_convert1, token_value_convert2, token_value_convert3;
98 int token_value_convert4;
99 double datafile_xArray[100][100], datafile_yArray[100];
100 double datafile_zArray[100][100];
101 double convert_f;
102 int datafile_nxArray[100], datafile_ny;
103 istringstream token3(linetoken3.c_str());
104 istringstream token4(linetoken4.c_str());
105 istringstream token5(linetoken5.c_str());
106 istringstream token6(linetoken6.c_str());
107 istringstream token7(linetoken7.c_str());
108 istringstream token8(linetoken8.c_str());
109 istringstream token9(linetoken9.c_str());
110 istringstream token10(linetoken10.c_str());
111
112 static bool Cnfabetaf_first = true;
113 static bool Cnfadaf_first = true;
114 static bool Cnfadrf_first = true;
115 static bool Cnfapf_first = true;
116 static bool Cnfarf_first = true;
117
118 switch(Cn_map[linetoken2])
119 {
120 case Cno_flag:
121 {
122 if (check_float(linetoken3))
123 token3 >> token_value;
124 else
125 uiuc_warnings_errors(1, *command_line);
126
127 Cno = token_value;
128 Cno_clean = Cno;
129 aeroYawParts -> storeCommands (*command_line);
130 break;
131 }
132 case Cn_beta_flag:
133 {
134 if (check_float(linetoken3))
135 token3 >> token_value;
136 else
137 uiuc_warnings_errors(1, *command_line);
138
139 Cn_beta = token_value;
140 Cn_beta_clean = Cn_beta;
141 aeroYawParts -> storeCommands (*command_line);
142 break;
143 }
144 case Cn_p_flag:
145 {
146 if (check_float(linetoken3))
147 token3 >> token_value;
148 else
149 uiuc_warnings_errors(1, *command_line);
150
151 Cn_p = token_value;
152 Cn_p_clean = Cn_p;
153 aeroYawParts -> storeCommands (*command_line);
154 break;
155 }
156 case Cn_r_flag:
157 {
158 if (check_float(linetoken3))
159 token3 >> token_value;
160 else
161 uiuc_warnings_errors(1, *command_line);
162
163 Cn_r = token_value;
164 Cn_r_clean = Cn_r;
165 aeroYawParts -> storeCommands (*command_line);
166 break;
167 }
168 case Cn_da_flag:
169 {
170 if (check_float(linetoken3))
171 token3 >> token_value;
172 else
173 uiuc_warnings_errors(1, *command_line);
174
175 Cn_da = token_value;
176 Cn_da_clean = Cn_da;
177 aeroYawParts -> storeCommands (*command_line);
178 break;
179 }
180 case Cn_dr_flag:
181 {
182 if (check_float(linetoken3))
183 token3 >> token_value;
184 else
185 uiuc_warnings_errors(1, *command_line);
186
187 Cn_dr = token_value;
188 Cn_dr_clean = Cn_dr;
189 aeroYawParts -> storeCommands (*command_line);
190 break;
191 }
192 case Cn_q_flag:
193 {
194 if (check_float(linetoken3))
195 token3 >> token_value;
196 else
197 uiuc_warnings_errors(1, *command_line);
198
199 Cn_q = token_value;
200 Cn_q_clean = Cn_q;
201 aeroYawParts -> storeCommands (*command_line);
202 break;
203 }
204 case Cn_b3_flag:
205 {
206 if (check_float(linetoken3))
207 token3 >> token_value;
208 else
209 uiuc_warnings_errors(1, *command_line);
210
211 Cn_b3 = token_value;
212 Cn_b3_clean = Cn_b3;
213 aeroYawParts -> storeCommands (*command_line);
214 break;
215 }
216 case Cnfada_flag:
217 {
218 Cnfada = aircraft_directory + linetoken3;
219 token4 >> token_value_convert1;
220 token5 >> token_value_convert2;
221 token6 >> token_value_convert3;
222 convert_z = uiuc_convert(token_value_convert1);
223 convert_x = uiuc_convert(token_value_convert2);
224 convert_y = uiuc_convert(token_value_convert3);
225 /* call 2D File Reader with file name (Cnfada) and
226 conversion factors; function returns array of
227 aileron deflections (daArray) and corresponding
228 alpha (aArray) and delta Cn (CnArray) values and
229 max number of terms in alpha arrays (nAlphaArray)
230 and deflection array (nda) */
231 uiuc_2DdataFileReader(Cnfada,
232 Cnfada_aArray,
233 Cnfada_daArray,
234 Cnfada_CnArray,
235 Cnfada_nAlphaArray,
236 Cnfada_nda);
237 aeroYawParts -> storeCommands (*command_line);
238 break;
239 }
240 case Cnfbetadr_flag:
241 {
242 Cnfbetadr = aircraft_directory + linetoken3;
243 token4 >> token_value_convert1;
244 token5 >> token_value_convert2;
245 token6 >> token_value_convert3;
246 convert_z = uiuc_convert(token_value_convert1);
247 convert_x = uiuc_convert(token_value_convert2);
248 convert_y = uiuc_convert(token_value_convert3);
249 /* call 2D File Reader with file name (Cnfbetadr) and
250 conversion factors; function returns array of
251 rudder deflections (drArray) and corresponding
252 beta (betaArray) and delta Cn (CnArray) values and
253 max number of terms in beta arrays (nBetaArray)
254 and deflection array (ndr) */
255 uiuc_2DdataFileReader(Cnfbetadr,
256 Cnfbetadr_betaArray,
257 Cnfbetadr_drArray,
258 Cnfbetadr_CnArray,
259 Cnfbetadr_nBetaArray,
260 Cnfbetadr_ndr);
261 aeroYawParts -> storeCommands (*command_line);
262 break;
263 }
264 case Cnfabetaf_flag:
265 {
266 int Cnfabetaf_index, i;
267 string Cnfabetaf_file;
268 double flap_value;
269 Cnfabetaf_file = aircraft_directory + linetoken3;
270 token4 >> Cnfabetaf_index;
271 if (Cnfabetaf_index < 0 || Cnfabetaf_index >= 100)
272 uiuc_warnings_errors(1, *command_line);
273 if (Cnfabetaf_index > Cnfabetaf_nf)
274 Cnfabetaf_nf = Cnfabetaf_index;
275 token5 >> flap_value;
276 token6 >> token_value_convert1;
277 token7 >> token_value_convert2;
278 token8 >> token_value_convert3;
279 token9 >> token_value_convert4;
280 token10 >> Cnfabetaf_nice;
281 convert_z = uiuc_convert(token_value_convert1);
282 convert_x = uiuc_convert(token_value_convert2);
283 convert_y = uiuc_convert(token_value_convert3);
284 convert_f = uiuc_convert(token_value_convert4);
285 Cnfabetaf_fArray[Cnfabetaf_index] = flap_value * convert_f;
286 /* call 2D File Reader with file name (Cnfabetaf_file) and
287 conversion factors; function returns array of
288 elevator deflections (deArray) and corresponding
289 alpha (aArray) and delta CZ (CZArray) values and
290 max number of terms in alpha arrays (nAlphaArray)
291 and delfection array (nde) */
292 uiuc_2DdataFileReader(Cnfabetaf_file,
293 datafile_xArray,
294 datafile_yArray,
295 datafile_zArray,
296 datafile_nxArray,
297 datafile_ny);
298 d_2_to_3(datafile_xArray, Cnfabetaf_aArray, Cnfabetaf_index);
299 d_1_to_2(datafile_yArray, Cnfabetaf_betaArray, Cnfabetaf_index);
300 d_2_to_3(datafile_zArray, Cnfabetaf_CnArray, Cnfabetaf_index);
301 i_1_to_2(datafile_nxArray, Cnfabetaf_nAlphaArray, Cnfabetaf_index);
302 Cnfabetaf_nbeta[Cnfabetaf_index] = datafile_ny;
303 if (Cnfabetaf_first==true)
304 {
305 if (Cnfabetaf_nice == 1)
306 {
307 Cnfabetaf_na_nice = datafile_nxArray[1];
308 Cnfabetaf_nb_nice = datafile_ny;
309 d_1_to_1(datafile_yArray, Cnfabetaf_bArray_nice);
310 for (i=1; i<=Cnfabetaf_na_nice; i++)
311 Cnfabetaf_aArray_nice[i] = datafile_xArray[1][i];
312 }
313 aeroYawParts -> storeCommands (*command_line);
314 Cnfabetaf_first=false;
315 }
316 break;
317 }
318 case Cnfadaf_flag:
319 {
320 int Cnfadaf_index, i;
321 string Cnfadaf_file;
322 double flap_value;
323 Cnfadaf_file = aircraft_directory + linetoken3;
324 token4 >> Cnfadaf_index;
325 if (Cnfadaf_index < 0 || Cnfadaf_index >= 100)
326 uiuc_warnings_errors(1, *command_line);
327 if (Cnfadaf_index > Cnfadaf_nf)
328 Cnfadaf_nf = Cnfadaf_index;
329 token5 >> flap_value;
330 token6 >> token_value_convert1;
331 token7 >> token_value_convert2;
332 token8 >> token_value_convert3;
333 token9 >> token_value_convert4;
334 token10 >> Cnfadaf_nice;
335 convert_z = uiuc_convert(token_value_convert1);
336 convert_x = uiuc_convert(token_value_convert2);
337 convert_y = uiuc_convert(token_value_convert3);
338 convert_f = uiuc_convert(token_value_convert4);
339 Cnfadaf_fArray[Cnfadaf_index] = flap_value * convert_f;
340 /* call 2D File Reader with file name (Cnfadaf_file) and
341 conversion factors; function returns array of
342 elevator deflections (deArray) and corresponding
343 alpha (aArray) and delta CZ (CZArray) values and
344 max number of terms in alpha arrays (nAlphaArray)
345 and delfection array (nde) */
346 uiuc_2DdataFileReader(Cnfadaf_file,
347 datafile_xArray,
348 datafile_yArray,
349 datafile_zArray,
350 datafile_nxArray,
351 datafile_ny);
352 d_2_to_3(datafile_xArray, Cnfadaf_aArray, Cnfadaf_index);
353 d_1_to_2(datafile_yArray, Cnfadaf_daArray, Cnfadaf_index);
354 d_2_to_3(datafile_zArray, Cnfadaf_CnArray, Cnfadaf_index);
355 i_1_to_2(datafile_nxArray, Cnfadaf_nAlphaArray, Cnfadaf_index);
356 Cnfadaf_nda[Cnfadaf_index] = datafile_ny;
357 if (Cnfadaf_first==true)
358 {
359 if (Cnfadaf_nice == 1)
360 {
361 Cnfadaf_na_nice = datafile_nxArray[1];
362 Cnfadaf_nda_nice = datafile_ny;
363 d_1_to_1(datafile_yArray, Cnfadaf_daArray_nice);
364 for (i=1; i<=Cnfadaf_na_nice; i++)
365 Cnfadaf_aArray_nice[i] = datafile_xArray[1][i];
366 }
367 aeroYawParts -> storeCommands (*command_line);
368 Cnfadaf_first=false;
369 }
370 break;
371 }
372 case Cnfadrf_flag:
373 {
374 int Cnfadrf_index, i;
375 string Cnfadrf_file;
376 double flap_value;
377 Cnfadrf_file = aircraft_directory + linetoken3;
378 token4 >> Cnfadrf_index;
379 if (Cnfadrf_index < 0 || Cnfadrf_index >= 100)
380 uiuc_warnings_errors(1, *command_line);
381 if (Cnfadrf_index > Cnfadrf_nf)
382 Cnfadrf_nf = Cnfadrf_index;
383 token5 >> flap_value;
384 token6 >> token_value_convert1;
385 token7 >> token_value_convert2;
386 token8 >> token_value_convert3;
387 token9 >> token_value_convert4;
388 token10 >> Cnfadrf_nice;
389 convert_z = uiuc_convert(token_value_convert1);
390 convert_x = uiuc_convert(token_value_convert2);
391 convert_y = uiuc_convert(token_value_convert3);
392 convert_f = uiuc_convert(token_value_convert4);
393 Cnfadrf_fArray[Cnfadrf_index] = flap_value * convert_f;
394 /* call 2D File Reader with file name (Cnfadrf_file) and
395 conversion factors; function returns array of
396 elevator deflections (deArray) and corresponding
397 alpha (aArray) and delta CZ (CZArray) values and
398 max number of terms in alpha arrays (nAlphaArray)
399 and delfection array (nde) */
400 uiuc_2DdataFileReader(Cnfadrf_file,
401 datafile_xArray,
402 datafile_yArray,
403 datafile_zArray,
404 datafile_nxArray,
405 datafile_ny);
406 d_2_to_3(datafile_xArray, Cnfadrf_aArray, Cnfadrf_index);
407 d_1_to_2(datafile_yArray, Cnfadrf_drArray, Cnfadrf_index);
408 d_2_to_3(datafile_zArray, Cnfadrf_CnArray, Cnfadrf_index);
409 i_1_to_2(datafile_nxArray, Cnfadrf_nAlphaArray, Cnfadrf_index);
410 Cnfadrf_ndr[Cnfadrf_index] = datafile_ny;
411 if (Cnfadrf_first==true)
412 {
413 if (Cnfadrf_nice == 1)
414 {
415 Cnfadrf_na_nice = datafile_nxArray[1];
416 Cnfadrf_ndr_nice = datafile_ny;
417 d_1_to_1(datafile_yArray, Cnfadrf_drArray_nice);
418 for (i=1; i<=Cnfadrf_na_nice; i++)
419 Cnfadrf_aArray_nice[i] = datafile_xArray[1][i];
420 }
421 aeroYawParts -> storeCommands (*command_line);
422 Cnfadrf_first=false;
423 }
424 break;
425 }
426 case Cnfapf_flag:
427 {
428 int Cnfapf_index, i;
429 string Cnfapf_file;
430 double flap_value;
431 Cnfapf_file = aircraft_directory + linetoken3;
432 token4 >> Cnfapf_index;
433 if (Cnfapf_index < 0 || Cnfapf_index >= 100)
434 uiuc_warnings_errors(1, *command_line);
435 if (Cnfapf_index > Cnfapf_nf)
436 Cnfapf_nf = Cnfapf_index;
437 token5 >> flap_value;
438 token6 >> token_value_convert1;
439 token7 >> token_value_convert2;
440 token8 >> token_value_convert3;
441 token9 >> token_value_convert4;
442 token10 >> Cnfapf_nice;
443 convert_z = uiuc_convert(token_value_convert1);
444 convert_x = uiuc_convert(token_value_convert2);
445 convert_y = uiuc_convert(token_value_convert3);
446 convert_f = uiuc_convert(token_value_convert4);
447 Cnfapf_fArray[Cnfapf_index] = flap_value * convert_f;
448 /* call 2D File Reader with file name (Cnfapf_file) and
449 conversion factors; function returns array of
450 elevator deflections (deArray) and corresponding
451 alpha (aArray) and delta CZ (CZArray) values and
452 max number of terms in alpha arrays (nAlphaArray)
453 and delfection array (nde) */
454 uiuc_2DdataFileReader(Cnfapf_file,
455 datafile_xArray,
456 datafile_yArray,
457 datafile_zArray,
458 datafile_nxArray,
459 datafile_ny);
460 d_2_to_3(datafile_xArray, Cnfapf_aArray, Cnfapf_index);
461 d_1_to_2(datafile_yArray, Cnfapf_pArray, Cnfapf_index);
462 d_2_to_3(datafile_zArray, Cnfapf_CnArray, Cnfapf_index);
463 i_1_to_2(datafile_nxArray, Cnfapf_nAlphaArray, Cnfapf_index);
464 Cnfapf_np[Cnfapf_index] = datafile_ny;
465 if (Cnfapf_first==true)
466 {
467 if (Cnfapf_nice == 1)
468 {
469 Cnfapf_na_nice = datafile_nxArray[1];
470 Cnfapf_np_nice = datafile_ny;
471 d_1_to_1(datafile_yArray, Cnfapf_pArray_nice);
472 for (i=1; i<=Cnfapf_na_nice; i++)
473 Cnfapf_aArray_nice[i] = datafile_xArray[1][i];
474 }
475 aeroYawParts -> storeCommands (*command_line);
476 Cnfapf_first=false;
477 }
478 break;
479 }
480 case Cnfarf_flag:
481 {
482 int Cnfarf_index, i;
483 string Cnfarf_file;
484 double flap_value;
485 Cnfarf_file = aircraft_directory + linetoken3;
486 token4 >> Cnfarf_index;
487 if (Cnfarf_index < 0 || Cnfarf_index >= 100)
488 uiuc_warnings_errors(1, *command_line);
489 if (Cnfarf_index > Cnfarf_nf)
490 Cnfarf_nf = Cnfarf_index;
491 token5 >> flap_value;
492 token6 >> token_value_convert1;
493 token7 >> token_value_convert2;
494 token8 >> token_value_convert3;
495 token9 >> token_value_convert4;
496 token10 >> Cnfarf_nice;
497 convert_z = uiuc_convert(token_value_convert1);
498 convert_x = uiuc_convert(token_value_convert2);
499 convert_y = uiuc_convert(token_value_convert3);
500 convert_f = uiuc_convert(token_value_convert4);
501 Cnfarf_fArray[Cnfarf_index] = flap_value * convert_f;
502 /* call 2D File Reader with file name (Cnfarf_file) and
503 conversion factors; function returns array of
504 elevator deflections (deArray) and corresponding
505 alpha (aArray) and delta CZ (CZArray) values and
506 max number of terms in alpha arrays (nAlphaArray)
507 and delfection array (nde) */
508 uiuc_2DdataFileReader(Cnfarf_file,
509 datafile_xArray,
510 datafile_yArray,
511 datafile_zArray,
512 datafile_nxArray,
513 datafile_ny);
514 d_2_to_3(datafile_xArray, Cnfarf_aArray, Cnfarf_index);
515 d_1_to_2(datafile_yArray, Cnfarf_rArray, Cnfarf_index);
516 d_2_to_3(datafile_zArray, Cnfarf_CnArray, Cnfarf_index);
517 i_1_to_2(datafile_nxArray, Cnfarf_nAlphaArray, Cnfarf_index);
518 Cnfarf_nr[Cnfarf_index] = datafile_ny;
519 if (Cnfarf_first==true)
520 {
521 if (Cnfarf_nice == 1)
522 {
523 Cnfarf_na_nice = datafile_nxArray[1];
524 Cnfarf_nr_nice = datafile_ny;
525 d_1_to_1(datafile_yArray, Cnfarf_rArray_nice);
526 for (i=1; i<=Cnfarf_na_nice; i++)
527 Cnfarf_aArray_nice[i] = datafile_xArray[1][i];
528 }
529 aeroYawParts -> storeCommands (*command_line);
530 Cnfarf_first=false;
531 }
532 break;
533 }
534 default:
535 {
536 if (ignore_unknown_keywords) {
537 // do nothing
538 } else {
539 // print error message
540 uiuc_warnings_errors(2, *command_line);
541 }
542 break;
543 }
544 };
545 }
546