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
22 ----------------------------------------------------------------------
24 AUTHOR(S): Robert Deters <rdeters@uiuc.edu>
25 Michael Selig <m-selig@uiuc.edu>
27 ----------------------------------------------------------------------
31 ----------------------------------------------------------------------
35 ----------------------------------------------------------------------
39 ----------------------------------------------------------------------
41 CALLED BY: uiuc_menu()
43 ----------------------------------------------------------------------
45 CALLS TO: check_float() if needed
51 ----------------------------------------------------------------------
53 COPYRIGHT: (C) 2003 by Michael Selig
55 This program is free software; you can redistribute it and/or
56 modify it under the terms of the GNU General Public License
57 as published by the Free Software Foundation.
59 This program is distributed in the hope that it will be useful,
60 but WITHOUT ANY WARRANTY; without even the implied warranty of
61 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
62 GNU General Public License for more details.
64 You should have received a copy of the GNU General Public License
65 along with this program; if not, write to the Free Software
66 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
67 USA or view http://www.gnu.org/copyleft/gpl.html.
69 **********************************************************************/
71 #include <simgear/compiler.h>
73 #if defined( __MWERKS__ )
74 // -dw- optimizer chokes (big-time) trying to optimize humongous
75 // loop/switch statements
76 #pragma optimization_level 0
83 #include "uiuc_menu_Croll.h"
93 void parse_Cl( const string& linetoken2, const string& linetoken3,
94 const string& linetoken4, const string& linetoken5,
95 const string& linetoken6, const string& linetoken7,
96 const string& linetoken8, const string& linetoken9,
97 const string& linetoken10, const string& aircraft_directory,
100 int token_value_convert1, token_value_convert2, token_value_convert3;
101 int token_value_convert4;
102 double datafile_xArray[100][100], datafile_yArray[100];
103 double datafile_zArray[100][100];
105 int datafile_nxArray[100], datafile_ny;
106 istrstream token3(linetoken3.c_str());
107 istrstream token4(linetoken4.c_str());
108 istrstream token5(linetoken5.c_str());
109 istrstream token6(linetoken6.c_str());
110 istrstream token7(linetoken7.c_str());
111 istrstream token8(linetoken8.c_str());
112 istrstream token9(linetoken9.c_str());
113 istrstream token10(linetoken10.c_str());
115 static bool Clfabetaf_first = true;
116 static bool Clfadaf_first = true;
117 static bool Clfadrf_first = true;
118 static bool Clfapf_first = true;
119 static bool Clfarf_first = true;
121 switch(Cl_map[linetoken2])
125 if (check_float(linetoken3))
126 token3 >> token_value;
128 uiuc_warnings_errors(1, *command_line);
132 aeroRollParts -> storeCommands (*command_line);
137 if (check_float(linetoken3))
138 token3 >> token_value;
140 uiuc_warnings_errors(1, *command_line);
142 Cl_beta = token_value;
143 Cl_beta_clean = Cl_beta;
144 aeroRollParts -> storeCommands (*command_line);
149 if (check_float(linetoken3))
150 token3 >> token_value;
152 uiuc_warnings_errors(1, *command_line);
156 aeroRollParts -> storeCommands (*command_line);
161 if (check_float(linetoken3))
162 token3 >> token_value;
164 uiuc_warnings_errors(1, *command_line);
168 aeroRollParts -> storeCommands (*command_line);
173 if (check_float(linetoken3))
174 token3 >> token_value;
176 uiuc_warnings_errors(1, *command_line);
180 aeroRollParts -> storeCommands (*command_line);
185 if (check_float(linetoken3))
186 token3 >> token_value;
188 uiuc_warnings_errors(1, *command_line);
192 aeroRollParts -> storeCommands (*command_line);
197 if (check_float(linetoken3))
198 token3 >> token_value;
200 uiuc_warnings_errors(1, *command_line);
202 Cl_daa = token_value;
203 Cl_daa_clean = Cl_daa;
204 aeroRollParts -> storeCommands (*command_line);
209 Clfada = aircraft_directory + linetoken3;
210 token4 >> token_value_convert1;
211 token5 >> token_value_convert2;
212 token6 >> token_value_convert3;
213 convert_z = uiuc_convert(token_value_convert1);
214 convert_x = uiuc_convert(token_value_convert2);
215 convert_y = uiuc_convert(token_value_convert3);
216 /* call 2D File Reader with file name (Clfada) and
217 conversion factors; function returns array of
218 aileron deflections (daArray) and corresponding
219 alpha (aArray) and delta Cl (ClArray) values and
220 max number of terms in alpha arrays (nAlphaArray)
221 and deflection array (nda) */
222 uiuc_2DdataFileReader(Clfada,
228 aeroRollParts -> storeCommands (*command_line);
233 Clfbetadr = aircraft_directory + linetoken3;
234 token4 >> token_value_convert1;
235 token5 >> token_value_convert2;
236 token6 >> token_value_convert3;
237 convert_z = uiuc_convert(token_value_convert1);
238 convert_x = uiuc_convert(token_value_convert2);
239 convert_y = uiuc_convert(token_value_convert3);
240 /* call 2D File Reader with file name (Clfbetadr) and
241 conversion factors; function returns array of
242 rudder deflections (drArray) and corresponding
243 beta (betaArray) and delta Cl (ClArray) values and
244 max number of terms in beta arrays (nBetaArray)
245 and deflection array (ndr) */
246 uiuc_2DdataFileReader(Clfbetadr,
250 Clfbetadr_nBetaArray,
252 aeroRollParts -> storeCommands (*command_line);
257 int Clfabetaf_index, i;
258 string Clfabetaf_file;
260 Clfabetaf_file = aircraft_directory + linetoken3;
261 token4 >> Clfabetaf_index;
262 if (Clfabetaf_index < 0 || Clfabetaf_index >= 100)
263 uiuc_warnings_errors(1, *command_line);
264 if (Clfabetaf_index > Clfabetaf_nf)
265 Clfabetaf_nf = Clfabetaf_index;
266 token5 >> flap_value;
267 token6 >> token_value_convert1;
268 token7 >> token_value_convert2;
269 token8 >> token_value_convert3;
270 token9 >> token_value_convert4;
271 token10 >> Clfabetaf_nice;
272 convert_z = uiuc_convert(token_value_convert1);
273 convert_x = uiuc_convert(token_value_convert2);
274 convert_y = uiuc_convert(token_value_convert3);
275 convert_f = uiuc_convert(token_value_convert4);
276 Clfabetaf_fArray[Clfabetaf_index] = flap_value * convert_f;
277 /* call 2D File Reader with file name (Clfabetaf_file) and
278 conversion factors; function returns array of
279 elevator deflections (deArray) and corresponding
280 alpha (aArray) and delta CZ (CZArray) values and
281 max number of terms in alpha arrays (nAlphaArray)
282 and delfection array (nde) */
283 uiuc_2DdataFileReader(Clfabetaf_file,
289 d_2_to_3(datafile_xArray, Clfabetaf_aArray, Clfabetaf_index);
290 d_1_to_2(datafile_yArray, Clfabetaf_betaArray, Clfabetaf_index);
291 d_2_to_3(datafile_zArray, Clfabetaf_ClArray, Clfabetaf_index);
292 i_1_to_2(datafile_nxArray, Clfabetaf_nAlphaArray, Clfabetaf_index);
293 Clfabetaf_nbeta[Clfabetaf_index] = datafile_ny;
294 if (Clfabetaf_first==true)
296 if (Clfabetaf_nice == 1)
298 Clfabetaf_na_nice = datafile_nxArray[1];
299 Clfabetaf_nb_nice = datafile_ny;
300 d_1_to_1(datafile_yArray, Clfabetaf_bArray_nice);
301 for (i=1; i<=Clfabetaf_na_nice; i++)
302 Clfabetaf_aArray_nice[i] = datafile_xArray[1][i];
304 aeroRollParts -> storeCommands (*command_line);
305 Clfabetaf_first=false;
311 int Clfadaf_index, i;
314 Clfadaf_file = aircraft_directory + linetoken3;
315 token4 >> Clfadaf_index;
316 if (Clfadaf_index < 0 || Clfadaf_index >= 100)
317 uiuc_warnings_errors(1, *command_line);
318 if (Clfadaf_index > Clfadaf_nf)
319 Clfadaf_nf = Clfadaf_index;
320 token5 >> flap_value;
321 token6 >> token_value_convert1;
322 token7 >> token_value_convert2;
323 token8 >> token_value_convert3;
324 token9 >> token_value_convert4;
325 token10 >> Clfadaf_nice;
326 convert_z = uiuc_convert(token_value_convert1);
327 convert_x = uiuc_convert(token_value_convert2);
328 convert_y = uiuc_convert(token_value_convert3);
329 convert_f = uiuc_convert(token_value_convert4);
330 Clfadaf_fArray[Clfadaf_index] = flap_value * convert_f;
331 /* call 2D File Reader with file name (Clfadaf_file) and
332 conversion factors; function returns array of
333 elevator deflections (deArray) and corresponding
334 alpha (aArray) and delta CZ (CZArray) values and
335 max number of terms in alpha arrays (nAlphaArray)
336 and delfection array (nde) */
337 uiuc_2DdataFileReader(Clfadaf_file,
343 d_2_to_3(datafile_xArray, Clfadaf_aArray, Clfadaf_index);
344 d_1_to_2(datafile_yArray, Clfadaf_daArray, Clfadaf_index);
345 d_2_to_3(datafile_zArray, Clfadaf_ClArray, Clfadaf_index);
346 i_1_to_2(datafile_nxArray, Clfadaf_nAlphaArray, Clfadaf_index);
347 Clfadaf_nda[Clfadaf_index] = datafile_ny;
348 if (Clfadaf_first==true)
350 if (Clfadaf_nice == 1)
352 Clfadaf_na_nice = datafile_nxArray[1];
353 Clfadaf_nda_nice = datafile_ny;
354 d_1_to_1(datafile_yArray, Clfadaf_daArray_nice);
355 for (i=1; i<=Clfadaf_na_nice; i++)
356 Clfadaf_aArray_nice[i] = datafile_xArray[1][i];
358 aeroRollParts -> storeCommands (*command_line);
365 int Clfadrf_index, i;
368 Clfadrf_file = aircraft_directory + linetoken3;
369 token4 >> Clfadrf_index;
370 if (Clfadrf_index < 0 || Clfadrf_index >= 100)
371 uiuc_warnings_errors(1, *command_line);
372 if (Clfadrf_index > Clfadrf_nf)
373 Clfadrf_nf = Clfadrf_index;
374 token5 >> flap_value;
375 token6 >> token_value_convert1;
376 token7 >> token_value_convert2;
377 token8 >> token_value_convert3;
378 token9 >> token_value_convert4;
379 token10 >> Clfadrf_nice;
380 convert_z = uiuc_convert(token_value_convert1);
381 convert_x = uiuc_convert(token_value_convert2);
382 convert_y = uiuc_convert(token_value_convert3);
383 convert_f = uiuc_convert(token_value_convert4);
384 Clfadrf_fArray[Clfadrf_index] = flap_value * convert_f;
385 /* call 2D File Reader with file name (Clfadrf_file) and
386 conversion factors; function returns array of
387 elevator deflections (deArray) and corresponding
388 alpha (aArray) and delta CZ (CZArray) values and
389 max number of terms in alpha arrays (nAlphaArray)
390 and delfection array (nde) */
391 uiuc_2DdataFileReader(Clfadrf_file,
397 d_2_to_3(datafile_xArray, Clfadrf_aArray, Clfadrf_index);
398 d_1_to_2(datafile_yArray, Clfadrf_drArray, Clfadrf_index);
399 d_2_to_3(datafile_zArray, Clfadrf_ClArray, Clfadrf_index);
400 i_1_to_2(datafile_nxArray, Clfadrf_nAlphaArray, Clfadrf_index);
401 Clfadrf_ndr[Clfadrf_index] = datafile_ny;
402 if (Clfadrf_first==true)
404 if (Clfadrf_nice == 1)
406 Clfadrf_na_nice = datafile_nxArray[1];
407 Clfadrf_ndr_nice = datafile_ny;
408 d_1_to_1(datafile_yArray, Clfadrf_drArray_nice);
409 for (i=1; i<=Clfadrf_na_nice; i++)
410 Clfadrf_aArray_nice[i] = datafile_xArray[1][i];
412 aeroRollParts -> storeCommands (*command_line);
422 Clfapf_file = aircraft_directory + linetoken3;
423 token4 >> Clfapf_index;
424 if (Clfapf_index < 0 || Clfapf_index >= 100)
425 uiuc_warnings_errors(1, *command_line);
426 if (Clfapf_index > Clfapf_nf)
427 Clfapf_nf = Clfapf_index;
428 token5 >> flap_value;
429 token6 >> token_value_convert1;
430 token7 >> token_value_convert2;
431 token8 >> token_value_convert3;
432 token9 >> token_value_convert4;
433 token10 >> Clfapf_nice;
434 convert_z = uiuc_convert(token_value_convert1);
435 convert_x = uiuc_convert(token_value_convert2);
436 convert_y = uiuc_convert(token_value_convert3);
437 convert_f = uiuc_convert(token_value_convert4);
438 Clfapf_fArray[Clfapf_index] = flap_value * convert_f;
439 /* call 2D File Reader with file name (Clfapf_file) and
440 conversion factors; function returns array of
441 elevator deflections (deArray) and corresponding
442 alpha (aArray) and delta CZ (CZArray) values and
443 max number of terms in alpha arrays (nAlphaArray)
444 and delfection array (nde) */
445 uiuc_2DdataFileReader(Clfapf_file,
451 d_2_to_3(datafile_xArray, Clfapf_aArray, Clfapf_index);
452 d_1_to_2(datafile_yArray, Clfapf_pArray, Clfapf_index);
453 d_2_to_3(datafile_zArray, Clfapf_ClArray, Clfapf_index);
454 i_1_to_2(datafile_nxArray, Clfapf_nAlphaArray, Clfapf_index);
455 Clfapf_np[Clfapf_index] = datafile_ny;
456 if (Clfapf_first==true)
458 if (Clfapf_nice == 1)
460 Clfapf_na_nice = datafile_nxArray[1];
461 Clfapf_np_nice = datafile_ny;
462 d_1_to_1(datafile_yArray, Clfapf_pArray_nice);
463 for (i=1; i<=Clfapf_na_nice; i++)
464 Clfapf_aArray_nice[i] = datafile_xArray[1][i];
466 aeroRollParts -> storeCommands (*command_line);
476 Clfarf_file = aircraft_directory + linetoken3;
477 token4 >> Clfarf_index;
478 if (Clfarf_index < 0 || Clfarf_index >= 100)
479 uiuc_warnings_errors(1, *command_line);
480 if (Clfarf_index > Clfarf_nf)
481 Clfarf_nf = Clfarf_index;
482 token5 >> flap_value;
483 token6 >> token_value_convert1;
484 token7 >> token_value_convert2;
485 token8 >> token_value_convert3;
486 token9 >> token_value_convert4;
487 token10 >> Clfarf_nice;
488 convert_z = uiuc_convert(token_value_convert1);
489 convert_x = uiuc_convert(token_value_convert2);
490 convert_y = uiuc_convert(token_value_convert3);
491 convert_f = uiuc_convert(token_value_convert4);
492 Clfarf_fArray[Clfarf_index] = flap_value * convert_f;
493 /* call 2D File Reader with file name (Clfarf_file) and
494 conversion factors; function returns array of
495 elevator deflections (deArray) and corresponding
496 alpha (aArray) and delta CZ (CZArray) values and
497 max number of terms in alpha arrays (nAlphaArray)
498 and delfection array (nde) */
499 uiuc_2DdataFileReader(Clfarf_file,
505 d_2_to_3(datafile_xArray, Clfarf_aArray, Clfarf_index);
506 d_1_to_2(datafile_yArray, Clfarf_rArray, Clfarf_index);
507 d_2_to_3(datafile_zArray, Clfarf_ClArray, Clfarf_index);
508 i_1_to_2(datafile_nxArray, Clfarf_nAlphaArray, Clfarf_index);
509 Clfarf_nr[Clfarf_index] = datafile_ny;
510 if (Clfarf_first==true)
512 if (Clfarf_nice == 1)
514 Clfarf_na_nice = datafile_nxArray[1];
515 Clfarf_nr_nice = datafile_ny;
516 d_1_to_1(datafile_yArray, Clfarf_rArray_nice);
517 for (i=1; i<=Clfarf_na_nice; i++)
518 Clfarf_aArray_nice[i] = datafile_xArray[1][i];
520 aeroRollParts -> storeCommands (*command_line);
527 if (ignore_unknown_keywords) {
530 // print error message
531 uiuc_warnings_errors(2, *command_line);