1 /**********************************************************************
3 FILENAME: uiuc_menu_Cn.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_Cn.h"
93 void parse_Cn( 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 Cnfabetaf_first = true;
116 static bool Cnfadaf_first = true;
117 static bool Cnfadrf_first = true;
118 static bool Cnfapf_first = true;
119 static bool Cnfarf_first = true;
121 switch(Cn_map[linetoken2])
125 if (check_float(linetoken3))
126 token3 >> token_value;
128 uiuc_warnings_errors(1, *command_line);
132 aeroYawParts -> storeCommands (*command_line);
137 if (check_float(linetoken3))
138 token3 >> token_value;
140 uiuc_warnings_errors(1, *command_line);
142 Cn_beta = token_value;
143 Cn_beta_clean = Cn_beta;
144 aeroYawParts -> storeCommands (*command_line);
149 if (check_float(linetoken3))
150 token3 >> token_value;
152 uiuc_warnings_errors(1, *command_line);
156 aeroYawParts -> storeCommands (*command_line);
161 if (check_float(linetoken3))
162 token3 >> token_value;
164 uiuc_warnings_errors(1, *command_line);
168 aeroYawParts -> storeCommands (*command_line);
173 if (check_float(linetoken3))
174 token3 >> token_value;
176 uiuc_warnings_errors(1, *command_line);
180 aeroYawParts -> storeCommands (*command_line);
185 if (check_float(linetoken3))
186 token3 >> token_value;
188 uiuc_warnings_errors(1, *command_line);
192 aeroYawParts -> storeCommands (*command_line);
197 if (check_float(linetoken3))
198 token3 >> token_value;
200 uiuc_warnings_errors(1, *command_line);
204 aeroYawParts -> storeCommands (*command_line);
209 if (check_float(linetoken3))
210 token3 >> token_value;
212 uiuc_warnings_errors(1, *command_line);
216 aeroYawParts -> storeCommands (*command_line);
221 Cnfada = aircraft_directory + linetoken3;
222 token4 >> token_value_convert1;
223 token5 >> token_value_convert2;
224 token6 >> token_value_convert3;
225 convert_z = uiuc_convert(token_value_convert1);
226 convert_x = uiuc_convert(token_value_convert2);
227 convert_y = uiuc_convert(token_value_convert3);
228 /* call 2D File Reader with file name (Cnfada) and
229 conversion factors; function returns array of
230 aileron deflections (daArray) and corresponding
231 alpha (aArray) and delta Cn (CnArray) values and
232 max number of terms in alpha arrays (nAlphaArray)
233 and deflection array (nda) */
234 uiuc_2DdataFileReader(Cnfada,
240 aeroYawParts -> storeCommands (*command_line);
245 Cnfbetadr = aircraft_directory + linetoken3;
246 token4 >> token_value_convert1;
247 token5 >> token_value_convert2;
248 token6 >> token_value_convert3;
249 convert_z = uiuc_convert(token_value_convert1);
250 convert_x = uiuc_convert(token_value_convert2);
251 convert_y = uiuc_convert(token_value_convert3);
252 /* call 2D File Reader with file name (Cnfbetadr) and
253 conversion factors; function returns array of
254 rudder deflections (drArray) and corresponding
255 beta (betaArray) and delta Cn (CnArray) values and
256 max number of terms in beta arrays (nBetaArray)
257 and deflection array (ndr) */
258 uiuc_2DdataFileReader(Cnfbetadr,
262 Cnfbetadr_nBetaArray,
264 aeroYawParts -> storeCommands (*command_line);
269 int Cnfabetaf_index, i;
270 string Cnfabetaf_file;
272 Cnfabetaf_file = aircraft_directory + linetoken3;
273 token4 >> Cnfabetaf_index;
274 if (Cnfabetaf_index < 0 || Cnfabetaf_index >= 100)
275 uiuc_warnings_errors(1, *command_line);
276 if (Cnfabetaf_index > Cnfabetaf_nf)
277 Cnfabetaf_nf = Cnfabetaf_index;
278 token5 >> flap_value;
279 token6 >> token_value_convert1;
280 token7 >> token_value_convert2;
281 token8 >> token_value_convert3;
282 token9 >> token_value_convert4;
283 token10 >> Cnfabetaf_nice;
284 convert_z = uiuc_convert(token_value_convert1);
285 convert_x = uiuc_convert(token_value_convert2);
286 convert_y = uiuc_convert(token_value_convert3);
287 convert_f = uiuc_convert(token_value_convert4);
288 Cnfabetaf_fArray[Cnfabetaf_index] = flap_value * convert_f;
289 /* call 2D File Reader with file name (Cnfabetaf_file) and
290 conversion factors; function returns array of
291 elevator deflections (deArray) and corresponding
292 alpha (aArray) and delta CZ (CZArray) values and
293 max number of terms in alpha arrays (nAlphaArray)
294 and delfection array (nde) */
295 uiuc_2DdataFileReader(Cnfabetaf_file,
301 d_2_to_3(datafile_xArray, Cnfabetaf_aArray, Cnfabetaf_index);
302 d_1_to_2(datafile_yArray, Cnfabetaf_betaArray, Cnfabetaf_index);
303 d_2_to_3(datafile_zArray, Cnfabetaf_CnArray, Cnfabetaf_index);
304 i_1_to_2(datafile_nxArray, Cnfabetaf_nAlphaArray, Cnfabetaf_index);
305 Cnfabetaf_nbeta[Cnfabetaf_index] = datafile_ny;
306 if (Cnfabetaf_first==true)
308 if (Cnfabetaf_nice == 1)
310 Cnfabetaf_na_nice = datafile_nxArray[1];
311 Cnfabetaf_nb_nice = datafile_ny;
312 d_1_to_1(datafile_yArray, Cnfabetaf_bArray_nice);
313 for (i=1; i<=Cnfabetaf_na_nice; i++)
314 Cnfabetaf_aArray_nice[i] = datafile_xArray[1][i];
316 aeroYawParts -> storeCommands (*command_line);
317 Cnfabetaf_first=false;
323 int Cnfadaf_index, i;
326 Cnfadaf_file = aircraft_directory + linetoken3;
327 token4 >> Cnfadaf_index;
328 if (Cnfadaf_index < 0 || Cnfadaf_index >= 100)
329 uiuc_warnings_errors(1, *command_line);
330 if (Cnfadaf_index > Cnfadaf_nf)
331 Cnfadaf_nf = Cnfadaf_index;
332 token5 >> flap_value;
333 token6 >> token_value_convert1;
334 token7 >> token_value_convert2;
335 token8 >> token_value_convert3;
336 token9 >> token_value_convert4;
337 token10 >> Cnfadaf_nice;
338 convert_z = uiuc_convert(token_value_convert1);
339 convert_x = uiuc_convert(token_value_convert2);
340 convert_y = uiuc_convert(token_value_convert3);
341 convert_f = uiuc_convert(token_value_convert4);
342 Cnfadaf_fArray[Cnfadaf_index] = flap_value * convert_f;
343 /* call 2D File Reader with file name (Cnfadaf_file) and
344 conversion factors; function returns array of
345 elevator deflections (deArray) and corresponding
346 alpha (aArray) and delta CZ (CZArray) values and
347 max number of terms in alpha arrays (nAlphaArray)
348 and delfection array (nde) */
349 uiuc_2DdataFileReader(Cnfadaf_file,
355 d_2_to_3(datafile_xArray, Cnfadaf_aArray, Cnfadaf_index);
356 d_1_to_2(datafile_yArray, Cnfadaf_daArray, Cnfadaf_index);
357 d_2_to_3(datafile_zArray, Cnfadaf_CnArray, Cnfadaf_index);
358 i_1_to_2(datafile_nxArray, Cnfadaf_nAlphaArray, Cnfadaf_index);
359 Cnfadaf_nda[Cnfadaf_index] = datafile_ny;
360 if (Cnfadaf_first==true)
362 if (Cnfadaf_nice == 1)
364 Cnfadaf_na_nice = datafile_nxArray[1];
365 Cnfadaf_nda_nice = datafile_ny;
366 d_1_to_1(datafile_yArray, Cnfadaf_daArray_nice);
367 for (i=1; i<=Cnfadaf_na_nice; i++)
368 Cnfadaf_aArray_nice[i] = datafile_xArray[1][i];
370 aeroYawParts -> storeCommands (*command_line);
377 int Cnfadrf_index, i;
380 Cnfadrf_file = aircraft_directory + linetoken3;
381 token4 >> Cnfadrf_index;
382 if (Cnfadrf_index < 0 || Cnfadrf_index >= 100)
383 uiuc_warnings_errors(1, *command_line);
384 if (Cnfadrf_index > Cnfadrf_nf)
385 Cnfadrf_nf = Cnfadrf_index;
386 token5 >> flap_value;
387 token6 >> token_value_convert1;
388 token7 >> token_value_convert2;
389 token8 >> token_value_convert3;
390 token9 >> token_value_convert4;
391 token10 >> Cnfadrf_nice;
392 convert_z = uiuc_convert(token_value_convert1);
393 convert_x = uiuc_convert(token_value_convert2);
394 convert_y = uiuc_convert(token_value_convert3);
395 convert_f = uiuc_convert(token_value_convert4);
396 Cnfadrf_fArray[Cnfadrf_index] = flap_value * convert_f;
397 /* call 2D File Reader with file name (Cnfadrf_file) and
398 conversion factors; function returns array of
399 elevator deflections (deArray) and corresponding
400 alpha (aArray) and delta CZ (CZArray) values and
401 max number of terms in alpha arrays (nAlphaArray)
402 and delfection array (nde) */
403 uiuc_2DdataFileReader(Cnfadrf_file,
409 d_2_to_3(datafile_xArray, Cnfadrf_aArray, Cnfadrf_index);
410 d_1_to_2(datafile_yArray, Cnfadrf_drArray, Cnfadrf_index);
411 d_2_to_3(datafile_zArray, Cnfadrf_CnArray, Cnfadrf_index);
412 i_1_to_2(datafile_nxArray, Cnfadrf_nAlphaArray, Cnfadrf_index);
413 Cnfadrf_ndr[Cnfadrf_index] = datafile_ny;
414 if (Cnfadrf_first==true)
416 if (Cnfadrf_nice == 1)
418 Cnfadrf_na_nice = datafile_nxArray[1];
419 Cnfadrf_ndr_nice = datafile_ny;
420 d_1_to_1(datafile_yArray, Cnfadrf_drArray_nice);
421 for (i=1; i<=Cnfadrf_na_nice; i++)
422 Cnfadrf_aArray_nice[i] = datafile_xArray[1][i];
424 aeroYawParts -> storeCommands (*command_line);
434 Cnfapf_file = aircraft_directory + linetoken3;
435 token4 >> Cnfapf_index;
436 if (Cnfapf_index < 0 || Cnfapf_index >= 100)
437 uiuc_warnings_errors(1, *command_line);
438 if (Cnfapf_index > Cnfapf_nf)
439 Cnfapf_nf = Cnfapf_index;
440 token5 >> flap_value;
441 token6 >> token_value_convert1;
442 token7 >> token_value_convert2;
443 token8 >> token_value_convert3;
444 token9 >> token_value_convert4;
445 token10 >> Cnfapf_nice;
446 convert_z = uiuc_convert(token_value_convert1);
447 convert_x = uiuc_convert(token_value_convert2);
448 convert_y = uiuc_convert(token_value_convert3);
449 convert_f = uiuc_convert(token_value_convert4);
450 Cnfapf_fArray[Cnfapf_index] = flap_value * convert_f;
451 /* call 2D File Reader with file name (Cnfapf_file) and
452 conversion factors; function returns array of
453 elevator deflections (deArray) and corresponding
454 alpha (aArray) and delta CZ (CZArray) values and
455 max number of terms in alpha arrays (nAlphaArray)
456 and delfection array (nde) */
457 uiuc_2DdataFileReader(Cnfapf_file,
463 d_2_to_3(datafile_xArray, Cnfapf_aArray, Cnfapf_index);
464 d_1_to_2(datafile_yArray, Cnfapf_pArray, Cnfapf_index);
465 d_2_to_3(datafile_zArray, Cnfapf_CnArray, Cnfapf_index);
466 i_1_to_2(datafile_nxArray, Cnfapf_nAlphaArray, Cnfapf_index);
467 Cnfapf_np[Cnfapf_index] = datafile_ny;
468 if (Cnfapf_first==true)
470 if (Cnfapf_nice == 1)
472 Cnfapf_na_nice = datafile_nxArray[1];
473 Cnfapf_np_nice = datafile_ny;
474 d_1_to_1(datafile_yArray, Cnfapf_pArray_nice);
475 for (i=1; i<=Cnfapf_na_nice; i++)
476 Cnfapf_aArray_nice[i] = datafile_xArray[1][i];
478 aeroYawParts -> storeCommands (*command_line);
488 Cnfarf_file = aircraft_directory + linetoken3;
489 token4 >> Cnfarf_index;
490 if (Cnfarf_index < 0 || Cnfarf_index >= 100)
491 uiuc_warnings_errors(1, *command_line);
492 if (Cnfarf_index > Cnfarf_nf)
493 Cnfarf_nf = Cnfarf_index;
494 token5 >> flap_value;
495 token6 >> token_value_convert1;
496 token7 >> token_value_convert2;
497 token8 >> token_value_convert3;
498 token9 >> token_value_convert4;
499 token10 >> Cnfarf_nice;
500 convert_z = uiuc_convert(token_value_convert1);
501 convert_x = uiuc_convert(token_value_convert2);
502 convert_y = uiuc_convert(token_value_convert3);
503 convert_f = uiuc_convert(token_value_convert4);
504 Cnfarf_fArray[Cnfarf_index] = flap_value * convert_f;
505 /* call 2D File Reader with file name (Cnfarf_file) and
506 conversion factors; function returns array of
507 elevator deflections (deArray) and corresponding
508 alpha (aArray) and delta CZ (CZArray) values and
509 max number of terms in alpha arrays (nAlphaArray)
510 and delfection array (nde) */
511 uiuc_2DdataFileReader(Cnfarf_file,
517 d_2_to_3(datafile_xArray, Cnfarf_aArray, Cnfarf_index);
518 d_1_to_2(datafile_yArray, Cnfarf_rArray, Cnfarf_index);
519 d_2_to_3(datafile_zArray, Cnfarf_CnArray, Cnfarf_index);
520 i_1_to_2(datafile_nxArray, Cnfarf_nAlphaArray, Cnfarf_index);
521 Cnfarf_nr[Cnfarf_index] = datafile_ny;
522 if (Cnfarf_first==true)
524 if (Cnfarf_nice == 1)
526 Cnfarf_na_nice = datafile_nxArray[1];
527 Cnfarf_nr_nice = datafile_ny;
528 d_1_to_1(datafile_yArray, Cnfarf_rArray_nice);
529 for (i=1; i<=Cnfarf_na_nice; i++)
530 Cnfarf_aArray_nice[i] = datafile_xArray[1][i];
532 aeroYawParts -> storeCommands (*command_line);
539 if (ignore_unknown_keywords) {
542 // print error message
543 uiuc_warnings_errors(2, *command_line);