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
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_Cn.h"
90 void parse_Cn( 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 Cnfabetaf_first = true;
113 static bool Cnfadaf_first = true;
114 static bool Cnfadrf_first = true;
115 static bool Cnfapf_first = true;
116 static bool Cnfarf_first = true;
118 switch(Cn_map[linetoken2])
122 if (check_float(linetoken3))
123 token3 >> token_value;
125 uiuc_warnings_errors(1, *command_line);
129 aeroYawParts -> storeCommands (*command_line);
134 if (check_float(linetoken3))
135 token3 >> token_value;
137 uiuc_warnings_errors(1, *command_line);
139 Cn_beta = token_value;
140 Cn_beta_clean = Cn_beta;
141 aeroYawParts -> storeCommands (*command_line);
146 if (check_float(linetoken3))
147 token3 >> token_value;
149 uiuc_warnings_errors(1, *command_line);
153 aeroYawParts -> storeCommands (*command_line);
158 if (check_float(linetoken3))
159 token3 >> token_value;
161 uiuc_warnings_errors(1, *command_line);
165 aeroYawParts -> storeCommands (*command_line);
170 if (check_float(linetoken3))
171 token3 >> token_value;
173 uiuc_warnings_errors(1, *command_line);
177 aeroYawParts -> storeCommands (*command_line);
182 if (check_float(linetoken3))
183 token3 >> token_value;
185 uiuc_warnings_errors(1, *command_line);
189 aeroYawParts -> storeCommands (*command_line);
194 if (check_float(linetoken3))
195 token3 >> token_value;
197 uiuc_warnings_errors(1, *command_line);
201 aeroYawParts -> storeCommands (*command_line);
206 if (check_float(linetoken3))
207 token3 >> token_value;
209 uiuc_warnings_errors(1, *command_line);
213 aeroYawParts -> storeCommands (*command_line);
218 Cnfada = aircraft_directory + linetoken3;
219 token4 >> token_value_convert1;
220 token5 >> token_value_convert2;
221 token6 >> token_value_convert3;
222 convert_z = uiuc_convert(token_value_convert1);
223 convert_x = uiuc_convert(token_value_convert2);
224 convert_y = uiuc_convert(token_value_convert3);
225 /* call 2D File Reader with file name (Cnfada) and
226 conversion factors; function returns array of
227 aileron deflections (daArray) and corresponding
228 alpha (aArray) and delta Cn (CnArray) values and
229 max number of terms in alpha arrays (nAlphaArray)
230 and deflection array (nda) */
231 uiuc_2DdataFileReader(Cnfada,
237 aeroYawParts -> storeCommands (*command_line);
242 Cnfbetadr = aircraft_directory + linetoken3;
243 token4 >> token_value_convert1;
244 token5 >> token_value_convert2;
245 token6 >> token_value_convert3;
246 convert_z = uiuc_convert(token_value_convert1);
247 convert_x = uiuc_convert(token_value_convert2);
248 convert_y = uiuc_convert(token_value_convert3);
249 /* call 2D File Reader with file name (Cnfbetadr) and
250 conversion factors; function returns array of
251 rudder deflections (drArray) and corresponding
252 beta (betaArray) and delta Cn (CnArray) values and
253 max number of terms in beta arrays (nBetaArray)
254 and deflection array (ndr) */
255 uiuc_2DdataFileReader(Cnfbetadr,
259 Cnfbetadr_nBetaArray,
261 aeroYawParts -> storeCommands (*command_line);
266 int Cnfabetaf_index, i;
267 string Cnfabetaf_file;
269 Cnfabetaf_file = aircraft_directory + linetoken3;
270 token4 >> Cnfabetaf_index;
271 if (Cnfabetaf_index < 0 || Cnfabetaf_index >= 100)
272 uiuc_warnings_errors(1, *command_line);
273 if (Cnfabetaf_index > Cnfabetaf_nf)
274 Cnfabetaf_nf = Cnfabetaf_index;
275 token5 >> flap_value;
276 token6 >> token_value_convert1;
277 token7 >> token_value_convert2;
278 token8 >> token_value_convert3;
279 token9 >> token_value_convert4;
280 token10 >> Cnfabetaf_nice;
281 convert_z = uiuc_convert(token_value_convert1);
282 convert_x = uiuc_convert(token_value_convert2);
283 convert_y = uiuc_convert(token_value_convert3);
284 convert_f = uiuc_convert(token_value_convert4);
285 Cnfabetaf_fArray[Cnfabetaf_index] = flap_value * convert_f;
286 /* call 2D File Reader with file name (Cnfabetaf_file) and
287 conversion factors; function returns array of
288 elevator deflections (deArray) and corresponding
289 alpha (aArray) and delta CZ (CZArray) values and
290 max number of terms in alpha arrays (nAlphaArray)
291 and delfection array (nde) */
292 uiuc_2DdataFileReader(Cnfabetaf_file,
298 d_2_to_3(datafile_xArray, Cnfabetaf_aArray, Cnfabetaf_index);
299 d_1_to_2(datafile_yArray, Cnfabetaf_betaArray, Cnfabetaf_index);
300 d_2_to_3(datafile_zArray, Cnfabetaf_CnArray, Cnfabetaf_index);
301 i_1_to_2(datafile_nxArray, Cnfabetaf_nAlphaArray, Cnfabetaf_index);
302 Cnfabetaf_nbeta[Cnfabetaf_index] = datafile_ny;
303 if (Cnfabetaf_first==true)
305 if (Cnfabetaf_nice == 1)
307 Cnfabetaf_na_nice = datafile_nxArray[1];
308 Cnfabetaf_nb_nice = datafile_ny;
309 d_1_to_1(datafile_yArray, Cnfabetaf_bArray_nice);
310 for (i=1; i<=Cnfabetaf_na_nice; i++)
311 Cnfabetaf_aArray_nice[i] = datafile_xArray[1][i];
313 aeroYawParts -> storeCommands (*command_line);
314 Cnfabetaf_first=false;
320 int Cnfadaf_index, i;
323 Cnfadaf_file = aircraft_directory + linetoken3;
324 token4 >> Cnfadaf_index;
325 if (Cnfadaf_index < 0 || Cnfadaf_index >= 100)
326 uiuc_warnings_errors(1, *command_line);
327 if (Cnfadaf_index > Cnfadaf_nf)
328 Cnfadaf_nf = Cnfadaf_index;
329 token5 >> flap_value;
330 token6 >> token_value_convert1;
331 token7 >> token_value_convert2;
332 token8 >> token_value_convert3;
333 token9 >> token_value_convert4;
334 token10 >> Cnfadaf_nice;
335 convert_z = uiuc_convert(token_value_convert1);
336 convert_x = uiuc_convert(token_value_convert2);
337 convert_y = uiuc_convert(token_value_convert3);
338 convert_f = uiuc_convert(token_value_convert4);
339 Cnfadaf_fArray[Cnfadaf_index] = flap_value * convert_f;
340 /* call 2D File Reader with file name (Cnfadaf_file) and
341 conversion factors; function returns array of
342 elevator deflections (deArray) and corresponding
343 alpha (aArray) and delta CZ (CZArray) values and
344 max number of terms in alpha arrays (nAlphaArray)
345 and delfection array (nde) */
346 uiuc_2DdataFileReader(Cnfadaf_file,
352 d_2_to_3(datafile_xArray, Cnfadaf_aArray, Cnfadaf_index);
353 d_1_to_2(datafile_yArray, Cnfadaf_daArray, Cnfadaf_index);
354 d_2_to_3(datafile_zArray, Cnfadaf_CnArray, Cnfadaf_index);
355 i_1_to_2(datafile_nxArray, Cnfadaf_nAlphaArray, Cnfadaf_index);
356 Cnfadaf_nda[Cnfadaf_index] = datafile_ny;
357 if (Cnfadaf_first==true)
359 if (Cnfadaf_nice == 1)
361 Cnfadaf_na_nice = datafile_nxArray[1];
362 Cnfadaf_nda_nice = datafile_ny;
363 d_1_to_1(datafile_yArray, Cnfadaf_daArray_nice);
364 for (i=1; i<=Cnfadaf_na_nice; i++)
365 Cnfadaf_aArray_nice[i] = datafile_xArray[1][i];
367 aeroYawParts -> storeCommands (*command_line);
374 int Cnfadrf_index, i;
377 Cnfadrf_file = aircraft_directory + linetoken3;
378 token4 >> Cnfadrf_index;
379 if (Cnfadrf_index < 0 || Cnfadrf_index >= 100)
380 uiuc_warnings_errors(1, *command_line);
381 if (Cnfadrf_index > Cnfadrf_nf)
382 Cnfadrf_nf = Cnfadrf_index;
383 token5 >> flap_value;
384 token6 >> token_value_convert1;
385 token7 >> token_value_convert2;
386 token8 >> token_value_convert3;
387 token9 >> token_value_convert4;
388 token10 >> Cnfadrf_nice;
389 convert_z = uiuc_convert(token_value_convert1);
390 convert_x = uiuc_convert(token_value_convert2);
391 convert_y = uiuc_convert(token_value_convert3);
392 convert_f = uiuc_convert(token_value_convert4);
393 Cnfadrf_fArray[Cnfadrf_index] = flap_value * convert_f;
394 /* call 2D File Reader with file name (Cnfadrf_file) and
395 conversion factors; function returns array of
396 elevator deflections (deArray) and corresponding
397 alpha (aArray) and delta CZ (CZArray) values and
398 max number of terms in alpha arrays (nAlphaArray)
399 and delfection array (nde) */
400 uiuc_2DdataFileReader(Cnfadrf_file,
406 d_2_to_3(datafile_xArray, Cnfadrf_aArray, Cnfadrf_index);
407 d_1_to_2(datafile_yArray, Cnfadrf_drArray, Cnfadrf_index);
408 d_2_to_3(datafile_zArray, Cnfadrf_CnArray, Cnfadrf_index);
409 i_1_to_2(datafile_nxArray, Cnfadrf_nAlphaArray, Cnfadrf_index);
410 Cnfadrf_ndr[Cnfadrf_index] = datafile_ny;
411 if (Cnfadrf_first==true)
413 if (Cnfadrf_nice == 1)
415 Cnfadrf_na_nice = datafile_nxArray[1];
416 Cnfadrf_ndr_nice = datafile_ny;
417 d_1_to_1(datafile_yArray, Cnfadrf_drArray_nice);
418 for (i=1; i<=Cnfadrf_na_nice; i++)
419 Cnfadrf_aArray_nice[i] = datafile_xArray[1][i];
421 aeroYawParts -> storeCommands (*command_line);
431 Cnfapf_file = aircraft_directory + linetoken3;
432 token4 >> Cnfapf_index;
433 if (Cnfapf_index < 0 || Cnfapf_index >= 100)
434 uiuc_warnings_errors(1, *command_line);
435 if (Cnfapf_index > Cnfapf_nf)
436 Cnfapf_nf = Cnfapf_index;
437 token5 >> flap_value;
438 token6 >> token_value_convert1;
439 token7 >> token_value_convert2;
440 token8 >> token_value_convert3;
441 token9 >> token_value_convert4;
442 token10 >> Cnfapf_nice;
443 convert_z = uiuc_convert(token_value_convert1);
444 convert_x = uiuc_convert(token_value_convert2);
445 convert_y = uiuc_convert(token_value_convert3);
446 convert_f = uiuc_convert(token_value_convert4);
447 Cnfapf_fArray[Cnfapf_index] = flap_value * convert_f;
448 /* call 2D File Reader with file name (Cnfapf_file) and
449 conversion factors; function returns array of
450 elevator deflections (deArray) and corresponding
451 alpha (aArray) and delta CZ (CZArray) values and
452 max number of terms in alpha arrays (nAlphaArray)
453 and delfection array (nde) */
454 uiuc_2DdataFileReader(Cnfapf_file,
460 d_2_to_3(datafile_xArray, Cnfapf_aArray, Cnfapf_index);
461 d_1_to_2(datafile_yArray, Cnfapf_pArray, Cnfapf_index);
462 d_2_to_3(datafile_zArray, Cnfapf_CnArray, Cnfapf_index);
463 i_1_to_2(datafile_nxArray, Cnfapf_nAlphaArray, Cnfapf_index);
464 Cnfapf_np[Cnfapf_index] = datafile_ny;
465 if (Cnfapf_first==true)
467 if (Cnfapf_nice == 1)
469 Cnfapf_na_nice = datafile_nxArray[1];
470 Cnfapf_np_nice = datafile_ny;
471 d_1_to_1(datafile_yArray, Cnfapf_pArray_nice);
472 for (i=1; i<=Cnfapf_na_nice; i++)
473 Cnfapf_aArray_nice[i] = datafile_xArray[1][i];
475 aeroYawParts -> storeCommands (*command_line);
485 Cnfarf_file = aircraft_directory + linetoken3;
486 token4 >> Cnfarf_index;
487 if (Cnfarf_index < 0 || Cnfarf_index >= 100)
488 uiuc_warnings_errors(1, *command_line);
489 if (Cnfarf_index > Cnfarf_nf)
490 Cnfarf_nf = Cnfarf_index;
491 token5 >> flap_value;
492 token6 >> token_value_convert1;
493 token7 >> token_value_convert2;
494 token8 >> token_value_convert3;
495 token9 >> token_value_convert4;
496 token10 >> Cnfarf_nice;
497 convert_z = uiuc_convert(token_value_convert1);
498 convert_x = uiuc_convert(token_value_convert2);
499 convert_y = uiuc_convert(token_value_convert3);
500 convert_f = uiuc_convert(token_value_convert4);
501 Cnfarf_fArray[Cnfarf_index] = flap_value * convert_f;
502 /* call 2D File Reader with file name (Cnfarf_file) and
503 conversion factors; function returns array of
504 elevator deflections (deArray) and corresponding
505 alpha (aArray) and delta CZ (CZArray) values and
506 max number of terms in alpha arrays (nAlphaArray)
507 and delfection array (nde) */
508 uiuc_2DdataFileReader(Cnfarf_file,
514 d_2_to_3(datafile_xArray, Cnfarf_aArray, Cnfarf_index);
515 d_1_to_2(datafile_yArray, Cnfarf_rArray, Cnfarf_index);
516 d_2_to_3(datafile_zArray, Cnfarf_CnArray, Cnfarf_index);
517 i_1_to_2(datafile_nxArray, Cnfarf_nAlphaArray, Cnfarf_index);
518 Cnfarf_nr[Cnfarf_index] = datafile_ny;
519 if (Cnfarf_first==true)
521 if (Cnfarf_nice == 1)
523 Cnfarf_na_nice = datafile_nxArray[1];
524 Cnfarf_nr_nice = datafile_ny;
525 d_1_to_1(datafile_yArray, Cnfarf_rArray_nice);
526 for (i=1; i<=Cnfarf_na_nice; i++)
527 Cnfarf_aArray_nice[i] = datafile_xArray[1][i];
529 aeroYawParts -> storeCommands (*command_line);
536 if (ignore_unknown_keywords) {
539 // print error message
540 uiuc_warnings_errors(2, *command_line);