1 /**********************************************************************
3 FILENAME: uiuc_menu_Croll.cpp
5 ----------------------------------------------------------------------
7 DESCRIPTION: reads input data for specified aircraft and creates
8 approporiate data storage space
10 ----------------------------------------------------------------------
14 ----------------------------------------------------------------------
16 REFERENCES: based on "menu reader" format of Michael Selig
18 ----------------------------------------------------------------------
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
25 ----------------------------------------------------------------------
27 AUTHOR(S): Robert Deters <rdeters@uiuc.edu>
28 Michael Selig <m-selig@uiuc.edu>
30 ----------------------------------------------------------------------
34 ----------------------------------------------------------------------
38 ----------------------------------------------------------------------
42 ----------------------------------------------------------------------
44 CALLED BY: uiuc_menu()
46 ----------------------------------------------------------------------
48 CALLS TO: check_float() if needed
54 ----------------------------------------------------------------------
56 COPYRIGHT: (C) 2003 by Michael Selig
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.
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.
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.
71 **********************************************************************/
73 #include <simgear/compiler.h>
80 #include "uiuc_menu_Croll.h"
90 void parse_Cl( 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,
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];
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());
112 static bool Clfabetaf_first = true;
113 static bool Clfadaf_first = true;
114 static bool Clfadrf_first = true;
115 static bool Clfapf_first = true;
116 static bool Clfarf_first = true;
118 switch(Cl_map[linetoken2])
122 if (check_float(linetoken3))
123 token3 >> token_value;
125 uiuc_warnings_errors(1, *command_line);
129 aeroRollParts -> storeCommands (*command_line);
134 if (check_float(linetoken3))
135 token3 >> token_value;
137 uiuc_warnings_errors(1, *command_line);
139 Cl_beta = token_value;
140 Cl_beta_clean = Cl_beta;
141 aeroRollParts -> storeCommands (*command_line);
146 if (check_float(linetoken3))
147 token3 >> token_value;
149 uiuc_warnings_errors(1, *command_line);
153 aeroRollParts -> storeCommands (*command_line);
158 if (check_float(linetoken3))
159 token3 >> token_value;
161 uiuc_warnings_errors(1, *command_line);
165 aeroRollParts -> storeCommands (*command_line);
170 if (check_float(linetoken3))
171 token3 >> token_value;
173 uiuc_warnings_errors(1, *command_line);
177 aeroRollParts -> storeCommands (*command_line);
182 if (check_float(linetoken3))
183 token3 >> token_value;
185 uiuc_warnings_errors(1, *command_line);
189 aeroRollParts -> storeCommands (*command_line);
194 if (check_float(linetoken3))
195 token3 >> token_value;
197 uiuc_warnings_errors(1, *command_line);
199 Cl_daa = token_value;
200 Cl_daa_clean = Cl_daa;
201 aeroRollParts -> storeCommands (*command_line);
206 Clfada = aircraft_directory + linetoken3;
207 token4 >> token_value_convert1;
208 token5 >> token_value_convert2;
209 token6 >> token_value_convert3;
210 convert_z = uiuc_convert(token_value_convert1);
211 convert_x = uiuc_convert(token_value_convert2);
212 convert_y = uiuc_convert(token_value_convert3);
213 /* call 2D File Reader with file name (Clfada) and
214 conversion factors; function returns array of
215 aileron deflections (daArray) and corresponding
216 alpha (aArray) and delta Cl (ClArray) values and
217 max number of terms in alpha arrays (nAlphaArray)
218 and deflection array (nda) */
219 uiuc_2DdataFileReader(Clfada,
225 aeroRollParts -> storeCommands (*command_line);
230 Clfbetadr = aircraft_directory + linetoken3;
231 token4 >> token_value_convert1;
232 token5 >> token_value_convert2;
233 token6 >> token_value_convert3;
234 convert_z = uiuc_convert(token_value_convert1);
235 convert_x = uiuc_convert(token_value_convert2);
236 convert_y = uiuc_convert(token_value_convert3);
237 /* call 2D File Reader with file name (Clfbetadr) and
238 conversion factors; function returns array of
239 rudder deflections (drArray) and corresponding
240 beta (betaArray) and delta Cl (ClArray) values and
241 max number of terms in beta arrays (nBetaArray)
242 and deflection array (ndr) */
243 uiuc_2DdataFileReader(Clfbetadr,
247 Clfbetadr_nBetaArray,
249 aeroRollParts -> storeCommands (*command_line);
254 int Clfabetaf_index, i;
255 string Clfabetaf_file;
257 Clfabetaf_file = aircraft_directory + linetoken3;
258 token4 >> Clfabetaf_index;
259 if (Clfabetaf_index < 0 || Clfabetaf_index >= 100)
260 uiuc_warnings_errors(1, *command_line);
261 if (Clfabetaf_index > Clfabetaf_nf)
262 Clfabetaf_nf = Clfabetaf_index;
263 token5 >> flap_value;
264 token6 >> token_value_convert1;
265 token7 >> token_value_convert2;
266 token8 >> token_value_convert3;
267 token9 >> token_value_convert4;
268 token10 >> Clfabetaf_nice;
269 convert_z = uiuc_convert(token_value_convert1);
270 convert_x = uiuc_convert(token_value_convert2);
271 convert_y = uiuc_convert(token_value_convert3);
272 convert_f = uiuc_convert(token_value_convert4);
273 Clfabetaf_fArray[Clfabetaf_index] = flap_value * convert_f;
274 /* call 2D File Reader with file name (Clfabetaf_file) and
275 conversion factors; function returns array of
276 elevator deflections (deArray) and corresponding
277 alpha (aArray) and delta CZ (CZArray) values and
278 max number of terms in alpha arrays (nAlphaArray)
279 and delfection array (nde) */
280 uiuc_2DdataFileReader(Clfabetaf_file,
286 d_2_to_3(datafile_xArray, Clfabetaf_aArray, Clfabetaf_index);
287 d_1_to_2(datafile_yArray, Clfabetaf_betaArray, Clfabetaf_index);
288 d_2_to_3(datafile_zArray, Clfabetaf_ClArray, Clfabetaf_index);
289 i_1_to_2(datafile_nxArray, Clfabetaf_nAlphaArray, Clfabetaf_index);
290 Clfabetaf_nbeta[Clfabetaf_index] = datafile_ny;
291 if (Clfabetaf_first==true)
293 if (Clfabetaf_nice == 1)
295 Clfabetaf_na_nice = datafile_nxArray[1];
296 Clfabetaf_nb_nice = datafile_ny;
297 d_1_to_1(datafile_yArray, Clfabetaf_bArray_nice);
298 for (i=1; i<=Clfabetaf_na_nice; i++)
299 Clfabetaf_aArray_nice[i] = datafile_xArray[1][i];
301 aeroRollParts -> storeCommands (*command_line);
302 Clfabetaf_first=false;
308 int Clfadaf_index, i;
311 Clfadaf_file = aircraft_directory + linetoken3;
312 token4 >> Clfadaf_index;
313 if (Clfadaf_index < 0 || Clfadaf_index >= 100)
314 uiuc_warnings_errors(1, *command_line);
315 if (Clfadaf_index > Clfadaf_nf)
316 Clfadaf_nf = Clfadaf_index;
317 token5 >> flap_value;
318 token6 >> token_value_convert1;
319 token7 >> token_value_convert2;
320 token8 >> token_value_convert3;
321 token9 >> token_value_convert4;
322 token10 >> Clfadaf_nice;
323 convert_z = uiuc_convert(token_value_convert1);
324 convert_x = uiuc_convert(token_value_convert2);
325 convert_y = uiuc_convert(token_value_convert3);
326 convert_f = uiuc_convert(token_value_convert4);
327 Clfadaf_fArray[Clfadaf_index] = flap_value * convert_f;
328 /* call 2D File Reader with file name (Clfadaf_file) and
329 conversion factors; function returns array of
330 elevator deflections (deArray) and corresponding
331 alpha (aArray) and delta CZ (CZArray) values and
332 max number of terms in alpha arrays (nAlphaArray)
333 and delfection array (nde) */
334 uiuc_2DdataFileReader(Clfadaf_file,
340 d_2_to_3(datafile_xArray, Clfadaf_aArray, Clfadaf_index);
341 d_1_to_2(datafile_yArray, Clfadaf_daArray, Clfadaf_index);
342 d_2_to_3(datafile_zArray, Clfadaf_ClArray, Clfadaf_index);
343 i_1_to_2(datafile_nxArray, Clfadaf_nAlphaArray, Clfadaf_index);
344 Clfadaf_nda[Clfadaf_index] = datafile_ny;
345 if (Clfadaf_first==true)
347 if (Clfadaf_nice == 1)
349 Clfadaf_na_nice = datafile_nxArray[1];
350 Clfadaf_nda_nice = datafile_ny;
351 d_1_to_1(datafile_yArray, Clfadaf_daArray_nice);
352 for (i=1; i<=Clfadaf_na_nice; i++)
353 Clfadaf_aArray_nice[i] = datafile_xArray[1][i];
355 aeroRollParts -> storeCommands (*command_line);
362 int Clfadrf_index, i;
365 Clfadrf_file = aircraft_directory + linetoken3;
366 token4 >> Clfadrf_index;
367 if (Clfadrf_index < 0 || Clfadrf_index >= 100)
368 uiuc_warnings_errors(1, *command_line);
369 if (Clfadrf_index > Clfadrf_nf)
370 Clfadrf_nf = Clfadrf_index;
371 token5 >> flap_value;
372 token6 >> token_value_convert1;
373 token7 >> token_value_convert2;
374 token8 >> token_value_convert3;
375 token9 >> token_value_convert4;
376 token10 >> Clfadrf_nice;
377 convert_z = uiuc_convert(token_value_convert1);
378 convert_x = uiuc_convert(token_value_convert2);
379 convert_y = uiuc_convert(token_value_convert3);
380 convert_f = uiuc_convert(token_value_convert4);
381 Clfadrf_fArray[Clfadrf_index] = flap_value * convert_f;
382 /* call 2D File Reader with file name (Clfadrf_file) and
383 conversion factors; function returns array of
384 elevator deflections (deArray) and corresponding
385 alpha (aArray) and delta CZ (CZArray) values and
386 max number of terms in alpha arrays (nAlphaArray)
387 and delfection array (nde) */
388 uiuc_2DdataFileReader(Clfadrf_file,
394 d_2_to_3(datafile_xArray, Clfadrf_aArray, Clfadrf_index);
395 d_1_to_2(datafile_yArray, Clfadrf_drArray, Clfadrf_index);
396 d_2_to_3(datafile_zArray, Clfadrf_ClArray, Clfadrf_index);
397 i_1_to_2(datafile_nxArray, Clfadrf_nAlphaArray, Clfadrf_index);
398 Clfadrf_ndr[Clfadrf_index] = datafile_ny;
399 if (Clfadrf_first==true)
401 if (Clfadrf_nice == 1)
403 Clfadrf_na_nice = datafile_nxArray[1];
404 Clfadrf_ndr_nice = datafile_ny;
405 d_1_to_1(datafile_yArray, Clfadrf_drArray_nice);
406 for (i=1; i<=Clfadrf_na_nice; i++)
407 Clfadrf_aArray_nice[i] = datafile_xArray[1][i];
409 aeroRollParts -> storeCommands (*command_line);
419 Clfapf_file = aircraft_directory + linetoken3;
420 token4 >> Clfapf_index;
421 if (Clfapf_index < 0 || Clfapf_index >= 100)
422 uiuc_warnings_errors(1, *command_line);
423 if (Clfapf_index > Clfapf_nf)
424 Clfapf_nf = Clfapf_index;
425 token5 >> flap_value;
426 token6 >> token_value_convert1;
427 token7 >> token_value_convert2;
428 token8 >> token_value_convert3;
429 token9 >> token_value_convert4;
430 token10 >> Clfapf_nice;
431 convert_z = uiuc_convert(token_value_convert1);
432 convert_x = uiuc_convert(token_value_convert2);
433 convert_y = uiuc_convert(token_value_convert3);
434 convert_f = uiuc_convert(token_value_convert4);
435 Clfapf_fArray[Clfapf_index] = flap_value * convert_f;
436 /* call 2D File Reader with file name (Clfapf_file) and
437 conversion factors; function returns array of
438 elevator deflections (deArray) and corresponding
439 alpha (aArray) and delta CZ (CZArray) values and
440 max number of terms in alpha arrays (nAlphaArray)
441 and delfection array (nde) */
442 uiuc_2DdataFileReader(Clfapf_file,
448 d_2_to_3(datafile_xArray, Clfapf_aArray, Clfapf_index);
449 d_1_to_2(datafile_yArray, Clfapf_pArray, Clfapf_index);
450 d_2_to_3(datafile_zArray, Clfapf_ClArray, Clfapf_index);
451 i_1_to_2(datafile_nxArray, Clfapf_nAlphaArray, Clfapf_index);
452 Clfapf_np[Clfapf_index] = datafile_ny;
453 if (Clfapf_first==true)
455 if (Clfapf_nice == 1)
457 Clfapf_na_nice = datafile_nxArray[1];
458 Clfapf_np_nice = datafile_ny;
459 d_1_to_1(datafile_yArray, Clfapf_pArray_nice);
460 for (i=1; i<=Clfapf_na_nice; i++)
461 Clfapf_aArray_nice[i] = datafile_xArray[1][i];
463 aeroRollParts -> storeCommands (*command_line);
473 Clfarf_file = aircraft_directory + linetoken3;
474 token4 >> Clfarf_index;
475 if (Clfarf_index < 0 || Clfarf_index >= 100)
476 uiuc_warnings_errors(1, *command_line);
477 if (Clfarf_index > Clfarf_nf)
478 Clfarf_nf = Clfarf_index;
479 token5 >> flap_value;
480 token6 >> token_value_convert1;
481 token7 >> token_value_convert2;
482 token8 >> token_value_convert3;
483 token9 >> token_value_convert4;
484 token10 >> Clfarf_nice;
485 convert_z = uiuc_convert(token_value_convert1);
486 convert_x = uiuc_convert(token_value_convert2);
487 convert_y = uiuc_convert(token_value_convert3);
488 convert_f = uiuc_convert(token_value_convert4);
489 Clfarf_fArray[Clfarf_index] = flap_value * convert_f;
490 /* call 2D File Reader with file name (Clfarf_file) and
491 conversion factors; function returns array of
492 elevator deflections (deArray) and corresponding
493 alpha (aArray) and delta CZ (CZArray) values and
494 max number of terms in alpha arrays (nAlphaArray)
495 and delfection array (nde) */
496 uiuc_2DdataFileReader(Clfarf_file,
502 d_2_to_3(datafile_xArray, Clfarf_aArray, Clfarf_index);
503 d_1_to_2(datafile_yArray, Clfarf_rArray, Clfarf_index);
504 d_2_to_3(datafile_zArray, Clfarf_ClArray, Clfarf_index);
505 i_1_to_2(datafile_nxArray, Clfarf_nAlphaArray, Clfarf_index);
506 Clfarf_nr[Clfarf_index] = datafile_ny;
507 if (Clfarf_first==true)
509 if (Clfarf_nice == 1)
511 Clfarf_na_nice = datafile_nxArray[1];
512 Clfarf_nr_nice = datafile_ny;
513 d_1_to_1(datafile_yArray, Clfarf_rArray_nice);
514 for (i=1; i<=Clfarf_na_nice; i++)
515 Clfarf_aArray_nice[i] = datafile_xArray[1][i];
517 aeroRollParts -> storeCommands (*command_line);
524 if (ignore_unknown_keywords) {
527 // print error message
528 uiuc_warnings_errors(2, *command_line);