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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
70 USA or view http://www.gnu.org/copyleft/gpl.html.
72 **********************************************************************/
74 #include <simgear/compiler.h>
76 #if defined( __MWERKS__ )
77 // -dw- optimizer chokes (big-time) trying to optimize humongous
78 // loop/switch statements
79 #pragma optimization_level 0
86 #include "uiuc_menu_Croll.h"
96 void parse_Cl( const string& linetoken2, const string& linetoken3,
97 const string& linetoken4, const string& linetoken5,
98 const string& linetoken6, const string& linetoken7,
99 const string& linetoken8, const string& linetoken9,
100 const string& linetoken10, const string& aircraft_directory,
101 LIST command_line ) {
103 int token_value_convert1, token_value_convert2, token_value_convert3;
104 int token_value_convert4;
105 double datafile_xArray[100][100], datafile_yArray[100];
106 double datafile_zArray[100][100];
108 int datafile_nxArray[100], datafile_ny;
109 istringstream token3(linetoken3.c_str());
110 istringstream token4(linetoken4.c_str());
111 istringstream token5(linetoken5.c_str());
112 istringstream token6(linetoken6.c_str());
113 istringstream token7(linetoken7.c_str());
114 istringstream token8(linetoken8.c_str());
115 istringstream token9(linetoken9.c_str());
116 istringstream token10(linetoken10.c_str());
118 static bool Clfabetaf_first = true;
119 static bool Clfadaf_first = true;
120 static bool Clfadrf_first = true;
121 static bool Clfapf_first = true;
122 static bool Clfarf_first = true;
124 switch(Cl_map[linetoken2])
128 if (check_float(linetoken3))
129 token3 >> token_value;
131 uiuc_warnings_errors(1, *command_line);
135 aeroRollParts -> storeCommands (*command_line);
140 if (check_float(linetoken3))
141 token3 >> token_value;
143 uiuc_warnings_errors(1, *command_line);
145 Cl_beta = token_value;
146 Cl_beta_clean = Cl_beta;
147 aeroRollParts -> storeCommands (*command_line);
152 if (check_float(linetoken3))
153 token3 >> token_value;
155 uiuc_warnings_errors(1, *command_line);
159 aeroRollParts -> storeCommands (*command_line);
164 if (check_float(linetoken3))
165 token3 >> token_value;
167 uiuc_warnings_errors(1, *command_line);
171 aeroRollParts -> storeCommands (*command_line);
176 if (check_float(linetoken3))
177 token3 >> token_value;
179 uiuc_warnings_errors(1, *command_line);
183 aeroRollParts -> storeCommands (*command_line);
188 if (check_float(linetoken3))
189 token3 >> token_value;
191 uiuc_warnings_errors(1, *command_line);
195 aeroRollParts -> storeCommands (*command_line);
200 if (check_float(linetoken3))
201 token3 >> token_value;
203 uiuc_warnings_errors(1, *command_line);
205 Cl_daa = token_value;
206 Cl_daa_clean = Cl_daa;
207 aeroRollParts -> storeCommands (*command_line);
212 Clfada = aircraft_directory + linetoken3;
213 token4 >> token_value_convert1;
214 token5 >> token_value_convert2;
215 token6 >> token_value_convert3;
216 convert_z = uiuc_convert(token_value_convert1);
217 convert_x = uiuc_convert(token_value_convert2);
218 convert_y = uiuc_convert(token_value_convert3);
219 /* call 2D File Reader with file name (Clfada) and
220 conversion factors; function returns array of
221 aileron deflections (daArray) and corresponding
222 alpha (aArray) and delta Cl (ClArray) values and
223 max number of terms in alpha arrays (nAlphaArray)
224 and deflection array (nda) */
225 uiuc_2DdataFileReader(Clfada,
231 aeroRollParts -> storeCommands (*command_line);
236 Clfbetadr = aircraft_directory + linetoken3;
237 token4 >> token_value_convert1;
238 token5 >> token_value_convert2;
239 token6 >> token_value_convert3;
240 convert_z = uiuc_convert(token_value_convert1);
241 convert_x = uiuc_convert(token_value_convert2);
242 convert_y = uiuc_convert(token_value_convert3);
243 /* call 2D File Reader with file name (Clfbetadr) and
244 conversion factors; function returns array of
245 rudder deflections (drArray) and corresponding
246 beta (betaArray) and delta Cl (ClArray) values and
247 max number of terms in beta arrays (nBetaArray)
248 and deflection array (ndr) */
249 uiuc_2DdataFileReader(Clfbetadr,
253 Clfbetadr_nBetaArray,
255 aeroRollParts -> storeCommands (*command_line);
260 int Clfabetaf_index, i;
261 string Clfabetaf_file;
263 Clfabetaf_file = aircraft_directory + linetoken3;
264 token4 >> Clfabetaf_index;
265 if (Clfabetaf_index < 0 || Clfabetaf_index >= 100)
266 uiuc_warnings_errors(1, *command_line);
267 if (Clfabetaf_index > Clfabetaf_nf)
268 Clfabetaf_nf = Clfabetaf_index;
269 token5 >> flap_value;
270 token6 >> token_value_convert1;
271 token7 >> token_value_convert2;
272 token8 >> token_value_convert3;
273 token9 >> token_value_convert4;
274 token10 >> Clfabetaf_nice;
275 convert_z = uiuc_convert(token_value_convert1);
276 convert_x = uiuc_convert(token_value_convert2);
277 convert_y = uiuc_convert(token_value_convert3);
278 convert_f = uiuc_convert(token_value_convert4);
279 Clfabetaf_fArray[Clfabetaf_index] = flap_value * convert_f;
280 /* call 2D File Reader with file name (Clfabetaf_file) and
281 conversion factors; function returns array of
282 elevator deflections (deArray) and corresponding
283 alpha (aArray) and delta CZ (CZArray) values and
284 max number of terms in alpha arrays (nAlphaArray)
285 and delfection array (nde) */
286 uiuc_2DdataFileReader(Clfabetaf_file,
292 d_2_to_3(datafile_xArray, Clfabetaf_aArray, Clfabetaf_index);
293 d_1_to_2(datafile_yArray, Clfabetaf_betaArray, Clfabetaf_index);
294 d_2_to_3(datafile_zArray, Clfabetaf_ClArray, Clfabetaf_index);
295 i_1_to_2(datafile_nxArray, Clfabetaf_nAlphaArray, Clfabetaf_index);
296 Clfabetaf_nbeta[Clfabetaf_index] = datafile_ny;
297 if (Clfabetaf_first==true)
299 if (Clfabetaf_nice == 1)
301 Clfabetaf_na_nice = datafile_nxArray[1];
302 Clfabetaf_nb_nice = datafile_ny;
303 d_1_to_1(datafile_yArray, Clfabetaf_bArray_nice);
304 for (i=1; i<=Clfabetaf_na_nice; i++)
305 Clfabetaf_aArray_nice[i] = datafile_xArray[1][i];
307 aeroRollParts -> storeCommands (*command_line);
308 Clfabetaf_first=false;
314 int Clfadaf_index, i;
317 Clfadaf_file = aircraft_directory + linetoken3;
318 token4 >> Clfadaf_index;
319 if (Clfadaf_index < 0 || Clfadaf_index >= 100)
320 uiuc_warnings_errors(1, *command_line);
321 if (Clfadaf_index > Clfadaf_nf)
322 Clfadaf_nf = Clfadaf_index;
323 token5 >> flap_value;
324 token6 >> token_value_convert1;
325 token7 >> token_value_convert2;
326 token8 >> token_value_convert3;
327 token9 >> token_value_convert4;
328 token10 >> Clfadaf_nice;
329 convert_z = uiuc_convert(token_value_convert1);
330 convert_x = uiuc_convert(token_value_convert2);
331 convert_y = uiuc_convert(token_value_convert3);
332 convert_f = uiuc_convert(token_value_convert4);
333 Clfadaf_fArray[Clfadaf_index] = flap_value * convert_f;
334 /* call 2D File Reader with file name (Clfadaf_file) and
335 conversion factors; function returns array of
336 elevator deflections (deArray) and corresponding
337 alpha (aArray) and delta CZ (CZArray) values and
338 max number of terms in alpha arrays (nAlphaArray)
339 and delfection array (nde) */
340 uiuc_2DdataFileReader(Clfadaf_file,
346 d_2_to_3(datafile_xArray, Clfadaf_aArray, Clfadaf_index);
347 d_1_to_2(datafile_yArray, Clfadaf_daArray, Clfadaf_index);
348 d_2_to_3(datafile_zArray, Clfadaf_ClArray, Clfadaf_index);
349 i_1_to_2(datafile_nxArray, Clfadaf_nAlphaArray, Clfadaf_index);
350 Clfadaf_nda[Clfadaf_index] = datafile_ny;
351 if (Clfadaf_first==true)
353 if (Clfadaf_nice == 1)
355 Clfadaf_na_nice = datafile_nxArray[1];
356 Clfadaf_nda_nice = datafile_ny;
357 d_1_to_1(datafile_yArray, Clfadaf_daArray_nice);
358 for (i=1; i<=Clfadaf_na_nice; i++)
359 Clfadaf_aArray_nice[i] = datafile_xArray[1][i];
361 aeroRollParts -> storeCommands (*command_line);
368 int Clfadrf_index, i;
371 Clfadrf_file = aircraft_directory + linetoken3;
372 token4 >> Clfadrf_index;
373 if (Clfadrf_index < 0 || Clfadrf_index >= 100)
374 uiuc_warnings_errors(1, *command_line);
375 if (Clfadrf_index > Clfadrf_nf)
376 Clfadrf_nf = Clfadrf_index;
377 token5 >> flap_value;
378 token6 >> token_value_convert1;
379 token7 >> token_value_convert2;
380 token8 >> token_value_convert3;
381 token9 >> token_value_convert4;
382 token10 >> Clfadrf_nice;
383 convert_z = uiuc_convert(token_value_convert1);
384 convert_x = uiuc_convert(token_value_convert2);
385 convert_y = uiuc_convert(token_value_convert3);
386 convert_f = uiuc_convert(token_value_convert4);
387 Clfadrf_fArray[Clfadrf_index] = flap_value * convert_f;
388 /* call 2D File Reader with file name (Clfadrf_file) and
389 conversion factors; function returns array of
390 elevator deflections (deArray) and corresponding
391 alpha (aArray) and delta CZ (CZArray) values and
392 max number of terms in alpha arrays (nAlphaArray)
393 and delfection array (nde) */
394 uiuc_2DdataFileReader(Clfadrf_file,
400 d_2_to_3(datafile_xArray, Clfadrf_aArray, Clfadrf_index);
401 d_1_to_2(datafile_yArray, Clfadrf_drArray, Clfadrf_index);
402 d_2_to_3(datafile_zArray, Clfadrf_ClArray, Clfadrf_index);
403 i_1_to_2(datafile_nxArray, Clfadrf_nAlphaArray, Clfadrf_index);
404 Clfadrf_ndr[Clfadrf_index] = datafile_ny;
405 if (Clfadrf_first==true)
407 if (Clfadrf_nice == 1)
409 Clfadrf_na_nice = datafile_nxArray[1];
410 Clfadrf_ndr_nice = datafile_ny;
411 d_1_to_1(datafile_yArray, Clfadrf_drArray_nice);
412 for (i=1; i<=Clfadrf_na_nice; i++)
413 Clfadrf_aArray_nice[i] = datafile_xArray[1][i];
415 aeroRollParts -> storeCommands (*command_line);
425 Clfapf_file = aircraft_directory + linetoken3;
426 token4 >> Clfapf_index;
427 if (Clfapf_index < 0 || Clfapf_index >= 100)
428 uiuc_warnings_errors(1, *command_line);
429 if (Clfapf_index > Clfapf_nf)
430 Clfapf_nf = Clfapf_index;
431 token5 >> flap_value;
432 token6 >> token_value_convert1;
433 token7 >> token_value_convert2;
434 token8 >> token_value_convert3;
435 token9 >> token_value_convert4;
436 token10 >> Clfapf_nice;
437 convert_z = uiuc_convert(token_value_convert1);
438 convert_x = uiuc_convert(token_value_convert2);
439 convert_y = uiuc_convert(token_value_convert3);
440 convert_f = uiuc_convert(token_value_convert4);
441 Clfapf_fArray[Clfapf_index] = flap_value * convert_f;
442 /* call 2D File Reader with file name (Clfapf_file) and
443 conversion factors; function returns array of
444 elevator deflections (deArray) and corresponding
445 alpha (aArray) and delta CZ (CZArray) values and
446 max number of terms in alpha arrays (nAlphaArray)
447 and delfection array (nde) */
448 uiuc_2DdataFileReader(Clfapf_file,
454 d_2_to_3(datafile_xArray, Clfapf_aArray, Clfapf_index);
455 d_1_to_2(datafile_yArray, Clfapf_pArray, Clfapf_index);
456 d_2_to_3(datafile_zArray, Clfapf_ClArray, Clfapf_index);
457 i_1_to_2(datafile_nxArray, Clfapf_nAlphaArray, Clfapf_index);
458 Clfapf_np[Clfapf_index] = datafile_ny;
459 if (Clfapf_first==true)
461 if (Clfapf_nice == 1)
463 Clfapf_na_nice = datafile_nxArray[1];
464 Clfapf_np_nice = datafile_ny;
465 d_1_to_1(datafile_yArray, Clfapf_pArray_nice);
466 for (i=1; i<=Clfapf_na_nice; i++)
467 Clfapf_aArray_nice[i] = datafile_xArray[1][i];
469 aeroRollParts -> storeCommands (*command_line);
479 Clfarf_file = aircraft_directory + linetoken3;
480 token4 >> Clfarf_index;
481 if (Clfarf_index < 0 || Clfarf_index >= 100)
482 uiuc_warnings_errors(1, *command_line);
483 if (Clfarf_index > Clfarf_nf)
484 Clfarf_nf = Clfarf_index;
485 token5 >> flap_value;
486 token6 >> token_value_convert1;
487 token7 >> token_value_convert2;
488 token8 >> token_value_convert3;
489 token9 >> token_value_convert4;
490 token10 >> Clfarf_nice;
491 convert_z = uiuc_convert(token_value_convert1);
492 convert_x = uiuc_convert(token_value_convert2);
493 convert_y = uiuc_convert(token_value_convert3);
494 convert_f = uiuc_convert(token_value_convert4);
495 Clfarf_fArray[Clfarf_index] = flap_value * convert_f;
496 /* call 2D File Reader with file name (Clfarf_file) and
497 conversion factors; function returns array of
498 elevator deflections (deArray) and corresponding
499 alpha (aArray) and delta CZ (CZArray) values and
500 max number of terms in alpha arrays (nAlphaArray)
501 and delfection array (nde) */
502 uiuc_2DdataFileReader(Clfarf_file,
508 d_2_to_3(datafile_xArray, Clfarf_aArray, Clfarf_index);
509 d_1_to_2(datafile_yArray, Clfarf_rArray, Clfarf_index);
510 d_2_to_3(datafile_zArray, Clfarf_ClArray, Clfarf_index);
511 i_1_to_2(datafile_nxArray, Clfarf_nAlphaArray, Clfarf_index);
512 Clfarf_nr[Clfarf_index] = datafile_ny;
513 if (Clfarf_first==true)
515 if (Clfarf_nice == 1)
517 Clfarf_na_nice = datafile_nxArray[1];
518 Clfarf_nr_nice = datafile_ny;
519 d_1_to_1(datafile_yArray, Clfarf_rArray_nice);
520 for (i=1; i<=Clfarf_na_nice; i++)
521 Clfarf_aArray_nice[i] = datafile_xArray[1][i];
523 aeroRollParts -> storeCommands (*command_line);
530 if (ignore_unknown_keywords) {
533 // print error message
534 uiuc_warnings_errors(2, *command_line);