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>
75 #if defined( __MWERKS__ )
76 // -dw- optimizer chokes (big-time) trying to optimize humongous
77 // loop/switch statements
78 #pragma optimization_level 0
85 #include "uiuc_menu_Croll.h"
95 void parse_Cl( const string& linetoken2, const string& linetoken3,
96 const string& linetoken4, const string& linetoken5,
97 const string& linetoken6, const string& linetoken7,
98 const string& linetoken8, const string& linetoken9,
99 const string& linetoken10, const string& aircraft_directory,
100 LIST command_line ) {
102 int token_value_convert1, token_value_convert2, token_value_convert3;
103 int token_value_convert4;
104 double datafile_xArray[100][100], datafile_yArray[100];
105 double datafile_zArray[100][100];
107 int datafile_nxArray[100], datafile_ny;
108 istringstream token3(linetoken3.c_str());
109 istringstream token4(linetoken4.c_str());
110 istringstream token5(linetoken5.c_str());
111 istringstream token6(linetoken6.c_str());
112 istringstream token7(linetoken7.c_str());
113 istringstream token8(linetoken8.c_str());
114 istringstream token9(linetoken9.c_str());
115 istringstream token10(linetoken10.c_str());
117 static bool Clfabetaf_first = true;
118 static bool Clfadaf_first = true;
119 static bool Clfadrf_first = true;
120 static bool Clfapf_first = true;
121 static bool Clfarf_first = true;
123 switch(Cl_map[linetoken2])
127 if (check_float(linetoken3))
128 token3 >> token_value;
130 uiuc_warnings_errors(1, *command_line);
134 aeroRollParts -> storeCommands (*command_line);
139 if (check_float(linetoken3))
140 token3 >> token_value;
142 uiuc_warnings_errors(1, *command_line);
144 Cl_beta = token_value;
145 Cl_beta_clean = Cl_beta;
146 aeroRollParts -> storeCommands (*command_line);
151 if (check_float(linetoken3))
152 token3 >> token_value;
154 uiuc_warnings_errors(1, *command_line);
158 aeroRollParts -> storeCommands (*command_line);
163 if (check_float(linetoken3))
164 token3 >> token_value;
166 uiuc_warnings_errors(1, *command_line);
170 aeroRollParts -> storeCommands (*command_line);
175 if (check_float(linetoken3))
176 token3 >> token_value;
178 uiuc_warnings_errors(1, *command_line);
182 aeroRollParts -> storeCommands (*command_line);
187 if (check_float(linetoken3))
188 token3 >> token_value;
190 uiuc_warnings_errors(1, *command_line);
194 aeroRollParts -> storeCommands (*command_line);
199 if (check_float(linetoken3))
200 token3 >> token_value;
202 uiuc_warnings_errors(1, *command_line);
204 Cl_daa = token_value;
205 Cl_daa_clean = Cl_daa;
206 aeroRollParts -> storeCommands (*command_line);
211 Clfada = aircraft_directory + linetoken3;
212 token4 >> token_value_convert1;
213 token5 >> token_value_convert2;
214 token6 >> token_value_convert3;
215 convert_z = uiuc_convert(token_value_convert1);
216 convert_x = uiuc_convert(token_value_convert2);
217 convert_y = uiuc_convert(token_value_convert3);
218 /* call 2D File Reader with file name (Clfada) and
219 conversion factors; function returns array of
220 aileron deflections (daArray) and corresponding
221 alpha (aArray) and delta Cl (ClArray) values and
222 max number of terms in alpha arrays (nAlphaArray)
223 and deflection array (nda) */
224 uiuc_2DdataFileReader(Clfada,
230 aeroRollParts -> storeCommands (*command_line);
235 Clfbetadr = aircraft_directory + linetoken3;
236 token4 >> token_value_convert1;
237 token5 >> token_value_convert2;
238 token6 >> token_value_convert3;
239 convert_z = uiuc_convert(token_value_convert1);
240 convert_x = uiuc_convert(token_value_convert2);
241 convert_y = uiuc_convert(token_value_convert3);
242 /* call 2D File Reader with file name (Clfbetadr) and
243 conversion factors; function returns array of
244 rudder deflections (drArray) and corresponding
245 beta (betaArray) and delta Cl (ClArray) values and
246 max number of terms in beta arrays (nBetaArray)
247 and deflection array (ndr) */
248 uiuc_2DdataFileReader(Clfbetadr,
252 Clfbetadr_nBetaArray,
254 aeroRollParts -> storeCommands (*command_line);
259 int Clfabetaf_index, i;
260 string Clfabetaf_file;
262 Clfabetaf_file = aircraft_directory + linetoken3;
263 token4 >> Clfabetaf_index;
264 if (Clfabetaf_index < 0 || Clfabetaf_index >= 100)
265 uiuc_warnings_errors(1, *command_line);
266 if (Clfabetaf_index > Clfabetaf_nf)
267 Clfabetaf_nf = Clfabetaf_index;
268 token5 >> flap_value;
269 token6 >> token_value_convert1;
270 token7 >> token_value_convert2;
271 token8 >> token_value_convert3;
272 token9 >> token_value_convert4;
273 token10 >> Clfabetaf_nice;
274 convert_z = uiuc_convert(token_value_convert1);
275 convert_x = uiuc_convert(token_value_convert2);
276 convert_y = uiuc_convert(token_value_convert3);
277 convert_f = uiuc_convert(token_value_convert4);
278 Clfabetaf_fArray[Clfabetaf_index] = flap_value * convert_f;
279 /* call 2D File Reader with file name (Clfabetaf_file) and
280 conversion factors; function returns array of
281 elevator deflections (deArray) and corresponding
282 alpha (aArray) and delta CZ (CZArray) values and
283 max number of terms in alpha arrays (nAlphaArray)
284 and delfection array (nde) */
285 uiuc_2DdataFileReader(Clfabetaf_file,
291 d_2_to_3(datafile_xArray, Clfabetaf_aArray, Clfabetaf_index);
292 d_1_to_2(datafile_yArray, Clfabetaf_betaArray, Clfabetaf_index);
293 d_2_to_3(datafile_zArray, Clfabetaf_ClArray, Clfabetaf_index);
294 i_1_to_2(datafile_nxArray, Clfabetaf_nAlphaArray, Clfabetaf_index);
295 Clfabetaf_nbeta[Clfabetaf_index] = datafile_ny;
296 if (Clfabetaf_first==true)
298 if (Clfabetaf_nice == 1)
300 Clfabetaf_na_nice = datafile_nxArray[1];
301 Clfabetaf_nb_nice = datafile_ny;
302 d_1_to_1(datafile_yArray, Clfabetaf_bArray_nice);
303 for (i=1; i<=Clfabetaf_na_nice; i++)
304 Clfabetaf_aArray_nice[i] = datafile_xArray[1][i];
306 aeroRollParts -> storeCommands (*command_line);
307 Clfabetaf_first=false;
313 int Clfadaf_index, i;
316 Clfadaf_file = aircraft_directory + linetoken3;
317 token4 >> Clfadaf_index;
318 if (Clfadaf_index < 0 || Clfadaf_index >= 100)
319 uiuc_warnings_errors(1, *command_line);
320 if (Clfadaf_index > Clfadaf_nf)
321 Clfadaf_nf = Clfadaf_index;
322 token5 >> flap_value;
323 token6 >> token_value_convert1;
324 token7 >> token_value_convert2;
325 token8 >> token_value_convert3;
326 token9 >> token_value_convert4;
327 token10 >> Clfadaf_nice;
328 convert_z = uiuc_convert(token_value_convert1);
329 convert_x = uiuc_convert(token_value_convert2);
330 convert_y = uiuc_convert(token_value_convert3);
331 convert_f = uiuc_convert(token_value_convert4);
332 Clfadaf_fArray[Clfadaf_index] = flap_value * convert_f;
333 /* call 2D File Reader with file name (Clfadaf_file) and
334 conversion factors; function returns array of
335 elevator deflections (deArray) and corresponding
336 alpha (aArray) and delta CZ (CZArray) values and
337 max number of terms in alpha arrays (nAlphaArray)
338 and delfection array (nde) */
339 uiuc_2DdataFileReader(Clfadaf_file,
345 d_2_to_3(datafile_xArray, Clfadaf_aArray, Clfadaf_index);
346 d_1_to_2(datafile_yArray, Clfadaf_daArray, Clfadaf_index);
347 d_2_to_3(datafile_zArray, Clfadaf_ClArray, Clfadaf_index);
348 i_1_to_2(datafile_nxArray, Clfadaf_nAlphaArray, Clfadaf_index);
349 Clfadaf_nda[Clfadaf_index] = datafile_ny;
350 if (Clfadaf_first==true)
352 if (Clfadaf_nice == 1)
354 Clfadaf_na_nice = datafile_nxArray[1];
355 Clfadaf_nda_nice = datafile_ny;
356 d_1_to_1(datafile_yArray, Clfadaf_daArray_nice);
357 for (i=1; i<=Clfadaf_na_nice; i++)
358 Clfadaf_aArray_nice[i] = datafile_xArray[1][i];
360 aeroRollParts -> storeCommands (*command_line);
367 int Clfadrf_index, i;
370 Clfadrf_file = aircraft_directory + linetoken3;
371 token4 >> Clfadrf_index;
372 if (Clfadrf_index < 0 || Clfadrf_index >= 100)
373 uiuc_warnings_errors(1, *command_line);
374 if (Clfadrf_index > Clfadrf_nf)
375 Clfadrf_nf = Clfadrf_index;
376 token5 >> flap_value;
377 token6 >> token_value_convert1;
378 token7 >> token_value_convert2;
379 token8 >> token_value_convert3;
380 token9 >> token_value_convert4;
381 token10 >> Clfadrf_nice;
382 convert_z = uiuc_convert(token_value_convert1);
383 convert_x = uiuc_convert(token_value_convert2);
384 convert_y = uiuc_convert(token_value_convert3);
385 convert_f = uiuc_convert(token_value_convert4);
386 Clfadrf_fArray[Clfadrf_index] = flap_value * convert_f;
387 /* call 2D File Reader with file name (Clfadrf_file) and
388 conversion factors; function returns array of
389 elevator deflections (deArray) and corresponding
390 alpha (aArray) and delta CZ (CZArray) values and
391 max number of terms in alpha arrays (nAlphaArray)
392 and delfection array (nde) */
393 uiuc_2DdataFileReader(Clfadrf_file,
399 d_2_to_3(datafile_xArray, Clfadrf_aArray, Clfadrf_index);
400 d_1_to_2(datafile_yArray, Clfadrf_drArray, Clfadrf_index);
401 d_2_to_3(datafile_zArray, Clfadrf_ClArray, Clfadrf_index);
402 i_1_to_2(datafile_nxArray, Clfadrf_nAlphaArray, Clfadrf_index);
403 Clfadrf_ndr[Clfadrf_index] = datafile_ny;
404 if (Clfadrf_first==true)
406 if (Clfadrf_nice == 1)
408 Clfadrf_na_nice = datafile_nxArray[1];
409 Clfadrf_ndr_nice = datafile_ny;
410 d_1_to_1(datafile_yArray, Clfadrf_drArray_nice);
411 for (i=1; i<=Clfadrf_na_nice; i++)
412 Clfadrf_aArray_nice[i] = datafile_xArray[1][i];
414 aeroRollParts -> storeCommands (*command_line);
424 Clfapf_file = aircraft_directory + linetoken3;
425 token4 >> Clfapf_index;
426 if (Clfapf_index < 0 || Clfapf_index >= 100)
427 uiuc_warnings_errors(1, *command_line);
428 if (Clfapf_index > Clfapf_nf)
429 Clfapf_nf = Clfapf_index;
430 token5 >> flap_value;
431 token6 >> token_value_convert1;
432 token7 >> token_value_convert2;
433 token8 >> token_value_convert3;
434 token9 >> token_value_convert4;
435 token10 >> Clfapf_nice;
436 convert_z = uiuc_convert(token_value_convert1);
437 convert_x = uiuc_convert(token_value_convert2);
438 convert_y = uiuc_convert(token_value_convert3);
439 convert_f = uiuc_convert(token_value_convert4);
440 Clfapf_fArray[Clfapf_index] = flap_value * convert_f;
441 /* call 2D File Reader with file name (Clfapf_file) and
442 conversion factors; function returns array of
443 elevator deflections (deArray) and corresponding
444 alpha (aArray) and delta CZ (CZArray) values and
445 max number of terms in alpha arrays (nAlphaArray)
446 and delfection array (nde) */
447 uiuc_2DdataFileReader(Clfapf_file,
453 d_2_to_3(datafile_xArray, Clfapf_aArray, Clfapf_index);
454 d_1_to_2(datafile_yArray, Clfapf_pArray, Clfapf_index);
455 d_2_to_3(datafile_zArray, Clfapf_ClArray, Clfapf_index);
456 i_1_to_2(datafile_nxArray, Clfapf_nAlphaArray, Clfapf_index);
457 Clfapf_np[Clfapf_index] = datafile_ny;
458 if (Clfapf_first==true)
460 if (Clfapf_nice == 1)
462 Clfapf_na_nice = datafile_nxArray[1];
463 Clfapf_np_nice = datafile_ny;
464 d_1_to_1(datafile_yArray, Clfapf_pArray_nice);
465 for (i=1; i<=Clfapf_na_nice; i++)
466 Clfapf_aArray_nice[i] = datafile_xArray[1][i];
468 aeroRollParts -> storeCommands (*command_line);
478 Clfarf_file = aircraft_directory + linetoken3;
479 token4 >> Clfarf_index;
480 if (Clfarf_index < 0 || Clfarf_index >= 100)
481 uiuc_warnings_errors(1, *command_line);
482 if (Clfarf_index > Clfarf_nf)
483 Clfarf_nf = Clfarf_index;
484 token5 >> flap_value;
485 token6 >> token_value_convert1;
486 token7 >> token_value_convert2;
487 token8 >> token_value_convert3;
488 token9 >> token_value_convert4;
489 token10 >> Clfarf_nice;
490 convert_z = uiuc_convert(token_value_convert1);
491 convert_x = uiuc_convert(token_value_convert2);
492 convert_y = uiuc_convert(token_value_convert3);
493 convert_f = uiuc_convert(token_value_convert4);
494 Clfarf_fArray[Clfarf_index] = flap_value * convert_f;
495 /* call 2D File Reader with file name (Clfarf_file) and
496 conversion factors; function returns array of
497 elevator deflections (deArray) and corresponding
498 alpha (aArray) and delta CZ (CZArray) values and
499 max number of terms in alpha arrays (nAlphaArray)
500 and delfection array (nde) */
501 uiuc_2DdataFileReader(Clfarf_file,
507 d_2_to_3(datafile_xArray, Clfarf_aArray, Clfarf_index);
508 d_1_to_2(datafile_yArray, Clfarf_rArray, Clfarf_index);
509 d_2_to_3(datafile_zArray, Clfarf_ClArray, Clfarf_index);
510 i_1_to_2(datafile_nxArray, Clfarf_nAlphaArray, Clfarf_index);
511 Clfarf_nr[Clfarf_index] = datafile_ny;
512 if (Clfarf_first==true)
514 if (Clfarf_nice == 1)
516 Clfarf_na_nice = datafile_nxArray[1];
517 Clfarf_nr_nice = datafile_ny;
518 d_1_to_1(datafile_yArray, Clfarf_rArray_nice);
519 for (i=1; i<=Clfarf_na_nice; i++)
520 Clfarf_aArray_nice[i] = datafile_xArray[1][i];
522 aeroRollParts -> storeCommands (*command_line);
529 if (ignore_unknown_keywords) {
532 // print error message
533 uiuc_warnings_errors(2, *command_line);