~ubuntu-branches/ubuntu/quantal/flightgear/quantal

« back to all changes in this revision

Viewing changes to src/FDM/UIUCModel/uiuc_menu.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Ove Kaaven
  • Date: 2002-03-27 21:50:15 UTC
  • Revision ID: james.westby@ubuntu.com-20020327215015-0rvi3o8iml0a8s93
Tags: upstream-0.7.9
ImportĀ upstreamĀ versionĀ 0.7.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/**********************************************************************
 
2
                                                                       
 
3
 FILENAME:     uiuc_menu.cpp
 
4
 
 
5
----------------------------------------------------------------------
 
6
 
 
7
 DESCRIPTION:  reads input file for specified aircraft and creates 
 
8
               approporiate data storage space
 
9
 
 
10
----------------------------------------------------------------------
 
11
 
 
12
 STATUS:       alpha version
 
13
 
 
14
----------------------------------------------------------------------
 
15
 
 
16
 REFERENCES:   based on "menu reader" format of Michael Selig
 
17
 
 
18
----------------------------------------------------------------------
 
19
 
 
20
 HISTORY:      01/29/2000   initial release
 
21
               02/18/2000   (JS) added 1D data file capability for 
 
22
                            CL(a) and CD(a) -- calls 
 
23
                            uiuc_1DdataFileReader
 
24
               02/22/2000   (JS) added ice map functions
 
25
               02/29/2000   (JS) added 2D data file capability for 
 
26
                            CL(a,de), CD(a,de), Cm(a,de), CY(a,da), 
 
27
                            CY(beta,dr), Cl(a,da), Cl(beta,dr), 
 
28
                            Cn(a,da), Cn(beta,dr) -- calls 
 
29
                            uiuc_2DdataFileReader
 
30
               02/02/2000   (JS) added record options for 1D and 
 
31
                            2D interpolated variables
 
32
               03/28/2000   (JS) streamlined conversion factors for 
 
33
                            file readers -- since they are global 
 
34
                            variables, it is not necessary to put 
 
35
                            them in the function calls
 
36
               03/29/2000   (JS) added Cmfa and Weight flags;
 
37
                            added misc map; added Dx_cg (etc) to init 
 
38
                            map
 
39
               04/01/2000   (JS) added throttle, longitudinal, lateral, 
 
40
                            and rudder inputs to record map
 
41
               04/05/2000   (JS) added Altitude to init and record
 
42
                            maps; added zero_Long_trim to 
 
43
                            controlSurface map
 
44
               03/09/2001   (DPM) added support for gear.
 
45
               06/18/2001   (RD) Added Alpha, Beta, U_body,
 
46
                            V_body, and W_body to init map.  Added 
 
47
                            aileron_input, rudder_input, pilot_elev_no,
 
48
                            pilot_ail_no, and pilot_rud_no to
 
49
                            controlSurface map.  Added Throttle_pct_input
 
50
                            to engine map.  Added CZfa to CL map.
 
51
               07/05/2001   (RD) Changed pilot_elev_no = true to pilot_
 
52
                            elev_no_check=false.  This is to allow pilot
 
53
                            to fly aircraft after input files have been
 
54
                            used.
 
55
               08/27/2001   (RD) Added xxx_init_true and xxx_init for
 
56
                            P_body, Q_body, R_body, Phi, Theta, Psi,
 
57
                            U_body, V_body, and W_body to help in
 
58
                            starting the A/C at an initial condition.
 
59
 
 
60
----------------------------------------------------------------------
 
61
 
 
62
 AUTHOR(S):    Bipin Sehgal       <bsehgal@uiuc.edu>
 
63
               Jeff Scott         <jscott@mail.com>
 
64
               Robert Deters      <rdeters@uiuc.edu>
 
65
               Michael Selig      <m-selig@uiuc.edu>
 
66
               David Megginson    <david@megginson.com>
 
67
 
 
68
----------------------------------------------------------------------
 
69
 
 
70
 VARIABLES:
 
71
 
 
72
----------------------------------------------------------------------
 
73
 
 
74
 INPUTS:       n/a
 
75
 
 
76
----------------------------------------------------------------------
 
77
 
 
78
 OUTPUTS:      n/a
 
79
 
 
80
----------------------------------------------------------------------
 
81
 
 
82
 CALLED BY:    uiuc_wrapper.cpp 
 
83
 
 
84
----------------------------------------------------------------------
 
85
 
 
86
 CALLS TO:     aircraft.dat
 
87
               tabulated data files (if needed)
 
88
 
 
89
----------------------------------------------------------------------
 
90
 
 
91
 COPYRIGHT:    (C) 2000 by Michael Selig
 
92
 
 
93
 This program is free software; you can redistribute it and/or
 
94
 modify it under the terms of the GNU General Public License
 
95
 as published by the Free Software Foundation.
 
96
 
 
97
 This program is distributed in the hope that it will be useful,
 
98
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 
99
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
100
 GNU General Public License for more details.
 
101
 
 
102
 You should have received a copy of the GNU General Public License
 
103
 along with this program; if not, write to the Free Software
 
104
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 
105
 USA or view http://www.gnu.org/copyleft/gpl.html.
 
106
 
 
107
**********************************************************************/
 
108
 
 
109
#include <simgear/compiler.h>
 
110
 
 
111
#if defined( __MWERKS__ )
 
112
// -dw- optimizer chokes (big-time) trying to optimize humongous
 
113
// loop/switch statements
 
114
#pragma optimization_level 0
 
115
#endif
 
116
 
 
117
#include <stdlib.h>
 
118
#include STL_IOSTREAM
 
119
 
 
120
#include "uiuc_menu.h"
 
121
 
 
122
#if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
 
123
SG_USING_STD(cerr);
 
124
SG_USING_STD(cout);
 
125
SG_USING_STD(endl);
 
126
 
 
127
#  ifndef _MSC_VER
 
128
SG_USING_STD(exit);
 
129
#  endif
 
130
#endif
 
131
 
 
132
bool check_float(string  &token)
 
133
{
 
134
  float value;
 
135
  istrstream stream(token.c_str()); 
 
136
  return (stream >> value);
 
137
}
 
138
 
 
139
 
 
140
void uiuc_menu( string aircraft_name )
 
141
{
 
142
  stack command_list;
 
143
  double token_value;
 
144
  int token_value_recordRate;
 
145
  int token_value_convert1, token_value_convert2, token_value_convert3;
 
146
 
 
147
  string linetoken1;
 
148
  string linetoken2;
 
149
  string linetoken3;
 
150
  string linetoken4;
 
151
  string linetoken5;
 
152
  string linetoken6;
 
153
 
 
154
 
 
155
  /* the following default setting should eventually be moved to a default or uiuc_init routine */
 
156
 
 
157
  recordRate = 1;       /* record every time step, default */
 
158
  recordStartTime = 0;  /* record from beginning of simulation */
 
159
 
 
160
/* set speed at which dynamic pressure terms will be accounted for,
 
161
   since if velocity is too small, coefficients will go to infinity */
 
162
  dyn_on_speed = 33;    /* 20 kts, default */
 
163
 
 
164
 
 
165
 
 
166
  /* Read the file and get the list of commands */
 
167
  airplane = new ParseFile(aircraft_name); /* struct that includes all lines of the input file */
 
168
  command_list = airplane -> getCommands();
 
169
  /* structs to include all parts included in the input file for specific keyword groups */
 
170
  initParts          = new ParseFile();
 
171
  geometryParts      = new ParseFile();
 
172
  massParts          = new ParseFile();
 
173
  engineParts        = new ParseFile();
 
174
  aeroDragParts      = new ParseFile();
 
175
  aeroLiftParts      = new ParseFile();
 
176
  aeroPitchParts     = new ParseFile();
 
177
  aeroSideforceParts = new ParseFile();
 
178
  aeroRollParts      = new ParseFile();
 
179
  aeroYawParts       = new ParseFile();
 
180
  gearParts          = new ParseFile();
 
181
  recordParts        = new ParseFile();
 
182
 
 
183
  if (command_list.begin() == command_list.end())
 
184
  {
 
185
    cerr << "UIUC ERROR: File " << aircraft_name <<" does not exist" << endl;
 
186
    exit(-1);
 
187
  }
 
188
  
 
189
  for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 
190
    {
 
191
      cout << *command_line << endl;
 
192
 
 
193
      linetoken1 = airplane -> getToken (*command_line, 1); 
 
194
      linetoken2 = airplane -> getToken (*command_line, 2); 
 
195
      linetoken3 = airplane -> getToken (*command_line, 3); 
 
196
      linetoken4 = airplane -> getToken (*command_line, 4); 
 
197
      linetoken5 = airplane -> getToken (*command_line, 5); 
 
198
      linetoken6 = airplane -> getToken (*command_line, 6); 
 
199
      
 
200
      istrstream token3(linetoken3.c_str());
 
201
      istrstream token4(linetoken4.c_str());
 
202
      istrstream token5(linetoken5.c_str());
 
203
      istrstream token6(linetoken6.c_str());
 
204
 
 
205
      switch (Keyword_map[linetoken1])
 
206
        {
 
207
        case init_flag:
 
208
          {
 
209
            switch(init_map[linetoken2])
 
210
              {
 
211
              case Dx_pilot_flag:
 
212
                {
 
213
                  if (check_float(linetoken3))
 
214
                    token3 >> token_value;
 
215
                  else
 
216
                    uiuc_warnings_errors(1, *command_line);
 
217
                  
 
218
                  Dx_pilot = token_value;
 
219
                  initParts -> storeCommands (*command_line);
 
220
                  break;
 
221
                }
 
222
              case Dy_pilot_flag:
 
223
                {
 
224
                  if (check_float(linetoken3))
 
225
                    token3 >> token_value;
 
226
                  else
 
227
                    uiuc_warnings_errors(1, *command_line);
 
228
                  
 
229
                  Dy_pilot = token_value;
 
230
                  initParts -> storeCommands (*command_line);
 
231
                  break;
 
232
                }
 
233
              case Dz_pilot_flag:
 
234
                {
 
235
                  if (check_float(linetoken3))
 
236
                    token3 >> token_value;
 
237
                  else
 
238
                    uiuc_warnings_errors(1, *command_line);
 
239
                  
 
240
                  Dz_pilot = token_value;
 
241
                  initParts -> storeCommands (*command_line);
 
242
                  break;
 
243
                }
 
244
              case Dx_cg_flag:
 
245
                {
 
246
                  if (check_float(linetoken3))
 
247
                    token3 >> token_value;
 
248
                  else
 
249
                    uiuc_warnings_errors(1, *command_line);
 
250
                  
 
251
                  Dx_cg = token_value;
 
252
                  initParts -> storeCommands (*command_line);
 
253
                  break;
 
254
                }
 
255
              case Dy_cg_flag:
 
256
                {
 
257
                  if (check_float(linetoken3))
 
258
                    token3 >> token_value;
 
259
                  else
 
260
                    uiuc_warnings_errors(1, *command_line);
 
261
                  
 
262
                  Dy_cg = token_value;
 
263
                  initParts -> storeCommands (*command_line);
 
264
                  break;
 
265
                }
 
266
              case Dz_cg_flag:
 
267
                {
 
268
                  if (check_float(linetoken3))
 
269
                    token3 >> token_value;
 
270
                  else
 
271
                    uiuc_warnings_errors(1, *command_line);
 
272
                  
 
273
                  Dz_cg = token_value;
 
274
                  initParts -> storeCommands (*command_line);
 
275
                  break;
 
276
                }
 
277
              case Altitude_flag:
 
278
                {
 
279
                  if (check_float(linetoken3))
 
280
                    token3 >> token_value;
 
281
                  else
 
282
                    uiuc_warnings_errors(1, *command_line);
 
283
                  
 
284
                  Altitude = token_value;
 
285
                  initParts -> storeCommands (*command_line);
 
286
                  break;
 
287
                }
 
288
              case V_north_flag:
 
289
                {
 
290
                  if (check_float(linetoken3)) 
 
291
                    token3 >> token_value;
 
292
                  else
 
293
                    uiuc_warnings_errors(1, *command_line);
 
294
                  
 
295
                  V_north = token_value;
 
296
                  initParts -> storeCommands (*command_line);
 
297
                  break;
 
298
                }
 
299
              case V_east_flag:
 
300
                {
 
301
                  initParts -> storeCommands (*command_line);
 
302
                  if (check_float(linetoken3))
 
303
                    token3 >> token_value;
 
304
                  else
 
305
                    uiuc_warnings_errors(1, *command_line);
 
306
                  
 
307
                  V_east = token_value;
 
308
                  break;
 
309
                }
 
310
              case V_down_flag:
 
311
                {
 
312
                  if (check_float(linetoken3))
 
313
                    token3 >> token_value;
 
314
                  else
 
315
                    uiuc_warnings_errors(1, *command_line);
 
316
                  
 
317
                  V_down = token_value;
 
318
                  initParts -> storeCommands (*command_line);
 
319
                  break;
 
320
                }
 
321
              case P_body_flag:
 
322
                {
 
323
                  if (check_float(linetoken3))
 
324
                    token3 >> token_value;
 
325
                  else
 
326
                    uiuc_warnings_errors(1, *command_line);
 
327
 
 
328
                  P_body_init_true = true;
 
329
                  P_body_init = token_value;
 
330
                  initParts -> storeCommands (*command_line);
 
331
                  break;
 
332
                }
 
333
              case Q_body_flag:
 
334
                {
 
335
                  if (check_float(linetoken3))
 
336
                    token3 >> token_value;
 
337
                  else
 
338
                    uiuc_warnings_errors(1, *command_line);
 
339
                  
 
340
                  Q_body_init_true = true;
 
341
                  Q_body_init = token_value;
 
342
                  initParts -> storeCommands (*command_line);
 
343
                  break;
 
344
                }
 
345
              case R_body_flag:
 
346
                {
 
347
                  if (check_float(linetoken3))
 
348
                    token3 >> token_value;
 
349
                  else
 
350
                    uiuc_warnings_errors(1, *command_line);
 
351
                  
 
352
                  R_body_init_true = true;
 
353
                  R_body_init = token_value;
 
354
                  initParts -> storeCommands (*command_line);
 
355
                  break;
 
356
                }
 
357
              case Phi_flag:
 
358
                {
 
359
                  if (check_float(linetoken3))
 
360
                    token3 >> token_value;
 
361
                  else
 
362
                    uiuc_warnings_errors(1, *command_line);
 
363
                  
 
364
                  Phi_init_true = true;
 
365
                  Phi_init = token_value;
 
366
                  initParts -> storeCommands (*command_line);
 
367
                  break;
 
368
                }
 
369
              case Theta_flag:
 
370
                {
 
371
                  if (check_float(linetoken3))
 
372
                    token3 >> token_value;
 
373
                  else
 
374
                    uiuc_warnings_errors(1, *command_line);
 
375
                  
 
376
                  Theta_init_true = true;
 
377
                  Theta_init = token_value;
 
378
                  initParts -> storeCommands (*command_line);
 
379
                  break;
 
380
                }
 
381
              case Psi_flag:
 
382
                {
 
383
                  if (check_float(linetoken3))
 
384
                    token3 >> token_value;
 
385
                  else
 
386
                    uiuc_warnings_errors(1, *command_line);
 
387
                  
 
388
                  Psi_init_true = true;
 
389
                  Psi_init = token_value;
 
390
                  initParts -> storeCommands (*command_line);
 
391
                  break;
 
392
                }
 
393
              case Long_trim_flag:
 
394
                {
 
395
                  if (check_float(linetoken3))
 
396
                    token3 >> token_value;
 
397
                  else
 
398
                    uiuc_warnings_errors(1, *command_line);
 
399
                  
 
400
                  Long_trim = token_value;
 
401
                  initParts -> storeCommands (*command_line);
 
402
                  break;
 
403
                }
 
404
              case recordRate_flag:
 
405
                {
 
406
                  //can't use check_float since variable is integer
 
407
                  token3 >> token_value_recordRate;
 
408
                  recordRate = 120 / token_value_recordRate;
 
409
                  break;
 
410
                }
 
411
              case recordStartTime_flag:
 
412
                {
 
413
                  if (check_float(linetoken3))
 
414
                    token3 >> token_value;
 
415
                  else
 
416
                    uiuc_warnings_errors(1, *command_line);
 
417
                  
 
418
                  recordStartTime = token_value;
 
419
                  break;
 
420
                }
 
421
              case nondim_rate_V_rel_wind_flag:
 
422
                {
 
423
                  nondim_rate_V_rel_wind = true;
 
424
                  break;
 
425
                }
 
426
              case dyn_on_speed_flag:
 
427
                {
 
428
                  if (check_float(linetoken3))
 
429
                    token3 >> token_value;
 
430
                  else
 
431
                    uiuc_warnings_errors(1, *command_line);
 
432
                  
 
433
                  dyn_on_speed = token_value;
 
434
                  break;
 
435
                }
 
436
              case Alpha_flag:
 
437
                {
 
438
                  if (check_float(linetoken3))
 
439
                    token3 >> token_value;
 
440
                  else
 
441
                    uiuc_warnings_errors(1, *command_line);
 
442
 
 
443
                  Alpha_init_true = true;
 
444
                  Alpha_init = token_value * DEG_TO_RAD;
 
445
                  break;
 
446
                }
 
447
              case Beta_flag:
 
448
                {
 
449
                  if (check_float(linetoken3))
 
450
                    token3 >> token_value;
 
451
                  else
 
452
                    uiuc_warnings_errors(1, *command_line);
 
453
 
 
454
                  Beta_init_true = true;
 
455
                  Beta_init = token_value * DEG_TO_RAD;
 
456
                  break;
 
457
                }
 
458
              case U_body_flag:
 
459
                {
 
460
                  if (check_float(linetoken3))
 
461
                    token3 >> token_value;
 
462
                  else
 
463
                    uiuc_warnings_errors(1, *command_line);
 
464
 
 
465
                  U_body_init_true = true;
 
466
                  U_body_init = token_value;
 
467
                  break;
 
468
                }
 
469
              case V_body_flag:
 
470
                {
 
471
                  if (check_float(linetoken3))
 
472
                    token3 >> token_value;
 
473
                  else
 
474
                    uiuc_warnings_errors(1, *command_line);
 
475
 
 
476
                  V_body_init_true = true;
 
477
                  V_body_init = token_value;
 
478
                  break;
 
479
                }
 
480
              case W_body_flag:
 
481
                {
 
482
                  if (check_float(linetoken3))
 
483
                    token3 >> token_value;
 
484
                  else
 
485
                    uiuc_warnings_errors(1, *command_line);
 
486
 
 
487
                  W_body_init_true = true;
 
488
                  W_body_init = token_value;
 
489
                  break;
 
490
                }
 
491
              default:
 
492
                {
 
493
                  uiuc_warnings_errors(2, *command_line);
 
494
                  break;
 
495
                }
 
496
              };
 
497
            break;
 
498
          } // end init map
 
499
          
 
500
          
 
501
        case geometry_flag:
 
502
          {
 
503
            switch(geometry_map[linetoken2])
 
504
              {
 
505
              case bw_flag:
 
506
                {
 
507
                  if (check_float(linetoken3))
 
508
                    token3 >> token_value;
 
509
                  else
 
510
                    uiuc_warnings_errors(1, *command_line);
 
511
                  
 
512
                  bw = token_value;
 
513
                  geometryParts -> storeCommands (*command_line);
 
514
                  break;
 
515
                }
 
516
              case cbar_flag:
 
517
                {
 
518
                  if (check_float(linetoken3))
 
519
                    token3 >> token_value;
 
520
                  else
 
521
                    uiuc_warnings_errors(1, *command_line);
 
522
                  
 
523
                  cbar = token_value;
 
524
                  geometryParts -> storeCommands (*command_line);
 
525
                  break;
 
526
                }
 
527
              case Sw_flag:
 
528
                {
 
529
                  if (check_float(linetoken3))
 
530
                    token3 >> token_value;
 
531
                  else
 
532
                    uiuc_warnings_errors(1, *command_line);
 
533
                  
 
534
                  Sw = token_value;
 
535
                  geometryParts -> storeCommands (*command_line);
 
536
                  break;
 
537
                }
 
538
              case ih_flag:
 
539
                {
 
540
                  if (check_float(linetoken3))
 
541
                    token3 >> token_value;
 
542
                  else
 
543
                    uiuc_warnings_errors(1, *command_line);
 
544
                  
 
545
                  ih = token_value;
 
546
                  geometryParts -> storeCommands (*command_line);
 
547
                  break;
 
548
                }
 
549
              case bh_flag:
 
550
                {
 
551
                  if (check_float(linetoken3))
 
552
                    token3 >> token_value;
 
553
                  else
 
554
                    uiuc_warnings_errors(1, *command_line);
 
555
                  
 
556
                  bh = token_value;
 
557
                  geometryParts -> storeCommands (*command_line);
 
558
                  break;
 
559
                }
 
560
              case ch_flag:
 
561
                {
 
562
                  if (check_float(linetoken3))
 
563
                    token3 >> token_value;
 
564
                  else
 
565
                    uiuc_warnings_errors(1, *command_line);
 
566
                  
 
567
                  ch = token_value;
 
568
                  geometryParts -> storeCommands (*command_line);
 
569
                  break;
 
570
                }
 
571
              case Sh_flag:
 
572
                {
 
573
                  if (check_float(linetoken3))
 
574
                    token3 >> token_value;
 
575
                  else
 
576
                    uiuc_warnings_errors(1, *command_line);
 
577
                  
 
578
                  Sh = token_value;
 
579
                  geometryParts -> storeCommands (*command_line);
 
580
                  break;
 
581
                }
 
582
              default:
 
583
                {
 
584
                  uiuc_warnings_errors(2, *command_line);
 
585
                  break;
 
586
                }
 
587
              };
 
588
            break;
 
589
          } // end geometry map
 
590
 
 
591
 
 
592
        case controlSurface_flag:
 
593
          {
 
594
            switch(controlSurface_map[linetoken2])
 
595
              {
 
596
              case de_flag:
 
597
                {
 
598
                  if (check_float(linetoken3))
 
599
                    token3 >> token_value;
 
600
                  else
 
601
                    uiuc_warnings_errors(1, *command_line);
 
602
                  
 
603
                  demax = token_value;
 
604
                  
 
605
                  if (check_float(linetoken4))
 
606
                    token4 >> token_value;
 
607
                  else
 
608
                    uiuc_warnings_errors(1, *command_line);
 
609
                  
 
610
                  demin = token_value;
 
611
                  break;
 
612
                }
 
613
              case da_flag:
 
614
                {
 
615
                  if (check_float(linetoken3))
 
616
                    token3 >> token_value;
 
617
                  else
 
618
                    uiuc_warnings_errors(1, *command_line);
 
619
                  
 
620
                  damax = token_value;
 
621
                  
 
622
                  if (check_float(linetoken4))
 
623
                    token4 >> token_value;
 
624
                  else
 
625
                    uiuc_warnings_errors(1, *command_line);
 
626
                  
 
627
                  damin = token_value;
 
628
                  break;
 
629
                }
 
630
              case dr_flag:
 
631
                {
 
632
                  if (check_float(linetoken3))
 
633
                    token3 >> token_value;
 
634
                  else
 
635
                    uiuc_warnings_errors(1, *command_line);
 
636
                  
 
637
                  drmax = token_value;
 
638
                  
 
639
                  if (check_float(linetoken4))
 
640
                    token4 >> token_value;
 
641
                  else
 
642
                    uiuc_warnings_errors(1, *command_line);
 
643
                  
 
644
                  drmin = token_value;
 
645
                  break;
 
646
                }
 
647
              case set_Long_trim_flag:
 
648
                {
 
649
                  if (check_float(linetoken3))
 
650
                    token3 >> token_value;
 
651
                  else
 
652
                    uiuc_warnings_errors(1, *command_line);
 
653
                  
 
654
                  set_Long_trim = true;
 
655
                  elevator_tab = token_value;
 
656
                  break;
 
657
                }
 
658
              case set_Long_trim_deg_flag:
 
659
                {
 
660
                  if (check_float(linetoken3))
 
661
                    token3 >> token_value;
 
662
                  else
 
663
                    uiuc_warnings_errors(1, *command_line);
 
664
                  
 
665
                  set_Long_trim = true;
 
666
                  elevator_tab = token_value * DEG_TO_RAD;
 
667
                  break;
 
668
                }
 
669
              case zero_Long_trim_flag:
 
670
                {
 
671
                  zero_Long_trim = true;
 
672
                  break;
 
673
                }
 
674
              case elevator_step_flag:
 
675
                {
 
676
                  // set step input flag
 
677
                  elevator_step = true;
 
678
 
 
679
                  // read in step angle in degrees and convert
 
680
                  if (check_float(linetoken3))
 
681
                    token3 >> token_value;
 
682
                  else
 
683
                    uiuc_warnings_errors(1, *command_line);
 
684
 
 
685
                  elevator_step_angle = token_value * DEG_TO_RAD;
 
686
 
 
687
                  // read in step start time
 
688
                  if (check_float(linetoken4))
 
689
                    token4 >> token_value;
 
690
                  else
 
691
                    uiuc_warnings_errors(1, *command_line);
 
692
                  
 
693
                  elevator_step_startTime = token_value;
 
694
                  break;
 
695
                }
 
696
              case elevator_singlet_flag:
 
697
                {
 
698
                  // set singlet input flag
 
699
                  elevator_singlet = true;
 
700
 
 
701
                  // read in singlet angle in degrees and convert
 
702
                  if (check_float(linetoken3))
 
703
                    token3 >> token_value;
 
704
                  else
 
705
                    uiuc_warnings_errors(1, *command_line);
 
706
 
 
707
                  elevator_singlet_angle = token_value * DEG_TO_RAD;
 
708
 
 
709
                  // read in singlet start time
 
710
                  if (check_float(linetoken4))
 
711
                    token4 >> token_value;
 
712
                  else
 
713
                    uiuc_warnings_errors(1, *command_line);
 
714
                  
 
715
                  elevator_singlet_startTime = token_value;
 
716
 
 
717
                  // read in singlet duration
 
718
                  if (check_float(linetoken5))
 
719
                    token5 >> token_value;
 
720
                  else
 
721
                    uiuc_warnings_errors(1, *command_line);
 
722
                  
 
723
                  elevator_singlet_duration = token_value;
 
724
                  break;
 
725
                }
 
726
              case elevator_doublet_flag:
 
727
                {
 
728
                  // set doublet input flag
 
729
                  elevator_doublet = true;
 
730
 
 
731
                  // read in doublet angle in degrees and convert
 
732
                  if (check_float(linetoken3))
 
733
                    token3 >> token_value;
 
734
                  else
 
735
                    uiuc_warnings_errors(1, *command_line);
 
736
 
 
737
                  elevator_doublet_angle = token_value * DEG_TO_RAD;
 
738
 
 
739
                  // read in doublet start time
 
740
                  if (check_float(linetoken4))
 
741
                    token4 >> token_value;
 
742
                  else
 
743
                    uiuc_warnings_errors(1, *command_line);
 
744
                  
 
745
                  elevator_doublet_startTime = token_value;
 
746
 
 
747
                  // read in doublet duration
 
748
                  if (check_float(linetoken5))
 
749
                    token5 >> token_value;
 
750
                  else
 
751
                    uiuc_warnings_errors(1, *command_line);
 
752
                  
 
753
                  elevator_doublet_duration = token_value;
 
754
                  break;
 
755
                }
 
756
              case elevator_input_flag:
 
757
                {
 
758
                  elevator_input = true;
 
759
                  elevator_input_file = linetoken3;
 
760
                  token4 >> token_value_convert1;
 
761
                  token5 >> token_value_convert2;
 
762
                  convert_y = uiuc_convert(token_value_convert1);
 
763
                  convert_x = uiuc_convert(token_value_convert2);
 
764
                  uiuc_1DdataFileReader(elevator_input_file,
 
765
                                        elevator_input_timeArray,
 
766
                                        elevator_input_deArray,
 
767
                                        elevator_input_ntime);
 
768
                  token6 >> token_value;
 
769
                  elevator_input_startTime = token_value;
 
770
                  break;
 
771
                }
 
772
              case aileron_input_flag:
 
773
                {
 
774
                  aileron_input = true;
 
775
                  aileron_input_file = linetoken3;
 
776
                  token4 >> token_value_convert1;
 
777
                  token5 >> token_value_convert2;
 
778
                  convert_y = uiuc_convert(token_value_convert1);
 
779
                  convert_x = uiuc_convert(token_value_convert2);
 
780
                  uiuc_1DdataFileReader(aileron_input_file,
 
781
                                        aileron_input_timeArray,
 
782
                                        aileron_input_daArray,
 
783
                                        aileron_input_ntime);
 
784
                  token6 >> token_value;
 
785
                  aileron_input_startTime = token_value;
 
786
                  break;
 
787
                }
 
788
              case rudder_input_flag:
 
789
                {
 
790
                  rudder_input = true;
 
791
                  rudder_input_file = linetoken3;
 
792
                  token4 >> token_value_convert1;
 
793
                  token5 >> token_value_convert2;
 
794
                  convert_y = uiuc_convert(token_value_convert1);
 
795
                  convert_x = uiuc_convert(token_value_convert2);
 
796
                  uiuc_1DdataFileReader(rudder_input_file,
 
797
                                        rudder_input_timeArray,
 
798
                                        rudder_input_drArray,
 
799
                                        rudder_input_ntime);
 
800
                  token6 >> token_value;
 
801
                  rudder_input_startTime = token_value;
 
802
                  break;
 
803
                }
 
804
              case pilot_elev_no_flag:
 
805
                {
 
806
                  pilot_elev_no_check = true;
 
807
                  break;
 
808
                }
 
809
              case pilot_ail_no_flag:
 
810
                {
 
811
                  pilot_ail_no_check = true;
 
812
                  break;
 
813
                }
 
814
              case pilot_rud_no_flag:
 
815
                {
 
816
                  pilot_rud_no_check = true;
 
817
                  break;
 
818
                }
 
819
              default:
 
820
                {
 
821
                  uiuc_warnings_errors(2, *command_line);
 
822
                  break;
 
823
                }
 
824
              };
 
825
            break;
 
826
          } // end controlSurface map
 
827
 
 
828
 
 
829
        case mass_flag:
 
830
          {
 
831
            switch(mass_map[linetoken2])
 
832
              {
 
833
              case Weight_flag:
 
834
                {
 
835
                  if (check_float(linetoken3))
 
836
                    token3 >> token_value;
 
837
                  else
 
838
                    uiuc_warnings_errors(1, *command_line);
 
839
                  
 
840
                  Weight = token_value;
 
841
                  Mass = Weight * INVG;
 
842
                  massParts -> storeCommands (*command_line);
 
843
                  break;
 
844
                }
 
845
              case Mass_flag:
 
846
                {
 
847
                  if (check_float(linetoken3))
 
848
                    token3 >> token_value;
 
849
                  else
 
850
                    uiuc_warnings_errors(1, *command_line);
 
851
                  
 
852
                  Mass = token_value;
 
853
                  massParts -> storeCommands (*command_line);
 
854
                  break;
 
855
                }
 
856
              case I_xx_flag:
 
857
                {
 
858
                  if (check_float(linetoken3))
 
859
                    token3 >> token_value;
 
860
                  else
 
861
                    uiuc_warnings_errors(1, *command_line);
 
862
                  
 
863
                  I_xx = token_value;
 
864
                  massParts -> storeCommands (*command_line);
 
865
                  break;
 
866
                }
 
867
              case I_yy_flag:
 
868
                {
 
869
                  if (check_float(linetoken3))
 
870
                    token3 >> token_value;
 
871
                  else
 
872
                    uiuc_warnings_errors(1, *command_line);
 
873
                  
 
874
                  I_yy = token_value;
 
875
                  massParts -> storeCommands (*command_line);
 
876
                  break;
 
877
                }
 
878
              case I_zz_flag:
 
879
                {
 
880
                  if (check_float(linetoken3))
 
881
                    token3 >> token_value;
 
882
                  else
 
883
                    uiuc_warnings_errors(1, *command_line);
 
884
                  
 
885
                  I_zz = token_value;
 
886
                  massParts -> storeCommands (*command_line);
 
887
                  break;
 
888
                }
 
889
              case I_xz_flag:
 
890
                {
 
891
                  if (check_float(linetoken3))
 
892
                    token3 >> token_value;
 
893
                  else
 
894
                    uiuc_warnings_errors(1, *command_line);
 
895
                  
 
896
                  I_xz = token_value;
 
897
                  massParts -> storeCommands (*command_line);
 
898
                  break;
 
899
                }
 
900
              default:
 
901
                {
 
902
                  uiuc_warnings_errors(2, *command_line);
 
903
                  break;
 
904
                }
 
905
              };
 
906
            break;
 
907
          } // end mass map
 
908
          
 
909
          
 
910
        case engine_flag:
 
911
          {
 
912
            switch(engine_map[linetoken2])
 
913
              {
 
914
              case simpleSingle_flag:
 
915
                {
 
916
                  if (check_float(linetoken3))
 
917
                    token3 >> token_value;
 
918
                  else
 
919
                    uiuc_warnings_errors(1, *command_line);
 
920
                  
 
921
                  simpleSingleMaxThrust = token_value; 
 
922
                  engineParts -> storeCommands (*command_line);
 
923
                  break;
 
924
                }
 
925
              case c172_flag:
 
926
                {
 
927
                  engineParts -> storeCommands (*command_line);
 
928
                  break;
 
929
                }
 
930
              case cherokee_flag:
 
931
                {
 
932
                  engineParts -> storeCommands (*command_line);
 
933
                  break;
 
934
                }
 
935
              case Throttle_pct_input_flag:
 
936
                {
 
937
                  Throttle_pct_input = true;
 
938
                  Throttle_pct_input_file = linetoken3;
 
939
                  token4 >> token_value_convert1;
 
940
                  token5 >> token_value_convert2;
 
941
                  convert_y = uiuc_convert(token_value_convert1);
 
942
                  convert_x = uiuc_convert(token_value_convert2);
 
943
                  uiuc_1DdataFileReader(Throttle_pct_input_file,
 
944
                                        Throttle_pct_input_timeArray,
 
945
                                        Throttle_pct_input_dTArray,
 
946
                                        Throttle_pct_input_ntime);
 
947
                  token6 >> token_value;
 
948
                  Throttle_pct_input_startTime = token_value;
 
949
                  break;
 
950
                }
 
951
              default:
 
952
                {
 
953
                  uiuc_warnings_errors(2, *command_line);
 
954
                  break;
 
955
                }
 
956
              };
 
957
            break;
 
958
          } // end engine map
 
959
          
 
960
          
 
961
        case CD_flag:
 
962
          {
 
963
            switch(CD_map[linetoken2])
 
964
              {
 
965
              case CDo_flag:
 
966
                {
 
967
                  if (check_float(linetoken3))
 
968
                    token3 >> token_value;
 
969
                  else
 
970
                    uiuc_warnings_errors(1, *command_line);
 
971
                  
 
972
                  CDo = token_value;
 
973
                  CDo_clean = CDo;
 
974
                  aeroDragParts -> storeCommands (*command_line);
 
975
                  break;
 
976
                }
 
977
              case CDK_flag:
 
978
                {
 
979
                  if (check_float(linetoken3))
 
980
                    token3 >> token_value;
 
981
                  else
 
982
                    uiuc_warnings_errors(1, *command_line);
 
983
                  
 
984
                  CDK = token_value;
 
985
                  CDK_clean = CDK;
 
986
                  aeroDragParts -> storeCommands (*command_line);
 
987
                  break;
 
988
                }
 
989
              case CD_a_flag:
 
990
                {
 
991
                  if (check_float(linetoken3))
 
992
                    token3 >> token_value;
 
993
                  else
 
994
                    uiuc_warnings_errors(1, *command_line);
 
995
                  
 
996
                  CD_a = token_value;
 
997
                  CD_a_clean = CD_a;
 
998
                  aeroDragParts -> storeCommands (*command_line);
 
999
                  break;
 
1000
                }
 
1001
              case CD_adot_flag:
 
1002
                {
 
1003
                  if (check_float(linetoken3))
 
1004
                    token3 >> token_value;
 
1005
                  else
 
1006
                    uiuc_warnings_errors(1, *command_line);
 
1007
                  
 
1008
                  CD_adot = token_value;
 
1009
                  CD_adot_clean = CD_adot;
 
1010
                  aeroDragParts -> storeCommands (*command_line);
 
1011
                  break;
 
1012
                }
 
1013
              case CD_q_flag:
 
1014
                {
 
1015
                  if (check_float(linetoken3))
 
1016
                    token3 >> token_value;
 
1017
                  else
 
1018
                    uiuc_warnings_errors(1, *command_line);
 
1019
                  
 
1020
                  CD_q = token_value;
 
1021
                  CD_q_clean = CD_q;
 
1022
                  aeroDragParts -> storeCommands (*command_line);
 
1023
                  break;
 
1024
                }
 
1025
              case CD_ih_flag:
 
1026
                {
 
1027
                  if (check_float(linetoken3))
 
1028
                    token3 >> token_value;
 
1029
                  else
 
1030
                    uiuc_warnings_errors(1, *command_line);
 
1031
                  
 
1032
                  CD_ih = token_value;
 
1033
                  aeroDragParts -> storeCommands (*command_line);
 
1034
                  break;
 
1035
                }
 
1036
              case CD_de_flag:
 
1037
                {
 
1038
                  if (check_float(linetoken3))
 
1039
                    token3 >> token_value;
 
1040
                  else
 
1041
                    uiuc_warnings_errors(1, *command_line);
 
1042
                  
 
1043
                  CD_de = token_value;
 
1044
                  CD_de_clean = CD_de;
 
1045
                  aeroDragParts -> storeCommands (*command_line);
 
1046
                  break;
 
1047
                }
 
1048
              case CDfa_flag:
 
1049
                {
 
1050
                  CDfa = linetoken3;
 
1051
                  token4 >> token_value_convert1;
 
1052
                  token5 >> token_value_convert2;
 
1053
                  convert_y = uiuc_convert(token_value_convert1);
 
1054
                  convert_x = uiuc_convert(token_value_convert2);
 
1055
                  /* call 1D File Reader with file name (CDfa) and conversion 
 
1056
                     factors; function returns array of alphas (aArray) and 
 
1057
                     corresponding CD values (CDArray) and max number of 
 
1058
                     terms in arrays (nAlpha) */
 
1059
                  uiuc_1DdataFileReader(CDfa,
 
1060
                                        CDfa_aArray,
 
1061
                                        CDfa_CDArray,
 
1062
                                        CDfa_nAlpha);
 
1063
                  aeroDragParts -> storeCommands (*command_line);
 
1064
                  break;
 
1065
                }
 
1066
              case CDfCL_flag:
 
1067
                {
 
1068
                  CDfCL = linetoken3;
 
1069
                  token4 >> token_value_convert1;
 
1070
                  token5 >> token_value_convert2;
 
1071
                  convert_y = uiuc_convert(token_value_convert1);
 
1072
                  convert_x = uiuc_convert(token_value_convert2);
 
1073
                  /* call 1D File Reader with file name (CDfCL) and conversion 
 
1074
                     factors; function returns array of CLs (CLArray) and 
 
1075
                     corresponding CD values (CDArray) and max number of 
 
1076
                     terms in arrays (nCL) */
 
1077
                  uiuc_1DdataFileReader(CDfCL,
 
1078
                                        CDfCL_CLArray,
 
1079
                                        CDfCL_CDArray,
 
1080
                                        CDfCL_nCL);
 
1081
                  aeroDragParts -> storeCommands (*command_line);
 
1082
                  break;
 
1083
                }
 
1084
              case CDfade_flag:
 
1085
                {
 
1086
                  CDfade = linetoken3;
 
1087
                  token4 >> token_value_convert1;
 
1088
                  token5 >> token_value_convert2;
 
1089
                  token6 >> token_value_convert3;
 
1090
                  convert_z = uiuc_convert(token_value_convert1);
 
1091
                  convert_x = uiuc_convert(token_value_convert2);
 
1092
                  convert_y = uiuc_convert(token_value_convert3);
 
1093
                  /* call 2D File Reader with file name (CDfade) and 
 
1094
                     conversion factors; function returns array of 
 
1095
                     elevator deflections (deArray) and corresponding 
 
1096
                     alpha (aArray) and delta CD (CDArray) values and 
 
1097
                     max number of terms in alpha arrays (nAlphaArray) 
 
1098
                     and deflection array (nde) */
 
1099
                  uiuc_2DdataFileReader(CDfade,
 
1100
                                        CDfade_aArray,
 
1101
                                        CDfade_deArray,
 
1102
                                        CDfade_CDArray,
 
1103
                                        CDfade_nAlphaArray,
 
1104
                                        CDfade_nde);
 
1105
                  aeroDragParts -> storeCommands (*command_line);
 
1106
                  break;
 
1107
                }
 
1108
              case CDfdf_flag:
 
1109
                {
 
1110
                  CDfdf = linetoken3;
 
1111
                  token4 >> token_value_convert1;
 
1112
                  token5 >> token_value_convert2;
 
1113
                  convert_y = uiuc_convert(token_value_convert1);
 
1114
                  convert_x = uiuc_convert(token_value_convert2);
 
1115
                  /* call 1D File Reader with file name (CDfdf) and conversion 
 
1116
                     factors; function returns array of dfs (dfArray) and 
 
1117
                     corresponding CD values (CDArray) and max number of 
 
1118
                     terms in arrays (ndf) */
 
1119
                  uiuc_1DdataFileReader(CDfdf,
 
1120
                                        CDfdf_dfArray,
 
1121
                                        CDfdf_CDArray,
 
1122
                                        CDfdf_ndf);
 
1123
                  aeroDragParts -> storeCommands (*command_line);
 
1124
                  break;
 
1125
                }
 
1126
              case CDfadf_flag:
 
1127
                {
 
1128
                  CDfadf = linetoken3;
 
1129
                  token4 >> token_value_convert1;
 
1130
                  token5 >> token_value_convert2;
 
1131
                  token6 >> token_value_convert3;
 
1132
                  convert_z = uiuc_convert(token_value_convert1);
 
1133
                  convert_x = uiuc_convert(token_value_convert2);
 
1134
                  convert_y = uiuc_convert(token_value_convert3);
 
1135
                  /* call 2D File Reader with file name (CDfadf) and 
 
1136
                     conversion factors; function returns array of 
 
1137
                     flap deflections (dfArray) and corresponding 
 
1138
                     alpha (aArray) and delta CD (CDArray) values and 
 
1139
                     max number of terms in alpha arrays (nAlphaArray) 
 
1140
                     and deflection array (ndf) */
 
1141
                  uiuc_2DdataFileReader(CDfadf,
 
1142
                                        CDfadf_aArray,
 
1143
                                        CDfadf_dfArray,
 
1144
                                        CDfadf_CDArray,
 
1145
                                        CDfadf_nAlphaArray,
 
1146
                                        CDfadf_ndf);
 
1147
                  aeroDragParts -> storeCommands (*command_line);
 
1148
                  break;
 
1149
                }
 
1150
              case CXo_flag:
 
1151
                {
 
1152
                  if (check_float(linetoken3))
 
1153
                    token3 >> token_value;
 
1154
                  else
 
1155
                    uiuc_warnings_errors(1, *command_line);
 
1156
                  
 
1157
                  CXo = token_value;
 
1158
                  CXo_clean = CXo;
 
1159
                  aeroDragParts -> storeCommands (*command_line);
 
1160
                  break;
 
1161
                }
 
1162
              case CXK_flag:
 
1163
                {
 
1164
                  if (check_float(linetoken3))
 
1165
                    token3 >> token_value;
 
1166
                  else
 
1167
                    uiuc_warnings_errors(1, *command_line);
 
1168
                  
 
1169
                  CXK = token_value;
 
1170
                  CXK_clean = CXK;
 
1171
                  aeroDragParts -> storeCommands (*command_line);
 
1172
                  break;
 
1173
                }
 
1174
              case CX_a_flag:
 
1175
                {
 
1176
                  if (check_float(linetoken3))
 
1177
                    token3 >> token_value;
 
1178
                  else
 
1179
                    uiuc_warnings_errors(1, *command_line);
 
1180
                  
 
1181
                  CX_a = token_value;
 
1182
                  CX_a_clean = CX_a;
 
1183
                  aeroDragParts -> storeCommands (*command_line);
 
1184
                  break;
 
1185
                }
 
1186
              case CX_a2_flag:
 
1187
                {
 
1188
                  if (check_float(linetoken3))
 
1189
                    token3 >> token_value;
 
1190
                  else
 
1191
                    uiuc_warnings_errors(1, *command_line);
 
1192
                  
 
1193
                  CX_a2 = token_value;
 
1194
                  CX_a2_clean = CX_a2;
 
1195
                  aeroDragParts -> storeCommands (*command_line);
 
1196
                  break;
 
1197
                }
 
1198
              case CX_a3_flag:
 
1199
                {
 
1200
                  if (check_float(linetoken3))
 
1201
                    token3 >> token_value;
 
1202
                  else
 
1203
                    uiuc_warnings_errors(1, *command_line);
 
1204
                  
 
1205
                  CX_a3 = token_value;
 
1206
                  CX_a3_clean = CX_a3;
 
1207
                  aeroDragParts -> storeCommands (*command_line);
 
1208
                  break;
 
1209
                }
 
1210
              case CX_adot_flag:
 
1211
                {
 
1212
                  if (check_float(linetoken3))
 
1213
                    token3 >> token_value;
 
1214
                  else
 
1215
                    uiuc_warnings_errors(1, *command_line);
 
1216
                  
 
1217
                  CX_adot = token_value;
 
1218
                  CX_adot_clean = CX_adot;
 
1219
                  aeroDragParts -> storeCommands (*command_line);
 
1220
                  break;
 
1221
                }
 
1222
              case CX_q_flag:
 
1223
                {
 
1224
                  if (check_float(linetoken3))
 
1225
                    token3 >> token_value;
 
1226
                  else
 
1227
                    uiuc_warnings_errors(1, *command_line);
 
1228
                  
 
1229
                  CX_q = token_value;
 
1230
                  CX_q_clean = CX_q;
 
1231
                  aeroDragParts -> storeCommands (*command_line);
 
1232
                  break;
 
1233
                }
 
1234
              case CX_de_flag:
 
1235
                {
 
1236
                  if (check_float(linetoken3))
 
1237
                    token3 >> token_value;
 
1238
                  else
 
1239
                    uiuc_warnings_errors(1, *command_line);
 
1240
                  
 
1241
                  CX_de = token_value;
 
1242
                  CX_de_clean = CX_de;
 
1243
                  aeroDragParts -> storeCommands (*command_line);
 
1244
                  break;
 
1245
                }
 
1246
              case CX_dr_flag:
 
1247
                {
 
1248
                  if (check_float(linetoken3))
 
1249
                    token3 >> token_value;
 
1250
                  else
 
1251
                    uiuc_warnings_errors(1, *command_line);
 
1252
                  
 
1253
                  CX_dr = token_value;
 
1254
                  CX_dr_clean = CX_dr;
 
1255
                  aeroDragParts -> storeCommands (*command_line);
 
1256
                  break;
 
1257
                }
 
1258
              case CX_df_flag:
 
1259
                {
 
1260
                  if (check_float(linetoken3))
 
1261
                    token3 >> token_value;
 
1262
                  else
 
1263
                    uiuc_warnings_errors(1, *command_line);
 
1264
                  
 
1265
                  CX_df = token_value;
 
1266
                  CX_df_clean = CX_df;
 
1267
                  aeroDragParts -> storeCommands (*command_line);
 
1268
                  break;
 
1269
                }
 
1270
              case CX_adf_flag:
 
1271
                {
 
1272
                  if (check_float(linetoken3))
 
1273
                    token3 >> token_value;
 
1274
                  else
 
1275
                    uiuc_warnings_errors(1, *command_line);
 
1276
                  
 
1277
                  CX_adf = token_value;
 
1278
                  CX_adf_clean = CX_adf;
 
1279
                  aeroDragParts -> storeCommands (*command_line);
 
1280
                  break;
 
1281
                }
 
1282
              default:
 
1283
                {
 
1284
                  uiuc_warnings_errors(2, *command_line);
 
1285
                  break;
 
1286
                }
 
1287
              };
 
1288
            break;
 
1289
          } // end CD map
 
1290
 
 
1291
          
 
1292
        case CL_flag:
 
1293
          {
 
1294
            switch(CL_map[linetoken2])
 
1295
              {
 
1296
              case CLo_flag:
 
1297
                {
 
1298
                  if (check_float(linetoken3))
 
1299
                    token3 >> token_value;
 
1300
                  else
 
1301
                    uiuc_warnings_errors(1, *command_line);
 
1302
                  
 
1303
                  CLo = token_value;
 
1304
                  CLo_clean = CLo;
 
1305
                  aeroLiftParts -> storeCommands (*command_line);
 
1306
                  break;
 
1307
                }
 
1308
              case CL_a_flag:
 
1309
                {
 
1310
                  if (check_float(linetoken3))
 
1311
                    token3 >> token_value;
 
1312
                  else
 
1313
                    uiuc_warnings_errors(1, *command_line);
 
1314
                  
 
1315
                  CL_a = token_value;
 
1316
                  CL_a_clean = CL_a;
 
1317
                  aeroLiftParts -> storeCommands (*command_line);
 
1318
                  break;
 
1319
                }
 
1320
              case CL_adot_flag:
 
1321
                {
 
1322
                  if (check_float(linetoken3))
 
1323
                    token3 >> token_value;
 
1324
                  else
 
1325
                    uiuc_warnings_errors(1, *command_line);
 
1326
 
 
1327
                  CL_adot = token_value;
 
1328
                  CL_adot_clean = CL_adot;
 
1329
                  aeroLiftParts -> storeCommands (*command_line);
 
1330
                  break;
 
1331
                }
 
1332
              case CL_q_flag:
 
1333
                {
 
1334
                  if (check_float(linetoken3))
 
1335
                    token3 >> token_value;
 
1336
                  else
 
1337
                    uiuc_warnings_errors(1, *command_line);
 
1338
 
 
1339
                  CL_q = token_value;
 
1340
                  CL_q_clean = CL_q;
 
1341
                  aeroLiftParts -> storeCommands (*command_line);
 
1342
                  break;
 
1343
                }
 
1344
              case CL_ih_flag:
 
1345
                {
 
1346
                  if (check_float(linetoken3))
 
1347
                    token3 >> token_value;
 
1348
                  else
 
1349
                    uiuc_warnings_errors(1, *command_line);
 
1350
 
 
1351
                  CL_ih = token_value;
 
1352
                  aeroLiftParts -> storeCommands (*command_line);
 
1353
                  break;
 
1354
                }
 
1355
              case CL_de_flag:
 
1356
                {
 
1357
                  if (check_float(linetoken3))
 
1358
                    token3 >> token_value;
 
1359
                  else
 
1360
                    uiuc_warnings_errors(1, *command_line);
 
1361
 
 
1362
                  CL_de = token_value;
 
1363
                  CL_de_clean = CL_de;
 
1364
                  aeroLiftParts -> storeCommands (*command_line);
 
1365
                  break;
 
1366
                }
 
1367
              case CLfa_flag:
 
1368
                {
 
1369
                  CLfa = linetoken3;
 
1370
                  token4 >> token_value_convert1;
 
1371
                  token5 >> token_value_convert2;
 
1372
                  convert_y = uiuc_convert(token_value_convert1);
 
1373
                  convert_x = uiuc_convert(token_value_convert2);
 
1374
                  /* call 1D File Reader with file name (CLfa) and conversion 
 
1375
                     factors; function returns array of alphas (aArray) and 
 
1376
                     corresponding CL values (CLArray) and max number of 
 
1377
                     terms in arrays (nAlpha) */
 
1378
                  uiuc_1DdataFileReader(CLfa,
 
1379
                                        CLfa_aArray,
 
1380
                                        CLfa_CLArray,
 
1381
                                        CLfa_nAlpha);
 
1382
                  aeroLiftParts -> storeCommands (*command_line);
 
1383
                  break;
 
1384
                }
 
1385
              case CLfade_flag:
 
1386
                {
 
1387
                  CLfade = linetoken3;
 
1388
                  token4 >> token_value_convert1;
 
1389
                  token5 >> token_value_convert2;
 
1390
                  token6 >> token_value_convert3;
 
1391
                  convert_z = uiuc_convert(token_value_convert1);
 
1392
                  convert_x = uiuc_convert(token_value_convert2);
 
1393
                  convert_y = uiuc_convert(token_value_convert3);
 
1394
                  /* call 2D File Reader with file name (CLfade) and 
 
1395
                     conversion factors; function returns array of 
 
1396
                     elevator deflections (deArray) and corresponding 
 
1397
                     alpha (aArray) and delta CL (CLArray) values and 
 
1398
                     max number of terms in alpha arrays (nAlphaArray) 
 
1399
                     and deflection array (nde) */
 
1400
                  uiuc_2DdataFileReader(CLfade,
 
1401
                                        CLfade_aArray,
 
1402
                                        CLfade_deArray,
 
1403
                                        CLfade_CLArray,
 
1404
                                        CLfade_nAlphaArray,
 
1405
                                        CLfade_nde);
 
1406
                  aeroLiftParts -> storeCommands (*command_line);
 
1407
                  break;
 
1408
                }
 
1409
              case CLfdf_flag:
 
1410
                {
 
1411
                  CLfdf = linetoken3;
 
1412
                  token4 >> token_value_convert1;
 
1413
                  token5 >> token_value_convert2;
 
1414
                  convert_y = uiuc_convert(token_value_convert1);
 
1415
                  convert_x = uiuc_convert(token_value_convert2);
 
1416
                  /* call 1D File Reader with file name (CLfdf) and conversion 
 
1417
                     factors; function returns array of dfs (dfArray) and 
 
1418
                     corresponding CL values (CLArray) and max number of 
 
1419
                     terms in arrays (ndf) */
 
1420
                  uiuc_1DdataFileReader(CLfdf,
 
1421
                                        CLfdf_dfArray,
 
1422
                                        CLfdf_CLArray,
 
1423
                                        CLfdf_ndf);
 
1424
                  aeroLiftParts -> storeCommands (*command_line);
 
1425
 
 
1426
                  // additional variables to streamline flap routine in aerodeflections
 
1427
                  ndf = CLfdf_ndf;
 
1428
                  int temp_counter = 1;
 
1429
                  while (temp_counter <= ndf)
 
1430
                    {
 
1431
                      dfArray[temp_counter] = CLfdf_dfArray[temp_counter];
 
1432
                      TimeArray[temp_counter] = dfTimefdf_TimeArray[temp_counter];
 
1433
                      temp_counter++;
 
1434
                    }
 
1435
                  break;
 
1436
                }
 
1437
              case CLfadf_flag:
 
1438
                {
 
1439
                  CLfadf = linetoken3;
 
1440
                  token4 >> token_value_convert1;
 
1441
                  token5 >> token_value_convert2;
 
1442
                  token6 >> token_value_convert3;
 
1443
                  convert_z = uiuc_convert(token_value_convert1);
 
1444
                  convert_x = uiuc_convert(token_value_convert2);
 
1445
                  convert_y = uiuc_convert(token_value_convert3);
 
1446
                  /* call 2D File Reader with file name (CLfadf) and 
 
1447
                     conversion factors; function returns array of 
 
1448
                     flap deflections (dfArray) and corresponding 
 
1449
                     alpha (aArray) and delta CL (CLArray) values and 
 
1450
                     max number of terms in alpha arrays (nAlphaArray) 
 
1451
                     and deflection array (ndf) */
 
1452
                  uiuc_2DdataFileReader(CLfadf,
 
1453
                                        CLfadf_aArray,
 
1454
                                        CLfadf_dfArray,
 
1455
                                        CLfadf_CLArray,
 
1456
                                        CLfadf_nAlphaArray,
 
1457
                                        CLfadf_ndf);
 
1458
                  aeroLiftParts -> storeCommands (*command_line);
 
1459
                  break;
 
1460
                }
 
1461
              case CZo_flag:
 
1462
                {
 
1463
                  if (check_float(linetoken3))
 
1464
                    token3 >> token_value;
 
1465
                  else
 
1466
                    uiuc_warnings_errors(1, *command_line);
 
1467
                  
 
1468
                  CZo = token_value;
 
1469
                  CZo_clean = CZo;
 
1470
                  aeroLiftParts -> storeCommands (*command_line);
 
1471
                  break;
 
1472
                }
 
1473
              case CZ_a_flag:
 
1474
                {
 
1475
                  if (check_float(linetoken3))
 
1476
                    token3 >> token_value;
 
1477
                  else
 
1478
                    uiuc_warnings_errors(1, *command_line);
 
1479
                  
 
1480
                  CZ_a = token_value;
 
1481
                  CZ_a_clean = CZ_a;
 
1482
                  aeroLiftParts -> storeCommands (*command_line);
 
1483
                  break;
 
1484
                }
 
1485
              case CZ_a2_flag:
 
1486
                {
 
1487
                  if (check_float(linetoken3))
 
1488
                    token3 >> token_value;
 
1489
                  else
 
1490
                    uiuc_warnings_errors(1, *command_line);
 
1491
                  
 
1492
                  CZ_a2 = token_value;
 
1493
                  CZ_a2_clean = CZ_a2;
 
1494
                  aeroLiftParts -> storeCommands (*command_line);
 
1495
                  break;
 
1496
                }
 
1497
              case CZ_a3_flag:
 
1498
                {
 
1499
                  if (check_float(linetoken3))
 
1500
                    token3 >> token_value;
 
1501
                  else
 
1502
                    uiuc_warnings_errors(1, *command_line);
 
1503
                  
 
1504
                  CZ_a3 = token_value;
 
1505
                  CZ_a3_clean = CZ_a3;
 
1506
                  aeroLiftParts -> storeCommands (*command_line);
 
1507
                  break;
 
1508
                }
 
1509
              case CZ_adot_flag:
 
1510
                {
 
1511
                  if (check_float(linetoken3))
 
1512
                    token3 >> token_value;
 
1513
                  else
 
1514
                    uiuc_warnings_errors(1, *command_line);
 
1515
 
 
1516
                  CZ_adot = token_value;
 
1517
                  CZ_adot_clean = CZ_adot;
 
1518
                  aeroLiftParts -> storeCommands (*command_line);
 
1519
                  break;
 
1520
                }
 
1521
              case CZ_q_flag:
 
1522
                {
 
1523
                  if (check_float(linetoken3))
 
1524
                    token3 >> token_value;
 
1525
                  else
 
1526
                    uiuc_warnings_errors(1, *command_line);
 
1527
 
 
1528
                  CZ_q = token_value;
 
1529
                  CZ_q_clean = CZ_q;
 
1530
                  aeroLiftParts -> storeCommands (*command_line);
 
1531
                  break;
 
1532
                }
 
1533
              case CZ_de_flag:
 
1534
                {
 
1535
                  if (check_float(linetoken3))
 
1536
                    token3 >> token_value;
 
1537
                  else
 
1538
                    uiuc_warnings_errors(1, *command_line);
 
1539
 
 
1540
                  CZ_de = token_value;
 
1541
                  CZ_de_clean = CZ_de;
 
1542
                  aeroLiftParts -> storeCommands (*command_line);
 
1543
                  break;
 
1544
                }
 
1545
              case CZ_deb2_flag:
 
1546
                {
 
1547
                  if (check_float(linetoken3))
 
1548
                    token3 >> token_value;
 
1549
                  else
 
1550
                    uiuc_warnings_errors(1, *command_line);
 
1551
 
 
1552
                  CZ_deb2 = token_value;
 
1553
                  CZ_deb2_clean = CZ_deb2;
 
1554
                  aeroLiftParts -> storeCommands (*command_line);
 
1555
                  break;
 
1556
                }
 
1557
              case CZ_df_flag:
 
1558
                {
 
1559
                  if (check_float(linetoken3))
 
1560
                    token3 >> token_value;
 
1561
                  else
 
1562
                    uiuc_warnings_errors(1, *command_line);
 
1563
 
 
1564
                  CZ_df = token_value;
 
1565
                  CZ_df_clean = CZ_df;
 
1566
                  aeroLiftParts -> storeCommands (*command_line);
 
1567
                  break;
 
1568
                }
 
1569
              case CZ_adf_flag:
 
1570
                {
 
1571
                  if (check_float(linetoken3))
 
1572
                    token3 >> token_value;
 
1573
                  else
 
1574
                    uiuc_warnings_errors(1, *command_line);
 
1575
 
 
1576
                  CZ_adf = token_value;
 
1577
                  CZ_adf_clean = CZ_adf;
 
1578
                  aeroLiftParts -> storeCommands (*command_line);
 
1579
                  break;
 
1580
                }
 
1581
              case CZfa_flag:
 
1582
                {
 
1583
                  CZfa = linetoken3;
 
1584
                  token4 >> token_value_convert1;
 
1585
                  token5 >> token_value_convert2;
 
1586
                  convert_y = uiuc_convert(token_value_convert1);
 
1587
                  convert_x = uiuc_convert(token_value_convert2);
 
1588
                  /* call 1D File Reader with file name (CZfa) and conversion 
 
1589
                     factors; function returns array of alphas (aArray) and 
 
1590
                     corresponding CZ values (CZArray) and max number of 
 
1591
                     terms in arrays (nAlpha) */
 
1592
                  uiuc_1DdataFileReader(CZfa,
 
1593
                                        CZfa_aArray,
 
1594
                                        CZfa_CZArray,
 
1595
                                        CZfa_nAlpha);
 
1596
                  aeroLiftParts -> storeCommands (*command_line);
 
1597
                  break;
 
1598
                }
 
1599
              default:
 
1600
                {
 
1601
                  uiuc_warnings_errors(2, *command_line);
 
1602
                  break;
 
1603
                }
 
1604
              };
 
1605
            break;
 
1606
          } // end CL map
 
1607
 
 
1608
 
 
1609
        case Cm_flag:
 
1610
          {
 
1611
            switch(Cm_map[linetoken2])
 
1612
              {
 
1613
              case Cmo_flag:
 
1614
                {
 
1615
                  if (check_float(linetoken3))
 
1616
                    token3 >> token_value;
 
1617
                  else
 
1618
                    uiuc_warnings_errors(1, *command_line);
 
1619
 
 
1620
                  Cmo = token_value;
 
1621
                  Cmo_clean = Cmo;
 
1622
                  aeroPitchParts -> storeCommands (*command_line);
 
1623
                  break;
 
1624
                }
 
1625
              case Cm_a_flag:
 
1626
                {
 
1627
                  if (check_float(linetoken3))
 
1628
                    token3 >> token_value;
 
1629
                  else
 
1630
                    uiuc_warnings_errors(1, *command_line);
 
1631
 
 
1632
                  Cm_a = token_value;
 
1633
                  Cm_a_clean = Cm_a;
 
1634
                  aeroPitchParts -> storeCommands (*command_line);
 
1635
                  break;
 
1636
                }
 
1637
              case Cm_a2_flag:
 
1638
                {
 
1639
                  if (check_float(linetoken3))
 
1640
                    token3 >> token_value;
 
1641
                  else
 
1642
                    uiuc_warnings_errors(1, *command_line);
 
1643
 
 
1644
                  Cm_a2 = token_value;
 
1645
                  Cm_a2_clean = Cm_a2;
 
1646
                  aeroPitchParts -> storeCommands (*command_line);
 
1647
                  break;
 
1648
                }
 
1649
              case Cm_adot_flag:
 
1650
                {
 
1651
                  if (check_float(linetoken3))
 
1652
                    token3 >> token_value;
 
1653
                  else
 
1654
                    uiuc_warnings_errors(1, *command_line);
 
1655
 
 
1656
                  Cm_adot = token_value;
 
1657
                  Cm_adot_clean = Cm_adot;
 
1658
                  aeroPitchParts -> storeCommands (*command_line);
 
1659
                  break;
 
1660
                }
 
1661
              case Cm_q_flag:
 
1662
                {
 
1663
                  if (check_float(linetoken3))
 
1664
                    token3 >> token_value;
 
1665
                  else
 
1666
                    uiuc_warnings_errors(1, *command_line);
 
1667
 
 
1668
                  Cm_q = token_value;
 
1669
                  Cm_q_clean = Cm_q;
 
1670
                  aeroPitchParts -> storeCommands (*command_line);
 
1671
                  break;
 
1672
                }
 
1673
              case Cm_ih_flag:
 
1674
                {
 
1675
                  if (check_float(linetoken3))
 
1676
                    token3 >> token_value;
 
1677
                  else
 
1678
                    uiuc_warnings_errors(1, *command_line);
 
1679
 
 
1680
                  Cm_ih = token_value;
 
1681
                  aeroPitchParts -> storeCommands (*command_line);
 
1682
                  break;
 
1683
                }
 
1684
              case Cm_de_flag:
 
1685
                {
 
1686
                  if (check_float(linetoken3))
 
1687
                    token3 >> token_value;
 
1688
                  else
 
1689
                    uiuc_warnings_errors(1, *command_line);
 
1690
 
 
1691
                  Cm_de = token_value;
 
1692
                  Cm_de_clean = Cm_de;
 
1693
                  aeroPitchParts -> storeCommands (*command_line);
 
1694
                  break;
 
1695
                }
 
1696
              case Cm_b2_flag:
 
1697
                {
 
1698
                  if (check_float(linetoken3))
 
1699
                    token3 >> token_value;
 
1700
                  else
 
1701
                    uiuc_warnings_errors(1, *command_line);
 
1702
 
 
1703
                  Cm_b2 = token_value;
 
1704
                  Cm_b2_clean = Cm_b2;
 
1705
                  aeroPitchParts -> storeCommands (*command_line);
 
1706
                  break;
 
1707
                }
 
1708
              case Cm_r_flag:
 
1709
                {
 
1710
                  if (check_float(linetoken3))
 
1711
                    token3 >> token_value;
 
1712
                  else
 
1713
                    uiuc_warnings_errors(1, *command_line);
 
1714
 
 
1715
                  Cm_r = token_value;
 
1716
                  Cm_r_clean = Cm_r;
 
1717
                  aeroPitchParts -> storeCommands (*command_line);
 
1718
                  break;
 
1719
                }
 
1720
              case Cm_df_flag:
 
1721
                {
 
1722
                  if (check_float(linetoken3))
 
1723
                    token3 >> token_value;
 
1724
                  else
 
1725
                    uiuc_warnings_errors(1, *command_line);
 
1726
 
 
1727
                  Cm_df = token_value;
 
1728
                  Cm_df_clean = Cm_df;
 
1729
                  aeroPitchParts -> storeCommands (*command_line);
 
1730
                  break;
 
1731
                }
 
1732
              case Cmfa_flag:
 
1733
                {
 
1734
                  Cmfa = linetoken3;
 
1735
                  token4 >> token_value_convert1;
 
1736
                  token5 >> token_value_convert2;
 
1737
                  convert_y = uiuc_convert(token_value_convert1);
 
1738
                  convert_x = uiuc_convert(token_value_convert2);
 
1739
                  /* call 1D File Reader with file name (Cmfa) and conversion 
 
1740
                     factors; function returns array of alphas (aArray) and 
 
1741
                     corresponding Cm values (CmArray) and max number of 
 
1742
                     terms in arrays (nAlpha) */
 
1743
                  uiuc_1DdataFileReader(Cmfa,
 
1744
                                        Cmfa_aArray,
 
1745
                                        Cmfa_CmArray,
 
1746
                                        Cmfa_nAlpha);
 
1747
                  aeroPitchParts -> storeCommands (*command_line);
 
1748
                  break;
 
1749
                }
 
1750
              case Cmfade_flag:
 
1751
                {
 
1752
                  Cmfade = linetoken3;
 
1753
                  token4 >> token_value_convert1;
 
1754
                  token5 >> token_value_convert2;
 
1755
                  token6 >> token_value_convert3;
 
1756
                  convert_z = uiuc_convert(token_value_convert1);
 
1757
                  convert_x = uiuc_convert(token_value_convert2);
 
1758
                  convert_y = uiuc_convert(token_value_convert3);
 
1759
                  /* call 2D File Reader with file name (Cmfade) and 
 
1760
                     conversion factors; function returns array of 
 
1761
                     elevator deflections (deArray) and corresponding 
 
1762
                     alpha (aArray) and delta Cm (CmArray) values and 
 
1763
                     max number of terms in alpha arrays (nAlphaArray) 
 
1764
                     and deflection array (nde) */
 
1765
                  uiuc_2DdataFileReader(Cmfade,
 
1766
                                        Cmfade_aArray,
 
1767
                                        Cmfade_deArray,
 
1768
                                        Cmfade_CmArray,
 
1769
                                        Cmfade_nAlphaArray,
 
1770
                                        Cmfade_nde);
 
1771
                  aeroPitchParts -> storeCommands (*command_line);
 
1772
                  break;
 
1773
                }
 
1774
              case Cmfdf_flag:
 
1775
                {
 
1776
                  Cmfdf = linetoken3;
 
1777
                  token4 >> token_value_convert1;
 
1778
                  token5 >> token_value_convert2;
 
1779
                  convert_y = uiuc_convert(token_value_convert1);
 
1780
                  convert_x = uiuc_convert(token_value_convert2);
 
1781
                  /* call 1D File Reader with file name (Cmfdf) and conversion 
 
1782
                     factors; function returns array of dfs (dfArray) and 
 
1783
                     corresponding Cm values (CmArray) and max number of 
 
1784
                     terms in arrays (ndf) */
 
1785
                  uiuc_1DdataFileReader(Cmfdf,
 
1786
                                        Cmfdf_dfArray,
 
1787
                                        Cmfdf_CmArray,
 
1788
                                        Cmfdf_ndf);
 
1789
                  aeroPitchParts -> storeCommands (*command_line);
 
1790
                  break;
 
1791
                }
 
1792
              case Cmfadf_flag:
 
1793
                {
 
1794
                  Cmfadf = linetoken3;
 
1795
                  token4 >> token_value_convert1;
 
1796
                  token5 >> token_value_convert2;
 
1797
                  token6 >> token_value_convert3;
 
1798
                  convert_z = uiuc_convert(token_value_convert1);
 
1799
                  convert_x = uiuc_convert(token_value_convert2);
 
1800
                  convert_y = uiuc_convert(token_value_convert3);
 
1801
                  /* call 2D File Reader with file name (Cmfadf) and 
 
1802
                     conversion factors; function returns array of 
 
1803
                     flap deflections (dfArray) and corresponding 
 
1804
                     alpha (aArray) and delta Cm (CmArray) values and 
 
1805
                     max number of terms in alpha arrays (nAlphaArray) 
 
1806
                     and deflection array (ndf) */
 
1807
                  uiuc_2DdataFileReader(Cmfadf,
 
1808
                                        Cmfadf_aArray,
 
1809
                                        Cmfadf_dfArray,
 
1810
                                        Cmfadf_CmArray,
 
1811
                                        Cmfadf_nAlphaArray,
 
1812
                                        Cmfadf_ndf);
 
1813
                  aeroPitchParts -> storeCommands (*command_line);
 
1814
                  break;
 
1815
                }
 
1816
              default:
 
1817
                {
 
1818
                  uiuc_warnings_errors(2, *command_line);
 
1819
                  break;
 
1820
                }
 
1821
              };
 
1822
            break;
 
1823
          } // end Cm map
 
1824
 
 
1825
 
 
1826
        case CY_flag:
 
1827
          {
 
1828
            switch(CY_map[linetoken2])
 
1829
              {
 
1830
              case CYo_flag:
 
1831
                {
 
1832
                  if (check_float(linetoken3))
 
1833
                    token3 >> token_value;
 
1834
                  else
 
1835
                    uiuc_warnings_errors(1, *command_line);
 
1836
 
 
1837
                  CYo = token_value;
 
1838
                  CYo_clean = CYo;
 
1839
                  aeroSideforceParts -> storeCommands (*command_line);
 
1840
                  break;
 
1841
                }
 
1842
              case CY_beta_flag:
 
1843
                {
 
1844
                  if (check_float(linetoken3))
 
1845
                    token3 >> token_value;
 
1846
                  else
 
1847
                    uiuc_warnings_errors(1, *command_line);
 
1848
 
 
1849
                  CY_beta = token_value;
 
1850
                  CY_beta_clean = CY_beta;
 
1851
                  aeroSideforceParts -> storeCommands (*command_line);
 
1852
                  break;
 
1853
                }
 
1854
              case CY_p_flag:
 
1855
                {
 
1856
                  if (check_float(linetoken3))
 
1857
                    token3 >> token_value;
 
1858
                  else
 
1859
                    uiuc_warnings_errors(1, *command_line);
 
1860
 
 
1861
                  CY_p = token_value;
 
1862
                  CY_p_clean = CY_p;
 
1863
                  aeroSideforceParts -> storeCommands (*command_line);
 
1864
                  break;
 
1865
                }
 
1866
              case CY_r_flag:
 
1867
                {
 
1868
                  if (check_float(linetoken3))
 
1869
                    token3 >> token_value;
 
1870
                  else
 
1871
                    uiuc_warnings_errors(1, *command_line);
 
1872
 
 
1873
                  CY_r = token_value;
 
1874
                  CY_r_clean = CY_r;
 
1875
                  aeroSideforceParts -> storeCommands (*command_line);
 
1876
                  break;
 
1877
                }
 
1878
              case CY_da_flag:
 
1879
                {
 
1880
                  if (check_float(linetoken3))
 
1881
                    token3 >> token_value;
 
1882
                  else
 
1883
                    uiuc_warnings_errors(1, *command_line);
 
1884
 
 
1885
                  CY_da = token_value;
 
1886
                  CY_da_clean = CY_da;
 
1887
                  aeroSideforceParts -> storeCommands (*command_line);
 
1888
                  break;
 
1889
                }
 
1890
              case CY_dr_flag:
 
1891
                {
 
1892
                  if (check_float(linetoken3))
 
1893
                    token3 >> token_value;
 
1894
                  else
 
1895
                    uiuc_warnings_errors(2, *command_line);
 
1896
 
 
1897
                  CY_dr = token_value;
 
1898
                  CY_dr_clean = CY_dr;
 
1899
                  aeroSideforceParts -> storeCommands (*command_line);
 
1900
                  break;
 
1901
                }
 
1902
              case CY_dra_flag:
 
1903
                {
 
1904
                  if (check_float(linetoken3))
 
1905
                    token3 >> token_value;
 
1906
                  else
 
1907
                    uiuc_warnings_errors(2, *command_line);
 
1908
 
 
1909
                  CY_dra = token_value;
 
1910
                  CY_dra_clean = CY_dra;
 
1911
                  aeroSideforceParts -> storeCommands (*command_line);
 
1912
                  break;
 
1913
                }
 
1914
              case CY_bdot_flag:
 
1915
                {
 
1916
                  if (check_float(linetoken3))
 
1917
                    token3 >> token_value;
 
1918
                  else
 
1919
                    uiuc_warnings_errors(2, *command_line);
 
1920
 
 
1921
                  CY_bdot = token_value;
 
1922
                  CY_bdot_clean = CY_bdot;
 
1923
                  aeroSideforceParts -> storeCommands (*command_line);
 
1924
                  break;
 
1925
                }
 
1926
              case CYfada_flag:
 
1927
                {
 
1928
                  CYfada = linetoken3;
 
1929
                  token4 >> token_value_convert1;
 
1930
                  token5 >> token_value_convert2;
 
1931
                  token6 >> token_value_convert3;
 
1932
                  convert_z = uiuc_convert(token_value_convert1);
 
1933
                  convert_x = uiuc_convert(token_value_convert2);
 
1934
                  convert_y = uiuc_convert(token_value_convert3);
 
1935
                  /* call 2D File Reader with file name (CYfada) and 
 
1936
                     conversion factors; function returns array of 
 
1937
                     aileron deflections (daArray) and corresponding 
 
1938
                     alpha (aArray) and delta CY (CYArray) values and 
 
1939
                     max number of terms in alpha arrays (nAlphaArray) 
 
1940
                     and deflection array (nda) */
 
1941
                  uiuc_2DdataFileReader(CYfada,
 
1942
                                        CYfada_aArray,
 
1943
                                        CYfada_daArray,
 
1944
                                        CYfada_CYArray,
 
1945
                                        CYfada_nAlphaArray,
 
1946
                                        CYfada_nda);
 
1947
                  aeroSideforceParts -> storeCommands (*command_line);
 
1948
                  break;
 
1949
                }
 
1950
              case CYfbetadr_flag:
 
1951
                {
 
1952
                  CYfbetadr = linetoken3;
 
1953
                  token4 >> token_value_convert1;
 
1954
                  token5 >> token_value_convert2;
 
1955
                  token6 >> token_value_convert3;
 
1956
                  convert_z = uiuc_convert(token_value_convert1);
 
1957
                  convert_x = uiuc_convert(token_value_convert2);
 
1958
                  convert_y = uiuc_convert(token_value_convert3);
 
1959
                  /* call 2D File Reader with file name (CYfbetadr) and 
 
1960
                     conversion factors; function returns array of 
 
1961
                     rudder deflections (drArray) and corresponding 
 
1962
                     beta (betaArray) and delta CY (CYArray) values and 
 
1963
                     max number of terms in beta arrays (nBetaArray) 
 
1964
                     and deflection array (ndr) */
 
1965
                  uiuc_2DdataFileReader(CYfbetadr,
 
1966
                                        CYfbetadr_betaArray,
 
1967
                                        CYfbetadr_drArray,
 
1968
                                        CYfbetadr_CYArray,
 
1969
                                        CYfbetadr_nBetaArray,
 
1970
                                        CYfbetadr_ndr);
 
1971
                  aeroSideforceParts -> storeCommands (*command_line);
 
1972
                  break;
 
1973
                }
 
1974
              default:
 
1975
                {
 
1976
                  uiuc_warnings_errors(2, *command_line);
 
1977
                  break;
 
1978
                }
 
1979
              };
 
1980
            break;
 
1981
          } // end CY map
 
1982
 
 
1983
 
 
1984
        case Cl_flag:
 
1985
          {
 
1986
            switch(Cl_map[linetoken2])
 
1987
              {
 
1988
              case Clo_flag:
 
1989
                {
 
1990
                  if (check_float(linetoken3))
 
1991
                    token3 >> token_value;
 
1992
                  else
 
1993
                    uiuc_warnings_errors(1, *command_line);
 
1994
 
 
1995
                  Clo = token_value;
 
1996
                  Clo_clean = Clo;
 
1997
                  aeroRollParts -> storeCommands (*command_line);
 
1998
                  break;
 
1999
                }
 
2000
              case Cl_beta_flag:
 
2001
                {
 
2002
                  if (check_float(linetoken3))
 
2003
                    token3 >> token_value;
 
2004
                  else
 
2005
                    uiuc_warnings_errors(1, *command_line);
 
2006
 
 
2007
                  Cl_beta = token_value;
 
2008
                  Cl_beta_clean = Cl_beta;
 
2009
                  aeroRollParts -> storeCommands (*command_line);
 
2010
                  break;
 
2011
                }
 
2012
              case Cl_p_flag:
 
2013
                {
 
2014
                  if (check_float(linetoken3))
 
2015
                    token3 >> token_value;
 
2016
                  else
 
2017
                    uiuc_warnings_errors(1, *command_line);
 
2018
 
 
2019
                  Cl_p = token_value;
 
2020
                  Cl_p_clean = Cl_p;
 
2021
                  aeroRollParts -> storeCommands (*command_line);
 
2022
                  break;
 
2023
                }
 
2024
              case Cl_r_flag:
 
2025
                {
 
2026
                  if (check_float(linetoken3))
 
2027
                    token3 >> token_value;
 
2028
                  else
 
2029
                    uiuc_warnings_errors(1, *command_line);
 
2030
 
 
2031
                  Cl_r = token_value;
 
2032
                  Cl_r_clean = Cl_r;
 
2033
                  aeroRollParts -> storeCommands (*command_line);
 
2034
                  break;
 
2035
                }
 
2036
              case Cl_da_flag:
 
2037
                {
 
2038
                  if (check_float(linetoken3))
 
2039
                    token3 >> token_value;
 
2040
                  else
 
2041
                    uiuc_warnings_errors(1, *command_line);
 
2042
 
 
2043
                  Cl_da = token_value;
 
2044
                  Cl_da_clean = Cl_da;
 
2045
                  aeroRollParts -> storeCommands (*command_line);
 
2046
                  break;
 
2047
                }
 
2048
              case Cl_dr_flag:
 
2049
                {
 
2050
                  if (check_float(linetoken3))
 
2051
                    token3 >> token_value;
 
2052
                  else
 
2053
                    uiuc_warnings_errors(1, *command_line);
 
2054
 
 
2055
                  Cl_dr = token_value;
 
2056
                  Cl_dr_clean = Cl_dr;
 
2057
                  aeroRollParts -> storeCommands (*command_line);
 
2058
                  break;
 
2059
                }
 
2060
              case Cl_daa_flag:
 
2061
                {
 
2062
                  if (check_float(linetoken3))
 
2063
                    token3 >> token_value;
 
2064
                  else
 
2065
                    uiuc_warnings_errors(1, *command_line);
 
2066
 
 
2067
                  Cl_daa = token_value;
 
2068
                  Cl_daa_clean = Cl_daa;
 
2069
                  aeroRollParts -> storeCommands (*command_line);
 
2070
                  break;
 
2071
                }
 
2072
              case Clfada_flag:
 
2073
                {
 
2074
                  Clfada = linetoken3;
 
2075
                  token4 >> token_value_convert1;
 
2076
                  token5 >> token_value_convert2;
 
2077
                  token6 >> token_value_convert3;
 
2078
                  convert_z = uiuc_convert(token_value_convert1);
 
2079
                  convert_x = uiuc_convert(token_value_convert2);
 
2080
                  convert_y = uiuc_convert(token_value_convert3);
 
2081
                  /* call 2D File Reader with file name (Clfada) and 
 
2082
                     conversion factors; function returns array of 
 
2083
                     aileron deflections (daArray) and corresponding 
 
2084
                     alpha (aArray) and delta Cl (ClArray) values and 
 
2085
                     max number of terms in alpha arrays (nAlphaArray) 
 
2086
                     and deflection array (nda) */
 
2087
                  uiuc_2DdataFileReader(Clfada,
 
2088
                                        Clfada_aArray,
 
2089
                                        Clfada_daArray,
 
2090
                                        Clfada_ClArray,
 
2091
                                        Clfada_nAlphaArray,
 
2092
                                        Clfada_nda);
 
2093
                  aeroRollParts -> storeCommands (*command_line);
 
2094
                  break;
 
2095
                }
 
2096
              case Clfbetadr_flag:
 
2097
                {
 
2098
                  Clfbetadr = linetoken3;
 
2099
                  token4 >> token_value_convert1;
 
2100
                  token5 >> token_value_convert2;
 
2101
                  token6 >> token_value_convert3;
 
2102
                  convert_z = uiuc_convert(token_value_convert1);
 
2103
                  convert_x = uiuc_convert(token_value_convert2);
 
2104
                  convert_y = uiuc_convert(token_value_convert3);
 
2105
                  /* call 2D File Reader with file name (Clfbetadr) and 
 
2106
                     conversion factors; function returns array of 
 
2107
                     rudder deflections (drArray) and corresponding 
 
2108
                     beta (betaArray) and delta Cl (ClArray) values and 
 
2109
                     max number of terms in beta arrays (nBetaArray) 
 
2110
                     and deflection array (ndr) */
 
2111
                  uiuc_2DdataFileReader(Clfbetadr,
 
2112
                                        Clfbetadr_betaArray,
 
2113
                                        Clfbetadr_drArray,
 
2114
                                        Clfbetadr_ClArray,
 
2115
                                        Clfbetadr_nBetaArray,
 
2116
                                        Clfbetadr_ndr);
 
2117
                  aeroRollParts -> storeCommands (*command_line);
 
2118
                  break;
 
2119
                }
 
2120
              default:
 
2121
                {
 
2122
                  uiuc_warnings_errors(2, *command_line);
 
2123
          break;
 
2124
                }
 
2125
              };
 
2126
            break;
 
2127
          } // end Cl map
 
2128
 
 
2129
 
 
2130
        case Cn_flag:
 
2131
          {
 
2132
            switch(Cn_map[linetoken2])
 
2133
              {
 
2134
              case Cno_flag:
 
2135
                {
 
2136
                  if (check_float(linetoken3))
 
2137
                    token3 >> token_value;
 
2138
                  else
 
2139
                    uiuc_warnings_errors(1, *command_line);
 
2140
 
 
2141
                  Cno = token_value;
 
2142
                  Cno_clean = Cno;
 
2143
                  aeroYawParts -> storeCommands (*command_line);
 
2144
                  break;
 
2145
                }
 
2146
              case Cn_beta_flag:
 
2147
                {
 
2148
                  if (check_float(linetoken3))
 
2149
                    token3 >> token_value;
 
2150
                  else
 
2151
                    uiuc_warnings_errors(1, *command_line);
 
2152
 
 
2153
                  Cn_beta = token_value;
 
2154
                  Cn_beta_clean = Cn_beta;
 
2155
                  aeroYawParts -> storeCommands (*command_line);
 
2156
                  break;
 
2157
                }
 
2158
              case Cn_p_flag:
 
2159
                {
 
2160
                  if (check_float(linetoken3))
 
2161
                    token3 >> token_value;
 
2162
                  else
 
2163
                    uiuc_warnings_errors(1, *command_line);
 
2164
 
 
2165
                  Cn_p = token_value;
 
2166
                  Cn_p_clean = Cn_p;
 
2167
                  aeroYawParts -> storeCommands (*command_line);
 
2168
                  break;
 
2169
                }
 
2170
              case Cn_r_flag:
 
2171
                {
 
2172
                  if (check_float(linetoken3))
 
2173
                    token3 >> token_value;
 
2174
                  else
 
2175
                    uiuc_warnings_errors(1, *command_line);
 
2176
 
 
2177
                  Cn_r = token_value;
 
2178
                  Cn_r_clean = Cn_r;
 
2179
                  aeroYawParts -> storeCommands (*command_line);
 
2180
                  break;
 
2181
                }
 
2182
              case Cn_da_flag:
 
2183
                {
 
2184
                  if (check_float(linetoken3))
 
2185
                    token3 >> token_value;
 
2186
                  else
 
2187
                    uiuc_warnings_errors(1, *command_line);
 
2188
 
 
2189
                  Cn_da = token_value;
 
2190
                  Cn_da_clean = Cn_da;
 
2191
                  aeroYawParts -> storeCommands (*command_line);
 
2192
                  break;
 
2193
                }
 
2194
              case Cn_dr_flag:
 
2195
                {
 
2196
                  if (check_float(linetoken3))
 
2197
                    token3 >> token_value;
 
2198
                  else
 
2199
                    uiuc_warnings_errors(1, *command_line);
 
2200
 
 
2201
                  Cn_dr = token_value;
 
2202
                  Cn_dr_clean = Cn_dr;
 
2203
                  aeroYawParts -> storeCommands (*command_line);
 
2204
                  break;
 
2205
                }
 
2206
              case Cn_q_flag:
 
2207
                {
 
2208
                  if (check_float(linetoken3))
 
2209
                    token3 >> token_value;
 
2210
                  else
 
2211
                    uiuc_warnings_errors(1, *command_line);
 
2212
 
 
2213
                  Cn_q = token_value;
 
2214
                  Cn_q_clean = Cn_q;
 
2215
                  aeroYawParts -> storeCommands (*command_line);
 
2216
                  break;
 
2217
                }
 
2218
              case Cn_b3_flag:
 
2219
                {
 
2220
                  if (check_float(linetoken3))
 
2221
                    token3 >> token_value;
 
2222
                  else
 
2223
                    uiuc_warnings_errors(1, *command_line);
 
2224
 
 
2225
                  Cn_b3 = token_value;
 
2226
                  Cn_b3_clean = Cn_b3;
 
2227
                  aeroYawParts -> storeCommands (*command_line);
 
2228
                  break;
 
2229
                }
 
2230
              case Cnfada_flag:
 
2231
                {
 
2232
                  Cnfada = linetoken3;
 
2233
                  token4 >> token_value_convert1;
 
2234
                  token5 >> token_value_convert2;
 
2235
                  token6 >> token_value_convert3;
 
2236
                  convert_z = uiuc_convert(token_value_convert1);
 
2237
                  convert_x = uiuc_convert(token_value_convert2);
 
2238
                  convert_y = uiuc_convert(token_value_convert3);
 
2239
                  /* call 2D File Reader with file name (Cnfada) and 
 
2240
                     conversion factors; function returns array of 
 
2241
                     aileron deflections (daArray) and corresponding 
 
2242
                     alpha (aArray) and delta Cn (CnArray) values and 
 
2243
                     max number of terms in alpha arrays (nAlphaArray) 
 
2244
                     and deflection array (nda) */
 
2245
                  uiuc_2DdataFileReader(Cnfada,
 
2246
                                        Cnfada_aArray,
 
2247
                                        Cnfada_daArray,
 
2248
                                        Cnfada_CnArray,
 
2249
                                        Cnfada_nAlphaArray,
 
2250
                                        Cnfada_nda);
 
2251
                  aeroYawParts -> storeCommands (*command_line);
 
2252
                  break;
 
2253
                }
 
2254
              case Cnfbetadr_flag:
 
2255
                {
 
2256
                  Cnfbetadr = linetoken3;
 
2257
                  token4 >> token_value_convert1;
 
2258
                  token5 >> token_value_convert2;
 
2259
                  token6 >> token_value_convert3;
 
2260
                  convert_z = uiuc_convert(token_value_convert1);
 
2261
                  convert_x = uiuc_convert(token_value_convert2);
 
2262
                  convert_y = uiuc_convert(token_value_convert3);
 
2263
                  /* call 2D File Reader with file name (Cnfbetadr) and 
 
2264
                     conversion factors; function returns array of 
 
2265
                     rudder deflections (drArray) and corresponding 
 
2266
                     beta (betaArray) and delta Cn (CnArray) values and 
 
2267
                     max number of terms in beta arrays (nBetaArray) 
 
2268
                     and deflection array (ndr) */
 
2269
                  uiuc_2DdataFileReader(Cnfbetadr,
 
2270
                                        Cnfbetadr_betaArray,
 
2271
                                        Cnfbetadr_drArray,
 
2272
                                        Cnfbetadr_CnArray,
 
2273
                                        Cnfbetadr_nBetaArray,
 
2274
                                        Cnfbetadr_ndr);
 
2275
                  aeroYawParts -> storeCommands (*command_line);
 
2276
                  break;
 
2277
                }
 
2278
              default:
 
2279
                {
 
2280
                  uiuc_warnings_errors(2, *command_line);
 
2281
                  break;
 
2282
                }
 
2283
              };
 
2284
            break;
 
2285
          } // end Cn map
 
2286
          
 
2287
        
 
2288
        case gear_flag:
 
2289
          {
 
2290
            int index;
 
2291
            token3 >> index;
 
2292
            if (index < 0 || index >= 16)
 
2293
              uiuc_warnings_errors(1, *command_line);
 
2294
            switch(gear_map[linetoken2])
 
2295
              {
 
2296
              case Dx_gear_flag:
 
2297
                {
 
2298
                  if (check_float(linetoken3))
 
2299
                    token4 >> token_value;
 
2300
                  else
 
2301
                    uiuc_warnings_errors(1, *command_line);
 
2302
                  D_gear_v[index][0] = token_value;
 
2303
                  gear_model[index] = true;
 
2304
                  break;
 
2305
                }
 
2306
              case Dy_gear_flag:
 
2307
                {
 
2308
                  if (check_float(linetoken3))
 
2309
                    token4 >> token_value;
 
2310
                  else
 
2311
                    uiuc_warnings_errors(1, *command_line);
 
2312
                  D_gear_v[index][1] = token_value;
 
2313
                  gear_model[index] = true;
 
2314
                  break;
 
2315
                }
 
2316
              case Dz_gear_flag:
 
2317
                {
 
2318
                  if (check_float(linetoken3))
 
2319
                    token4 >> token_value;
 
2320
                  else
 
2321
                    uiuc_warnings_errors(1, *command_line);
 
2322
                  D_gear_v[index][2] = token_value;
 
2323
                  gear_model[index] = true;
 
2324
                  break;
 
2325
                }
 
2326
              case cgear_flag:
 
2327
                {
 
2328
                  if (check_float(linetoken3))
 
2329
                    token4 >> token_value;
 
2330
                  else
 
2331
                    uiuc_warnings_errors(1, *command_line);
 
2332
                  cgear[index] = token_value;
 
2333
                  gear_model[index] = true;
 
2334
                  break;
 
2335
                }
 
2336
              case kgear_flag:
 
2337
                {
 
2338
                  if (check_float(linetoken3))
 
2339
                    token4 >> token_value;
 
2340
                  else
 
2341
                    uiuc_warnings_errors(1, *command_line);
 
2342
                  kgear[index] = token_value;
 
2343
                  gear_model[index] = true;
 
2344
                  break;
 
2345
                }
 
2346
              case muGear_flag:
 
2347
                {
 
2348
                  if (check_float(linetoken3))
 
2349
                    token4 >> token_value;
 
2350
                  else
 
2351
                    uiuc_warnings_errors(1, *command_line);
 
2352
                  muGear[index] = token_value;
 
2353
                  gear_model[index] = true;
 
2354
                  break;
 
2355
                }
 
2356
              case strutLength_flag:
 
2357
                {
 
2358
                  if (check_float(linetoken3))
 
2359
                    token4 >> token_value;
 
2360
                  else
 
2361
                    uiuc_warnings_errors(1, *command_line);
 
2362
                  strutLength[index] = token_value;
 
2363
                  gear_model[index] = true;
 
2364
                  break;
 
2365
                }
 
2366
              default:
 
2367
                {
 
2368
                  uiuc_warnings_errors(2, *command_line);
 
2369
                  break;
 
2370
                }
 
2371
              };
 
2372
            break;
 
2373
          } // end gear map
 
2374
      
 
2375
 
 
2376
        case ice_flag:
 
2377
          {
 
2378
            switch(ice_map[linetoken2])
 
2379
              {
 
2380
              case iceTime_flag:
 
2381
                {
 
2382
                  if (check_float(linetoken3))
 
2383
                    token3 >> token_value;
 
2384
 
 
2385
                  else
 
2386
                    uiuc_warnings_errors(1, *command_line);
 
2387
 
 
2388
                  ice_model = true;
 
2389
                  iceTime = token_value;
 
2390
                  break;
 
2391
                }
 
2392
              case transientTime_flag:
 
2393
                {
 
2394
                  if (check_float(linetoken3))
 
2395
                    token3 >> token_value;
 
2396
                  else
 
2397
                    uiuc_warnings_errors(1, *command_line);
 
2398
 
 
2399
                  transientTime = token_value;
 
2400
                  break;
 
2401
                }
 
2402
              case eta_ice_final_flag:
 
2403
                {
 
2404
                  if (check_float(linetoken3))
 
2405
                    token3 >> token_value;
 
2406
                  else
 
2407
                    uiuc_warnings_errors(1, *command_line);
 
2408
 
 
2409
                  eta_ice_final = token_value;
 
2410
                  break;
 
2411
                }
 
2412
              case beta_probe_wing_flag:
 
2413
                {
 
2414
                  if (check_float(linetoken3))
 
2415
                    token3 >> token_value;
 
2416
                  else
 
2417
                    uiuc_warnings_errors(1, *command_line);
 
2418
 
 
2419
                  beta_model = true;
 
2420
                  x_probe_wing = token_value;
 
2421
                  break;
 
2422
                }
 
2423
              case beta_probe_tail_flag:
 
2424
                {
 
2425
                  if (check_float(linetoken3))
 
2426
                    token3 >> token_value;
 
2427
                  else
 
2428
                    uiuc_warnings_errors(1, *command_line);
 
2429
 
 
2430
                  beta_model = true;
 
2431
                  x_probe_tail = token_value;
 
2432
                  break;
 
2433
                }
 
2434
              case kCDo_flag:
 
2435
                {
 
2436
                  if (check_float(linetoken3))
 
2437
                    token3 >> token_value;
 
2438
                  else
 
2439
                    uiuc_warnings_errors(1, *command_line);
 
2440
                  
 
2441
                  kCDo = token_value;
 
2442
                  break;
 
2443
                }
 
2444
              case kCDK_flag:
 
2445
                {
 
2446
                  if (check_float(linetoken3))
 
2447
                    token3 >> token_value;
 
2448
                  else
 
2449
                    uiuc_warnings_errors(1, *command_line);
 
2450
                  
 
2451
                  kCDK = token_value;
 
2452
                  break;
 
2453
                }
 
2454
              case kCD_a_flag:
 
2455
                {
 
2456
                  if (check_float(linetoken3))
 
2457
                    token3 >> token_value;
 
2458
                  else
 
2459
                    uiuc_warnings_errors(1, *command_line);
 
2460
                  
 
2461
                  kCD_a = token_value;
 
2462
                  break;
 
2463
                }
 
2464
              case kCD_adot_flag:
 
2465
                {
 
2466
                  if (check_float(linetoken3))
 
2467
                    token3 >> token_value;
 
2468
                  else
 
2469
                    uiuc_warnings_errors(1, *command_line);
 
2470
                  
 
2471
                  kCD_adot = token_value;
 
2472
                  break;
 
2473
                }
 
2474
              case kCD_q_flag:
 
2475
                {
 
2476
                  if (check_float(linetoken3))
 
2477
                    token3 >> token_value;
 
2478
                  else
 
2479
                    uiuc_warnings_errors(1, *command_line);
 
2480
                  
 
2481
                  kCD_q = token_value;
 
2482
                  break;
 
2483
                }
 
2484
              case kCD_de_flag:
 
2485
                {
 
2486
                  if (check_float(linetoken3))
 
2487
                    token3 >> token_value;
 
2488
                  else
 
2489
                    uiuc_warnings_errors(1, *command_line);
 
2490
                  
 
2491
                  kCD_de = token_value;
 
2492
                  break;
 
2493
                }
 
2494
              case kCXo_flag:
 
2495
                {
 
2496
                  if (check_float(linetoken3))
 
2497
                    token3 >> token_value;
 
2498
                  else
 
2499
                    uiuc_warnings_errors(1, *command_line);
 
2500
                  
 
2501
                  kCXo = token_value;
 
2502
                  break;
 
2503
                }
 
2504
              case kCXK_flag:
 
2505
                {
 
2506
                  if (check_float(linetoken3))
 
2507
                    token3 >> token_value;
 
2508
                  else
 
2509
                    uiuc_warnings_errors(1, *command_line);
 
2510
                  
 
2511
                  kCXK = token_value;
 
2512
                  break;
 
2513
                }
 
2514
              case kCX_a_flag:
 
2515
                {
 
2516
                  if (check_float(linetoken3))
 
2517
                    token3 >> token_value;
 
2518
                  else
 
2519
                    uiuc_warnings_errors(1, *command_line);
 
2520
                  
 
2521
                  kCX_a = token_value;
 
2522
                  break;
 
2523
                }
 
2524
              case kCX_a2_flag:
 
2525
                {
 
2526
                  if (check_float(linetoken3))
 
2527
                    token3 >> token_value;
 
2528
                  else
 
2529
                    uiuc_warnings_errors(1, *command_line);
 
2530
                  
 
2531
                  kCX_a2 = token_value;
 
2532
                  break;
 
2533
                }
 
2534
              case kCX_a3_flag:
 
2535
                {
 
2536
                  if (check_float(linetoken3))
 
2537
                    token3 >> token_value;
 
2538
                  else
 
2539
                    uiuc_warnings_errors(1, *command_line);
 
2540
                  
 
2541
                  kCX_a3 = token_value;
 
2542
                  break;
 
2543
                }
 
2544
              case kCX_adot_flag:
 
2545
                {
 
2546
                  if (check_float(linetoken3))
 
2547
                    token3 >> token_value;
 
2548
                  else
 
2549
                    uiuc_warnings_errors(1, *command_line);
 
2550
                  
 
2551
                  kCX_adot = token_value;
 
2552
                  break;
 
2553
                }
 
2554
              case kCX_q_flag:
 
2555
                {
 
2556
                  if (check_float(linetoken3))
 
2557
                    token3 >> token_value;
 
2558
                  else
 
2559
                    uiuc_warnings_errors(1, *command_line);
 
2560
                  
 
2561
                  kCX_q = token_value;
 
2562
                  break;
 
2563
                }
 
2564
              case kCX_de_flag:
 
2565
                {
 
2566
                  if (check_float(linetoken3))
 
2567
                    token3 >> token_value;
 
2568
                  else
 
2569
                    uiuc_warnings_errors(1, *command_line);
 
2570
                  
 
2571
                  kCX_de = token_value;
 
2572
                  break;
 
2573
                }
 
2574
              case kCX_dr_flag:
 
2575
                {
 
2576
                  if (check_float(linetoken3))
 
2577
                    token3 >> token_value;
 
2578
                  else
 
2579
                    uiuc_warnings_errors(1, *command_line);
 
2580
                  
 
2581
                  kCX_dr = token_value;
 
2582
                  break;
 
2583
                }
 
2584
              case kCX_df_flag:
 
2585
                {
 
2586
                  if (check_float(linetoken3))
 
2587
                    token3 >> token_value;
 
2588
                  else
 
2589
                    uiuc_warnings_errors(1, *command_line);
 
2590
                  
 
2591
                  kCX_df = token_value;
 
2592
                  break;
 
2593
                }
 
2594
              case kCX_adf_flag:
 
2595
                {
 
2596
                  if (check_float(linetoken3))
 
2597
                    token3 >> token_value;
 
2598
                  else
 
2599
                    uiuc_warnings_errors(1, *command_line);
 
2600
                  
 
2601
                  kCX_adf = token_value;
 
2602
                  break;
 
2603
                }
 
2604
              case kCLo_flag:
 
2605
                {
 
2606
                  if (check_float(linetoken3))
 
2607
                    token3 >> token_value;
 
2608
                  else
 
2609
                    uiuc_warnings_errors(1, *command_line);
 
2610
                  
 
2611
                  kCLo = token_value;
 
2612
                  break;
 
2613
                }
 
2614
              case kCL_a_flag:
 
2615
                {
 
2616
                  if (check_float(linetoken3))
 
2617
                    token3 >> token_value;
 
2618
                  else
 
2619
                    uiuc_warnings_errors(1, *command_line);
 
2620
                  
 
2621
                  kCL_a = token_value;
 
2622
                  break;
 
2623
                }
 
2624
              case kCL_adot_flag:
 
2625
                {
 
2626
                  if (check_float(linetoken3))
 
2627
                    token3 >> token_value;
 
2628
                  else
 
2629
                    uiuc_warnings_errors(1, *command_line);
 
2630
 
 
2631
                  kCL_adot = token_value;
 
2632
                  break;
 
2633
                }
 
2634
              case kCL_q_flag:
 
2635
                {
 
2636
                  if (check_float(linetoken3))
 
2637
                    token3 >> token_value;
 
2638
                  else
 
2639
                    uiuc_warnings_errors(1, *command_line);
 
2640
 
 
2641
                  kCL_q = token_value;
 
2642
                  break;
 
2643
                }
 
2644
              case kCL_de_flag:
 
2645
                {
 
2646
                  if (check_float(linetoken3))
 
2647
                    token3 >> token_value;
 
2648
                  else
 
2649
                    uiuc_warnings_errors(1, *command_line);
 
2650
 
 
2651
                  kCL_de = token_value;
 
2652
                  break;
 
2653
                }
 
2654
              case kCZo_flag:
 
2655
                {
 
2656
                  if (check_float(linetoken3))
 
2657
                    token3 >> token_value;
 
2658
                  else
 
2659
                    uiuc_warnings_errors(1, *command_line);
 
2660
                  
 
2661
                  kCZo = token_value;
 
2662
                  break;
 
2663
                }
 
2664
              case kCZ_a_flag:
 
2665
                {
 
2666
                  if (check_float(linetoken3))
 
2667
                    token3 >> token_value;
 
2668
                  else
 
2669
                    uiuc_warnings_errors(1, *command_line);
 
2670
                  
 
2671
                  kCZ_a = token_value;
 
2672
                  break;
 
2673
                }
 
2674
              case kCZ_a2_flag:
 
2675
                {
 
2676
                  if (check_float(linetoken3))
 
2677
                    token3 >> token_value;
 
2678
                  else
 
2679
                    uiuc_warnings_errors(1, *command_line);
 
2680
                  
 
2681
                  kCZ_a2 = token_value;
 
2682
                  break;
 
2683
                }
 
2684
              case kCZ_a3_flag:
 
2685
                {
 
2686
                  if (check_float(linetoken3))
 
2687
                    token3 >> token_value;
 
2688
                  else
 
2689
                    uiuc_warnings_errors(1, *command_line);
 
2690
                  
 
2691
                  kCZ_a3 = token_value;
 
2692
                  break;
 
2693
                }
 
2694
              case kCZ_adot_flag:
 
2695
                {
 
2696
                  if (check_float(linetoken3))
 
2697
                    token3 >> token_value;
 
2698
                  else
 
2699
                    uiuc_warnings_errors(1, *command_line);
 
2700
 
 
2701
                  kCZ_adot = token_value;
 
2702
                  break;
 
2703
                }
 
2704
              case kCZ_q_flag:
 
2705
                {
 
2706
                  if (check_float(linetoken3))
 
2707
                    token3 >> token_value;
 
2708
                  else
 
2709
                    uiuc_warnings_errors(1, *command_line);
 
2710
 
 
2711
                  kCZ_q = token_value;
 
2712
                  break;
 
2713
                }
 
2714
              case kCZ_de_flag:
 
2715
                {
 
2716
                  if (check_float(linetoken3))
 
2717
                    token3 >> token_value;
 
2718
                  else
 
2719
                    uiuc_warnings_errors(1, *command_line);
 
2720
 
 
2721
                  kCZ_de = token_value;
 
2722
                  break;
 
2723
                }
 
2724
              case kCZ_deb2_flag:
 
2725
                {
 
2726
                  if (check_float(linetoken3))
 
2727
                    token3 >> token_value;
 
2728
                  else
 
2729
                    uiuc_warnings_errors(1, *command_line);
 
2730
                  
 
2731
                  kCZ_deb2 = token_value;
 
2732
                  break;
 
2733
                }
 
2734
              case kCZ_df_flag:
 
2735
                {
 
2736
                  if (check_float(linetoken3))
 
2737
                    token3 >> token_value;
 
2738
                  else
 
2739
                    uiuc_warnings_errors(1, *command_line);
 
2740
                  
 
2741
                  kCZ_df = token_value;
 
2742
                  break;
 
2743
                }
 
2744
              case kCZ_adf_flag:
 
2745
                {
 
2746
                  if (check_float(linetoken3))
 
2747
                    token3 >> token_value;
 
2748
                  else
 
2749
                    uiuc_warnings_errors(1, *command_line);
 
2750
                  
 
2751
                  kCZ_adf = token_value;
 
2752
                  break;
 
2753
                }
 
2754
              case kCmo_flag:
 
2755
                {
 
2756
                  if (check_float(linetoken3))
 
2757
                    token3 >> token_value;
 
2758
                  else
 
2759
                    uiuc_warnings_errors(1, *command_line);
 
2760
 
 
2761
                  kCmo = token_value;
 
2762
                  break;
 
2763
                }
 
2764
              case kCm_a_flag:
 
2765
                {
 
2766
                  if (check_float(linetoken3))
 
2767
                    token3 >> token_value;
 
2768
                  else
 
2769
                    uiuc_warnings_errors(1, *command_line);
 
2770
 
 
2771
                  kCm_a = token_value;
 
2772
                  break;
 
2773
                }
 
2774
              case kCm_a2_flag:
 
2775
                {
 
2776
                  if (check_float(linetoken3))
 
2777
                    token3 >> token_value;
 
2778
                  else
 
2779
                    uiuc_warnings_errors(1, *command_line);
 
2780
 
 
2781
                  kCm_a2 = token_value;
 
2782
                  break;
 
2783
                }
 
2784
              case kCm_adot_flag:
 
2785
                {
 
2786
                  if (check_float(linetoken3))
 
2787
                    token3 >> token_value;
 
2788
                  else
 
2789
                    uiuc_warnings_errors(1, *command_line);
 
2790
 
 
2791
                  kCm_adot = token_value;
 
2792
                  break;
 
2793
                }
 
2794
              case kCm_q_flag:
 
2795
                {
 
2796
                  if (check_float(linetoken3))
 
2797
                    token3 >> token_value;
 
2798
                  else
 
2799
                    uiuc_warnings_errors(1, *command_line);
 
2800
 
 
2801
                  kCm_q = token_value;
 
2802
                  break;
 
2803
                }
 
2804
              case kCm_de_flag:
 
2805
                {
 
2806
                  if (check_float(linetoken3))
 
2807
                    token3 >> token_value;
 
2808
                  else
 
2809
                    uiuc_warnings_errors(1, *command_line);
 
2810
 
 
2811
                  kCm_de = token_value;
 
2812
                  break;
 
2813
                }
 
2814
              case kCm_b2_flag:
 
2815
                {
 
2816
                  if (check_float(linetoken3))
 
2817
                    token3 >> token_value;
 
2818
                  else
 
2819
                    uiuc_warnings_errors(1, *command_line);
 
2820
 
 
2821
                  kCm_b2 = token_value;
 
2822
                  break;
 
2823
                }
 
2824
              case kCm_r_flag:
 
2825
                {
 
2826
                  if (check_float(linetoken3))
 
2827
                    token3 >> token_value;
 
2828
                  else
 
2829
                    uiuc_warnings_errors(1, *command_line);
 
2830
 
 
2831
                  kCm_r = token_value;
 
2832
                  break;
 
2833
                }
 
2834
              case kCm_df_flag:
 
2835
                {
 
2836
                  if (check_float(linetoken3))
 
2837
                    token3 >> token_value;
 
2838
                  else
 
2839
                    uiuc_warnings_errors(1, *command_line);
 
2840
 
 
2841
                  kCm_df = token_value;
 
2842
                  break;
 
2843
                }
 
2844
              case kCYo_flag:
 
2845
                {
 
2846
                  if (check_float(linetoken3))
 
2847
                    token3 >> token_value;
 
2848
                  else
 
2849
                    uiuc_warnings_errors(1, *command_line);
 
2850
 
 
2851
                  kCYo = token_value;
 
2852
                  break;
 
2853
                }
 
2854
              case kCY_beta_flag:
 
2855
                {
 
2856
                  if (check_float(linetoken3))
 
2857
                    token3 >> token_value;
 
2858
                  else
 
2859
                    uiuc_warnings_errors(1, *command_line);
 
2860
 
 
2861
                  kCY_beta = token_value;
 
2862
                  break;
 
2863
                }
 
2864
              case kCY_p_flag:
 
2865
                {
 
2866
                  if (check_float(linetoken3))
 
2867
                    token3 >> token_value;
 
2868
                  else
 
2869
                    uiuc_warnings_errors(1, *command_line);
 
2870
 
 
2871
                  kCY_p = token_value;
 
2872
                  break;
 
2873
                }
 
2874
              case kCY_r_flag:
 
2875
                {
 
2876
                  if (check_float(linetoken3))
 
2877
                    token3 >> token_value;
 
2878
                  else
 
2879
                    uiuc_warnings_errors(1, *command_line);
 
2880
 
 
2881
                  kCY_r = token_value;
 
2882
                  break;
 
2883
                }
 
2884
              case kCY_da_flag:
 
2885
                {
 
2886
                  if (check_float(linetoken3))
 
2887
                    token3 >> token_value;
 
2888
                  else
 
2889
                    uiuc_warnings_errors(1, *command_line);
 
2890
 
 
2891
                  kCY_da = token_value;
 
2892
                  break;
 
2893
                }
 
2894
              case kCY_dr_flag:
 
2895
                {
 
2896
                  if (check_float(linetoken3))
 
2897
                    token3 >> token_value;
 
2898
                  else
 
2899
                    uiuc_warnings_errors(1, *command_line);
 
2900
 
 
2901
                  kCY_dr = token_value;
 
2902
                  break;
 
2903
                }
 
2904
              case kCY_dra_flag:
 
2905
                {
 
2906
                  if (check_float(linetoken3))
 
2907
                    token3 >> token_value;
 
2908
                  else
 
2909
                    uiuc_warnings_errors(1, *command_line);
 
2910
 
 
2911
                  kCY_dra = token_value;
 
2912
                  break;
 
2913
                }
 
2914
              case kCY_bdot_flag:
 
2915
                {
 
2916
                  if (check_float(linetoken3))
 
2917
                    token3 >> token_value;
 
2918
                  else
 
2919
                    uiuc_warnings_errors(1, *command_line);
 
2920
 
 
2921
                  kCY_bdot = token_value;
 
2922
                  break;
 
2923
                }
 
2924
              case kClo_flag:
 
2925
                {
 
2926
                  if (check_float(linetoken3))
 
2927
                    token3 >> token_value;
 
2928
                  else
 
2929
                    uiuc_warnings_errors(1, *command_line);
 
2930
 
 
2931
                  kClo = token_value;
 
2932
                  break;
 
2933
                }
 
2934
              case kCl_beta_flag:
 
2935
                {
 
2936
                  if (check_float(linetoken3))
 
2937
                    token3 >> token_value;
 
2938
                  else
 
2939
                    uiuc_warnings_errors(1, *command_line);
 
2940
 
 
2941
                  kCl_beta = token_value;
 
2942
                  break;
 
2943
                }
 
2944
              case kCl_p_flag:
 
2945
                {
 
2946
                  if (check_float(linetoken3))
 
2947
                    token3 >> token_value;
 
2948
                  else
 
2949
                    uiuc_warnings_errors(1, *command_line);
 
2950
 
 
2951
                  kCl_p = token_value;
 
2952
                  break;
 
2953
                }
 
2954
              case kCl_r_flag:
 
2955
                {
 
2956
                  if (check_float(linetoken3))
 
2957
                    token3 >> token_value;
 
2958
                  else
 
2959
                    uiuc_warnings_errors(1, *command_line);
 
2960
 
 
2961
                  kCl_r = token_value;
 
2962
                  break;
 
2963
                }
 
2964
              case kCl_da_flag:
 
2965
                {
 
2966
                  if (check_float(linetoken3))
 
2967
                    token3 >> token_value;
 
2968
                  else
 
2969
                    uiuc_warnings_errors(1, *command_line);
 
2970
 
 
2971
                  kCl_da = token_value;
 
2972
                  break;
 
2973
                }
 
2974
              case kCl_dr_flag:
 
2975
                {
 
2976
                  if (check_float(linetoken3))
 
2977
                    token3 >> token_value;
 
2978
                  else
 
2979
                    uiuc_warnings_errors(1, *command_line);
 
2980
 
 
2981
                  kCl_dr = token_value;
 
2982
                  break;
 
2983
                }
 
2984
              case kCl_daa_flag:
 
2985
                {
 
2986
                  if (check_float(linetoken3))
 
2987
                    token3 >> token_value;
 
2988
                  else
 
2989
                    uiuc_warnings_errors(1, *command_line);
 
2990
 
 
2991
                  kCl_daa = token_value;
 
2992
                  break;
 
2993
                }
 
2994
              case kCno_flag:
 
2995
                {
 
2996
                  if (check_float(linetoken3))
 
2997
                    token3 >> token_value;
 
2998
                  else
 
2999
                    uiuc_warnings_errors(1, *command_line);
 
3000
 
 
3001
                  kCno = token_value;
 
3002
                  break;
 
3003
                }
 
3004
              case kCn_beta_flag:
 
3005
                {
 
3006
                  if (check_float(linetoken3))
 
3007
                    token3 >> token_value;
 
3008
                  else
 
3009
                    uiuc_warnings_errors(1, *command_line);
 
3010
 
 
3011
                  kCn_beta = token_value;
 
3012
                  break;
 
3013
                }
 
3014
              case kCn_p_flag:
 
3015
                {
 
3016
                  if (check_float(linetoken3))
 
3017
                    token3 >> token_value;
 
3018
                  else
 
3019
                    uiuc_warnings_errors(1, *command_line);
 
3020
 
 
3021
                  kCn_p = token_value;
 
3022
                  break;
 
3023
                }
 
3024
              case kCn_r_flag:
 
3025
                {
 
3026
                  if (check_float(linetoken3))
 
3027
                    token3 >> token_value;
 
3028
                  else
 
3029
                    uiuc_warnings_errors(1, *command_line);
 
3030
 
 
3031
                  kCn_r = token_value;
 
3032
                  break;
 
3033
                }
 
3034
              case kCn_da_flag:
 
3035
                {
 
3036
                  if (check_float(linetoken3))
 
3037
                    token3 >> token_value;
 
3038
                  else
 
3039
                    uiuc_warnings_errors(1, *command_line);
 
3040
 
 
3041
                  kCn_da = token_value;
 
3042
                  break;
 
3043
                }
 
3044
              case kCn_dr_flag:
 
3045
                {
 
3046
                  if (check_float(linetoken3))
 
3047
                    token3 >> token_value;
 
3048
                  else
 
3049
                    uiuc_warnings_errors(1, *command_line);
 
3050
 
 
3051
                  kCn_dr = token_value;
 
3052
                  break;
 
3053
                }
 
3054
              case kCn_q_flag:
 
3055
                {
 
3056
                  if (check_float(linetoken3))
 
3057
                    token3 >> token_value;
 
3058
                  else
 
3059
                    uiuc_warnings_errors(1, *command_line);
 
3060
 
 
3061
                  kCn_q = token_value;
 
3062
                  break;
 
3063
                }
 
3064
              case kCn_b3_flag:
 
3065
                {
 
3066
                  if (check_float(linetoken3))
 
3067
                    token3 >> token_value;
 
3068
                  else
 
3069
                    uiuc_warnings_errors(1, *command_line);
 
3070
 
 
3071
                  kCn_b3 = token_value;
 
3072
                  break;
 
3073
                }
 
3074
              default:
 
3075
                {
 
3076
                  uiuc_warnings_errors(2, *command_line);
 
3077
                  break;
 
3078
                }
 
3079
              };
 
3080
            break;
 
3081
          } // end ice map
 
3082
         
 
3083
 
 
3084
        case fog_flag:
 
3085
          {
 
3086
            switch(fog_map[linetoken2])
 
3087
              {
 
3088
              case fog_segments_flag:
 
3089
                {
 
3090
                  if (check_float(linetoken3))
 
3091
                    token3 >> token_value_convert1;
 
3092
                  else
 
3093
                    uiuc_warnings_errors(1, *command_line);
 
3094
 
 
3095
                  if (token_value_convert1 < 1 || token_value_convert1 > 100)
 
3096
                    uiuc_warnings_errors(1, *command_line);
 
3097
                  
 
3098
                  fog_field = true;
 
3099
                  fog_point_index = 0;
 
3100
                  delete[] fog_time;
 
3101
                  delete[] fog_value;
 
3102
                  fog_segments = token_value_convert1;
 
3103
                  fog_time = new double[fog_segments+1];
 
3104
                  fog_time[0] = 0.0;
 
3105
                  fog_value = new int[fog_segments+1];
 
3106
                  fog_value[0] = 0;
 
3107
                  
 
3108
                  break;
 
3109
                }
 
3110
              case fog_point_flag:
 
3111
                {
 
3112
                  if (check_float(linetoken3))
 
3113
                    token3 >> token_value;
 
3114
                  else
 
3115
                    uiuc_warnings_errors(1, *command_line);
 
3116
 
 
3117
                  if (token_value < 0.1)
 
3118
                    uiuc_warnings_errors(1, *command_line);
 
3119
 
 
3120
                  if (check_float(linetoken4))
 
3121
                    token4 >> token_value_convert1;
 
3122
                  else
 
3123
                    uiuc_warnings_errors(1, *command_line);
 
3124
 
 
3125
                  if (token_value_convert1 < -1000 || token_value_convert1 > 1000)
 
3126
                    uiuc_warnings_errors(1, *command_line);
 
3127
 
 
3128
                  if (fog_point_index == fog_segments || fog_point_index == -1)
 
3129
                    uiuc_warnings_errors(1, *command_line);
 
3130
 
 
3131
                  fog_point_index++;
 
3132
                  fog_time[fog_point_index] = token_value;
 
3133
                  fog_value[fog_point_index] = token_value_convert1;
 
3134
 
 
3135
                  break;
 
3136
                }
 
3137
              default:
 
3138
                {
 
3139
                  uiuc_warnings_errors(2, *command_line);
 
3140
                  break;
 
3141
                }
 
3142
              };
 
3143
            break;
 
3144
          } // end fog map        
 
3145
          
 
3146
 
 
3147
 
 
3148
 
 
3149
          
 
3150
 
 
3151
        case record_flag:
 
3152
          {
 
3153
            static int fout_flag=0;
 
3154
            if (fout_flag==0)
 
3155
            {
 
3156
              fout_flag=-1;
 
3157
              fout.open("uiuc_record.dat");
 
3158
            }
 
3159
            switch(record_map[linetoken2])
 
3160
              {
 
3161
                /************************* Time ************************/
 
3162
              case Simtime_record:
 
3163
                {
 
3164
                  recordParts -> storeCommands (*command_line);
 
3165
                  break;
 
3166
                }
 
3167
              case dt_record:
 
3168
                {
 
3169
                  recordParts -> storeCommands (*command_line);
 
3170
                  break;
 
3171
                }
 
3172
 
 
3173
                /************************* Mass ************************/
 
3174
              case Weight_record:
 
3175
                {
 
3176
                  recordParts -> storeCommands (*command_line);
 
3177
                  break;
 
3178
                }
 
3179
              case Mass_record:
 
3180
                {
 
3181
                  recordParts -> storeCommands (*command_line);
 
3182
                  break;
 
3183
                }
 
3184
              case I_xx_record:
 
3185
                {
 
3186
                  recordParts -> storeCommands (*command_line);
 
3187
                  break;
 
3188
                }
 
3189
              case I_yy_record:
 
3190
                {
 
3191
                  recordParts -> storeCommands (*command_line);
 
3192
                  break;
 
3193
                }
 
3194
              case I_zz_record:
 
3195
                {
 
3196
                  recordParts -> storeCommands (*command_line);
 
3197
                  break;
 
3198
                }
 
3199
              case I_xz_record:
 
3200
                {
 
3201
                  recordParts -> storeCommands (*command_line);
 
3202
                  break;
 
3203
                }
 
3204
 
 
3205
                /*********************** Geometry **********************/
 
3206
              case Dx_pilot_record:
 
3207
                {
 
3208
                  recordParts -> storeCommands (*command_line);
 
3209
                  break;
 
3210
                }
 
3211
              case Dy_pilot_record:
 
3212
                {
 
3213
                  recordParts -> storeCommands (*command_line);
 
3214
                  break;
 
3215
                }
 
3216
              case Dz_pilot_record:
 
3217
                {
 
3218
                  recordParts -> storeCommands (*command_line);
 
3219
                  break;
 
3220
                }
 
3221
              case Dx_cg_record:
 
3222
                {
 
3223
                  recordParts -> storeCommands (*command_line);
 
3224
                  break;
 
3225
                }
 
3226
              case Dy_cg_record:
 
3227
                {
 
3228
                  recordParts -> storeCommands (*command_line);
 
3229
                  break;
 
3230
                }
 
3231
              case Dz_cg_record:
 
3232
                {
 
3233
                  recordParts -> storeCommands (*command_line);
 
3234
                  break;
 
3235
                }
 
3236
 
 
3237
                /********************** Positions **********************/
 
3238
              case Lat_geocentric_record:
 
3239
                {
 
3240
                  recordParts -> storeCommands (*command_line);
 
3241
                  break;
 
3242
                }
 
3243
              case Lon_geocentric_record:
 
3244
                {
 
3245
                  recordParts -> storeCommands (*command_line);
 
3246
                  break;
 
3247
                }
 
3248
              case Radius_to_vehicle_record:
 
3249
                {
 
3250
                  recordParts -> storeCommands (*command_line);
 
3251
                  break;
 
3252
                }
 
3253
              case Latitude_record:
 
3254
                {
 
3255
                  recordParts -> storeCommands (*command_line);
 
3256
                  break;
 
3257
                }
 
3258
              case Longitude_record:
 
3259
                {
 
3260
                  recordParts -> storeCommands (*command_line);
 
3261
                  break;
 
3262
                }
 
3263
              case Altitude_record:
 
3264
                {
 
3265
                  recordParts -> storeCommands (*command_line);
 
3266
                  break;
 
3267
                }
 
3268
              case Phi_record:
 
3269
                {
 
3270
                  recordParts -> storeCommands (*command_line);
 
3271
                  break;
 
3272
                }
 
3273
              case Theta_record:
 
3274
                {
 
3275
                  recordParts -> storeCommands (*command_line);
 
3276
                  break;
 
3277
                }
 
3278
              case Psi_record:
 
3279
                {
 
3280
                  recordParts -> storeCommands (*command_line);
 
3281
                  break;
 
3282
                }
 
3283
 
 
3284
                /******************** Accelerations ********************/
 
3285
              case V_dot_north_record:
 
3286
                {
 
3287
                  recordParts -> storeCommands (*command_line);
 
3288
                  break;
 
3289
                }
 
3290
              case V_dot_east_record:
 
3291
                {
 
3292
                  recordParts -> storeCommands (*command_line);
 
3293
                  break;
 
3294
                }
 
3295
              case V_dot_down_record:
 
3296
                {
 
3297
                  recordParts -> storeCommands (*command_line);
 
3298
                  break;
 
3299
                }
 
3300
              case U_dot_body_record:
 
3301
                {
 
3302
                  recordParts -> storeCommands (*command_line);
 
3303
                  break;
 
3304
                }
 
3305
              case V_dot_body_record:
 
3306
                {
 
3307
                  recordParts -> storeCommands (*command_line);
 
3308
                  break;
 
3309
                }
 
3310
              case W_dot_body_record:
 
3311
                {
 
3312
                  recordParts -> storeCommands (*command_line);
 
3313
                  break;
 
3314
                }
 
3315
              case A_X_pilot_record:
 
3316
                {
 
3317
                  recordParts -> storeCommands (*command_line);
 
3318
                  break;
 
3319
                }
 
3320
              case A_Y_pilot_record:
 
3321
                {
 
3322
                  recordParts -> storeCommands (*command_line);
 
3323
                  break;
 
3324
                }
 
3325
              case A_Z_pilot_record:
 
3326
                {
 
3327
                  recordParts -> storeCommands (*command_line);
 
3328
                  break;
 
3329
                }
 
3330
              case A_X_cg_record:
 
3331
                {
 
3332
                  recordParts -> storeCommands (*command_line);
 
3333
                  break;
 
3334
                }
 
3335
              case A_Y_cg_record:
 
3336
                {
 
3337
                  recordParts -> storeCommands (*command_line);
 
3338
                  break;
 
3339
                }
 
3340
              case A_Z_cg_record:
 
3341
                {
 
3342
                  recordParts -> storeCommands (*command_line);
 
3343
                  break;
 
3344
                }
 
3345
              case N_X_pilot_record:
 
3346
                {
 
3347
                  recordParts -> storeCommands (*command_line);
 
3348
                  break;
 
3349
                }
 
3350
              case N_Y_pilot_record:
 
3351
                {
 
3352
                  recordParts -> storeCommands (*command_line);
 
3353
                  break;
 
3354
                }
 
3355
              case N_Z_pilot_record:
 
3356
                {
 
3357
                  recordParts -> storeCommands (*command_line);
 
3358
                  break;
 
3359
                }
 
3360
              case N_X_cg_record:
 
3361
                {
 
3362
                  recordParts -> storeCommands (*command_line);
 
3363
                  break;
 
3364
                }
 
3365
              case N_Y_cg_record:
 
3366
                {
 
3367
                  recordParts -> storeCommands (*command_line);
 
3368
                  break;
 
3369
                }
 
3370
              case N_Z_cg_record:
 
3371
                {
 
3372
                  recordParts -> storeCommands (*command_line);
 
3373
                  break;
 
3374
                }
 
3375
              case P_dot_body_record:
 
3376
                {
 
3377
                  recordParts -> storeCommands (*command_line);
 
3378
                  break;
 
3379
                }
 
3380
              case Q_dot_body_record:
 
3381
                {
 
3382
                  recordParts -> storeCommands (*command_line);
 
3383
                  break;
 
3384
                }
 
3385
              case R_dot_body_record:
 
3386
                {
 
3387
                  recordParts -> storeCommands (*command_line);
 
3388
                  break;
 
3389
                }
 
3390
 
 
3391
                /********************** Velocities *********************/
 
3392
              case V_north_record:
 
3393
                {
 
3394
                  recordParts -> storeCommands (*command_line);
 
3395
                  break;
 
3396
                }
 
3397
              case V_east_record:
 
3398
                {
 
3399
                  recordParts -> storeCommands (*command_line);
 
3400
                  break;
 
3401
                }
 
3402
              case V_down_record:
 
3403
                {
 
3404
                  recordParts -> storeCommands (*command_line);
 
3405
                  break;
 
3406
                }
 
3407
              case V_north_rel_ground_record:
 
3408
                {
 
3409
                  recordParts -> storeCommands (*command_line);
 
3410
                  break;
 
3411
                }
 
3412
              case V_east_rel_ground_record:
 
3413
                {
 
3414
                  recordParts -> storeCommands (*command_line);
 
3415
                  break;
 
3416
                }
 
3417
              case V_down_rel_ground_record:
 
3418
                {
 
3419
                  recordParts -> storeCommands (*command_line);
 
3420
                  break;
 
3421
                }
 
3422
              case V_north_airmass_record:
 
3423
                {
 
3424
                  recordParts -> storeCommands (*command_line);
 
3425
                  break;
 
3426
                }
 
3427
              case V_east_airmass_record:
 
3428
                {
 
3429
                  recordParts -> storeCommands (*command_line);
 
3430
                  break;
 
3431
                }
 
3432
              case V_down_airmass_record:
 
3433
                {
 
3434
                  recordParts -> storeCommands (*command_line);
 
3435
                  break;
 
3436
                }
 
3437
              case V_north_rel_airmass_record:
 
3438
                {
 
3439
                  recordParts -> storeCommands (*command_line);
 
3440
                  break;
 
3441
                }
 
3442
              case V_east_rel_airmass_record:
 
3443
                {
 
3444
                  recordParts -> storeCommands (*command_line);
 
3445
                  break;
 
3446
                }
 
3447
              case V_down_rel_airmass_record:
 
3448
                {
 
3449
                  recordParts -> storeCommands (*command_line);
 
3450
                  break;
 
3451
                }
 
3452
              case U_gust_record:
 
3453
                {
 
3454
                  recordParts -> storeCommands (*command_line);
 
3455
                  break;
 
3456
                }
 
3457
              case V_gust_record:
 
3458
                {
 
3459
                  recordParts -> storeCommands (*command_line);
 
3460
                  break;
 
3461
                }
 
3462
              case W_gust_record:
 
3463
                {
 
3464
                  recordParts -> storeCommands (*command_line);
 
3465
                  break;
 
3466
                }
 
3467
              case U_body_record:
 
3468
                {
 
3469
                  recordParts -> storeCommands (*command_line);
 
3470
                  break;
 
3471
                }
 
3472
              case V_body_record:
 
3473
                {
 
3474
                  recordParts -> storeCommands (*command_line);
 
3475
                  break;
 
3476
                }
 
3477
              case W_body_record:
 
3478
                {
 
3479
                  recordParts -> storeCommands (*command_line);
 
3480
                  break;
 
3481
                }
 
3482
              case V_rel_wind_record:
 
3483
                {
 
3484
                  recordParts -> storeCommands (*command_line);
 
3485
                  break;
 
3486
                }
 
3487
              case V_true_kts_record:
 
3488
                {
 
3489
                  recordParts -> storeCommands (*command_line);
 
3490
                  break;
 
3491
                }
 
3492
              case V_rel_ground_record:
 
3493
                {
 
3494
                  recordParts -> storeCommands (*command_line);
 
3495
                  break;
 
3496
                }
 
3497
              case V_inertial_record:
 
3498
                {
 
3499
                  recordParts -> storeCommands (*command_line);
 
3500
                  break;
 
3501
                }
 
3502
              case V_ground_speed_record:
 
3503
                {
 
3504
                  recordParts -> storeCommands (*command_line);
 
3505
                  break;
 
3506
                }
 
3507
              case V_equiv_record:
 
3508
                {
 
3509
                  recordParts -> storeCommands (*command_line);
 
3510
                  break;
 
3511
                }
 
3512
              case V_equiv_kts_record:
 
3513
                {
 
3514
                  recordParts -> storeCommands (*command_line);
 
3515
                  break;
 
3516
                }
 
3517
              case V_calibrated_record:
 
3518
                {
 
3519
                  recordParts -> storeCommands (*command_line);
 
3520
                  break;
 
3521
                }
 
3522
              case V_calibrated_kts_record:
 
3523
                {
 
3524
                  recordParts -> storeCommands (*command_line);
 
3525
                  break;
 
3526
                }
 
3527
              case P_local_record:
 
3528
                {
 
3529
                  recordParts -> storeCommands (*command_line);
 
3530
                  break;
 
3531
                }
 
3532
              case Q_local_record:
 
3533
                {
 
3534
                  recordParts -> storeCommands (*command_line);
 
3535
                  break;
 
3536
                }
 
3537
              case R_local_record:
 
3538
                {
 
3539
                  recordParts -> storeCommands (*command_line);
 
3540
                  break;
 
3541
                }
 
3542
              case P_body_record:
 
3543
                {
 
3544
                  recordParts -> storeCommands (*command_line);
 
3545
                  break;
 
3546
                }
 
3547
              case Q_body_record:
 
3548
                {
 
3549
                  recordParts -> storeCommands (*command_line);
 
3550
                  break;
 
3551
                }
 
3552
              case R_body_record:
 
3553
                {
 
3554
                  recordParts -> storeCommands (*command_line);
 
3555
                  break;
 
3556
                }
 
3557
              case P_total_record:
 
3558
                {
 
3559
                  recordParts -> storeCommands (*command_line);
 
3560
                  break;
 
3561
                }
 
3562
              case Q_total_record:
 
3563
                {
 
3564
                  recordParts -> storeCommands (*command_line);
 
3565
                  break;
 
3566
                }
 
3567
              case R_total_record:
 
3568
                {
 
3569
                  recordParts -> storeCommands (*command_line);
 
3570
                  break;
 
3571
                }
 
3572
              case Phi_dot_record:
 
3573
                {
 
3574
                  recordParts -> storeCommands (*command_line);
 
3575
                  break;
 
3576
                }
 
3577
              case Theta_dot_record:
 
3578
                {
 
3579
                  recordParts -> storeCommands (*command_line);
 
3580
                  break;
 
3581
                }
 
3582
              case Psi_dot_record:
 
3583
                {
 
3584
                  recordParts -> storeCommands (*command_line);
 
3585
                  break;
 
3586
                }
 
3587
              case Latitude_dot_record:
 
3588
                {
 
3589
                  recordParts -> storeCommands (*command_line);
 
3590
                  break;
 
3591
                }
 
3592
              case Longitude_dot_record:
 
3593
                {
 
3594
                  recordParts -> storeCommands (*command_line);
 
3595
                  break;
 
3596
                }
 
3597
              case Radius_dot_record:
 
3598
                {
 
3599
                  recordParts -> storeCommands (*command_line);
 
3600
                  break;
 
3601
                }
 
3602
 
 
3603
                /************************ Angles ***********************/
 
3604
              case Alpha_record:
 
3605
                {
 
3606
                  recordParts -> storeCommands (*command_line);
 
3607
                  break;
 
3608
                }
 
3609
              case Alpha_deg_record:
 
3610
                {
 
3611
                  recordParts -> storeCommands (*command_line);
 
3612
                  break;
 
3613
                }
 
3614
              case Alpha_dot_record:
 
3615
                {
 
3616
                  recordParts -> storeCommands (*command_line);
 
3617
                  break;
 
3618
                }
 
3619
              case Alpha_dot_deg_record:
 
3620
                {
 
3621
                  recordParts -> storeCommands (*command_line);
 
3622
                  break;
 
3623
                }
 
3624
              case Beta_record:
 
3625
                {
 
3626
                  recordParts -> storeCommands (*command_line);
 
3627
                  break;
 
3628
                }
 
3629
              case Beta_deg_record:
 
3630
                {
 
3631
                  recordParts -> storeCommands (*command_line);
 
3632
                  break;
 
3633
                }
 
3634
              case Beta_dot_record:
 
3635
                {
 
3636
                  recordParts -> storeCommands (*command_line);
 
3637
                  break;
 
3638
                }
 
3639
              case Beta_dot_deg_record:
 
3640
                {
 
3641
                  recordParts -> storeCommands (*command_line);
 
3642
                  break;
 
3643
                }
 
3644
              case Gamma_vert_record:
 
3645
                {
 
3646
                  recordParts -> storeCommands (*command_line);
 
3647
                  break;
 
3648
                }
 
3649
              case Gamma_vert_deg_record:
 
3650
                {
 
3651
                  recordParts -> storeCommands (*command_line);
 
3652
                  break;
 
3653
                }
 
3654
              case Gamma_horiz_record:
 
3655
                {
 
3656
                  recordParts -> storeCommands (*command_line);
 
3657
                  break;
 
3658
                }
 
3659
              case Gamma_horiz_deg_record:
 
3660
                {
 
3661
                  recordParts -> storeCommands (*command_line);
 
3662
                  break;
 
3663
                }
 
3664
 
 
3665
                /**************** Atmospheric Properties ***************/
 
3666
              case Density_record:
 
3667
                {
 
3668
                  recordParts -> storeCommands (*command_line);
 
3669
                  break;
 
3670
                }
 
3671
              case V_sound_record:
 
3672
                {
 
3673
                  recordParts -> storeCommands (*command_line);
 
3674
                  break;
 
3675
                }
 
3676
              case Mach_number_record:
 
3677
                {
 
3678
                  recordParts -> storeCommands (*command_line);
 
3679
                  break;
 
3680
                }
 
3681
              case Static_pressure_record:
 
3682
                {
 
3683
                  recordParts -> storeCommands (*command_line);
 
3684
                  break;
 
3685
                }
 
3686
              case Total_pressure_record:
 
3687
                {
 
3688
                  recordParts -> storeCommands (*command_line);
 
3689
                  break;
 
3690
                }
 
3691
              case Impact_pressure_record:
 
3692
                {
 
3693
                  recordParts -> storeCommands (*command_line);
 
3694
                  break;
 
3695
                }
 
3696
              case Dynamic_pressure_record:
 
3697
                {
 
3698
                  recordParts -> storeCommands (*command_line);
 
3699
                  break;
 
3700
                }
 
3701
              case Static_temperature_record:
 
3702
                {
 
3703
                  recordParts -> storeCommands (*command_line);
 
3704
                  break;
 
3705
                }
 
3706
              case Total_temperature_record:
 
3707
                {
 
3708
                  recordParts -> storeCommands (*command_line);
 
3709
                  break;
 
3710
                }
 
3711
 
 
3712
                /******************** Earth Properties *****************/
 
3713
              case Gravity_record:
 
3714
                {
 
3715
                  recordParts -> storeCommands (*command_line);
 
3716
                  break;
 
3717
                }
 
3718
              case Sea_level_radius_record:
 
3719
                {
 
3720
                  recordParts -> storeCommands (*command_line);
 
3721
                  break;
 
3722
                }
 
3723
              case Earth_position_angle_record:
 
3724
                {
 
3725
                  recordParts -> storeCommands (*command_line);
 
3726
                  break;
 
3727
                }
 
3728
              case Runway_altitude_record:
 
3729
                {
 
3730
                  recordParts -> storeCommands (*command_line);
 
3731
                  break;
 
3732
                }
 
3733
              case Runway_latitude_record:
 
3734
                {
 
3735
                  recordParts -> storeCommands (*command_line);
 
3736
                  break;
 
3737
                }
 
3738
              case Runway_longitude_record:
 
3739
                {
 
3740
                  recordParts -> storeCommands (*command_line);
 
3741
                  break;
 
3742
                }
 
3743
              case Runway_heading_record:
 
3744
                {
 
3745
                  recordParts -> storeCommands (*command_line);
 
3746
                  break;
 
3747
                }
 
3748
              case Radius_to_rwy_record:
 
3749
                {
 
3750
                  recordParts -> storeCommands (*command_line);
 
3751
                  break;
 
3752
                }
 
3753
              case D_pilot_north_of_rwy_record:
 
3754
                {
 
3755
                  recordParts -> storeCommands (*command_line);
 
3756
                  break;
 
3757
                }
 
3758
              case D_pilot_east_of_rwy_record:
 
3759
                {
 
3760
                  recordParts -> storeCommands (*command_line);
 
3761
                  break;
 
3762
                }
 
3763
              case D_pilot_above_rwy_record:
 
3764
                {
 
3765
                  recordParts -> storeCommands (*command_line);
 
3766
                  break;
 
3767
                }
 
3768
              case X_pilot_rwy_record:
 
3769
                {
 
3770
                  recordParts -> storeCommands (*command_line);
 
3771
                  break;
 
3772
                }
 
3773
              case Y_pilot_rwy_record:
 
3774
                {
 
3775
                  recordParts -> storeCommands (*command_line);
 
3776
                  break;
 
3777
                }
 
3778
              case H_pilot_rwy_record:
 
3779
                {
 
3780
                  recordParts -> storeCommands (*command_line);
 
3781
                  break;
 
3782
                }
 
3783
              case D_cg_north_of_rwy_record:
 
3784
                {
 
3785
                  recordParts -> storeCommands (*command_line);
 
3786
                  break;
 
3787
                }
 
3788
              case D_cg_east_of_rwy_record:
 
3789
                {
 
3790
                  recordParts -> storeCommands (*command_line);
 
3791
                  break;
 
3792
                }
 
3793
              case D_cg_above_rwy_record:
 
3794
                {
 
3795
                  recordParts -> storeCommands (*command_line);
 
3796
                  break;
 
3797
                }
 
3798
              case X_cg_rwy_record:
 
3799
                {
 
3800
                  recordParts -> storeCommands (*command_line);
 
3801
                  break;
 
3802
                }
 
3803
              case Y_cg_rwy_record:
 
3804
                {
 
3805
                  recordParts -> storeCommands (*command_line);
 
3806
                  break;
 
3807
                }
 
3808
              case H_cg_rwy_record:
 
3809
                {
 
3810
                  recordParts -> storeCommands (*command_line);
 
3811
                  break;
 
3812
                }
 
3813
 
 
3814
                /********************* Engine Inputs *******************/
 
3815
              case Throttle_pct_record:
 
3816
                {
 
3817
                  recordParts -> storeCommands (*command_line);
 
3818
                  break;
 
3819
                }
 
3820
              case Throttle_3_record:
 
3821
                {
 
3822
                  recordParts -> storeCommands (*command_line);
 
3823
                  break;
 
3824
                }
 
3825
 
 
3826
                /******************** Control Inputs *******************/
 
3827
              case Long_control_record:
 
3828
                {
 
3829
                  recordParts -> storeCommands (*command_line);
 
3830
                  break;
 
3831
                }
 
3832
              case Long_trim_record:
 
3833
                {
 
3834
                  recordParts -> storeCommands (*command_line);
 
3835
                  break;
 
3836
                }
 
3837
              case Long_trim_deg_record:
 
3838
                {
 
3839
                  recordParts -> storeCommands (*command_line);
 
3840
                  break;
 
3841
                }
 
3842
              case elevator_record:
 
3843
                {
 
3844
                  recordParts -> storeCommands (*command_line);
 
3845
                  break;
 
3846
                }
 
3847
              case elevator_deg_record:
 
3848
                {
 
3849
                  recordParts -> storeCommands (*command_line);
 
3850
                  break;
 
3851
                }
 
3852
              case Lat_control_record:
 
3853
                {
 
3854
                  recordParts -> storeCommands (*command_line);
 
3855
                  break;
 
3856
                }
 
3857
              case aileron_record:
 
3858
                {
 
3859
                  recordParts -> storeCommands (*command_line);
 
3860
                  break;
 
3861
                }
 
3862
              case aileron_deg_record:
 
3863
                {
 
3864
                  recordParts -> storeCommands (*command_line);
 
3865
                  break;
 
3866
                }
 
3867
              case Rudder_pedal_record:
 
3868
                {
 
3869
                  recordParts -> storeCommands (*command_line);
 
3870
                  break;
 
3871
                }
 
3872
              case rudder_record:
 
3873
                {
 
3874
                  recordParts -> storeCommands (*command_line);
 
3875
                  break;
 
3876
                }
 
3877
              case rudder_deg_record:
 
3878
                {
 
3879
                  recordParts -> storeCommands (*command_line);
 
3880
                  break;
 
3881
                }
 
3882
              case Flap_handle_record:
 
3883
                {
 
3884
                  recordParts -> storeCommands (*command_line);
 
3885
                  break;
 
3886
                }
 
3887
              case flap_record:
 
3888
                {
 
3889
                  recordParts -> storeCommands (*command_line);
 
3890
                  break;
 
3891
                }
 
3892
              case flap_deg_record:
 
3893
                {
 
3894
                  recordParts -> storeCommands (*command_line);
 
3895
                  break;
 
3896
                }
 
3897
 
 
3898
                /****************** Aero Coefficients ******************/
 
3899
              case CD_record:
 
3900
                {
 
3901
                  recordParts -> storeCommands (*command_line);
 
3902
                  break;
 
3903
                }
 
3904
              case CDfaI_record:
 
3905
                {
 
3906
                  recordParts -> storeCommands (*command_line);
 
3907
                  break;
 
3908
                }
 
3909
              case CDfadeI_record:
 
3910
                {
 
3911
                  recordParts -> storeCommands (*command_line);
 
3912
                  break;
 
3913
                }
 
3914
              case CDfdfI_record:
 
3915
                {
 
3916
                  recordParts -> storeCommands (*command_line);
 
3917
                  break;
 
3918
                }
 
3919
              case CDfadfI_record:
 
3920
                {
 
3921
                  recordParts -> storeCommands (*command_line);
 
3922
                  break;
 
3923
                }
 
3924
              case CX_record:
 
3925
                {
 
3926
                  recordParts -> storeCommands (*command_line);
 
3927
                  break;
 
3928
                }
 
3929
              case CL_record:
 
3930
                {
 
3931
                  recordParts -> storeCommands (*command_line);
 
3932
                  break;
 
3933
                }
 
3934
              case CLfaI_record:
 
3935
                {
 
3936
                  recordParts -> storeCommands (*command_line);
 
3937
                  break;
 
3938
                }
 
3939
              case CLfadeI_record:
 
3940
                {
 
3941
                  recordParts -> storeCommands (*command_line);
 
3942
                  break;
 
3943
                }
 
3944
              case CLfdfI_record:
 
3945
                {
 
3946
                  recordParts -> storeCommands (*command_line);
 
3947
                  break;
 
3948
                }
 
3949
              case CLfadfI_record:
 
3950
                {
 
3951
                  recordParts -> storeCommands (*command_line);
 
3952
                  break;
 
3953
                }
 
3954
              case CZ_record:
 
3955
                {
 
3956
                  recordParts -> storeCommands (*command_line);
 
3957
                  break;
 
3958
                }
 
3959
              case Cm_record:
 
3960
                {
 
3961
                  recordParts -> storeCommands (*command_line);
 
3962
                  break;
 
3963
                }
 
3964
              case CmfaI_record:
 
3965
                {
 
3966
                  recordParts -> storeCommands (*command_line);
 
3967
                  break;
 
3968
                }
 
3969
              case CmfadeI_record:
 
3970
                {
 
3971
                  recordParts -> storeCommands (*command_line);
 
3972
                  break;
 
3973
                }
 
3974
              case CmfdfI_record:
 
3975
                {
 
3976
                  recordParts -> storeCommands (*command_line);
 
3977
                  break;
 
3978
                }
 
3979
              case CmfadfI_record:
 
3980
                {
 
3981
                  recordParts -> storeCommands (*command_line);
 
3982
                  break;
 
3983
                }
 
3984
              case CY_record:
 
3985
                {
 
3986
                  recordParts -> storeCommands (*command_line);
 
3987
                  break;
 
3988
                }
 
3989
              case CYfadaI_record:
 
3990
                {
 
3991
                  recordParts -> storeCommands (*command_line);
 
3992
                  break;
 
3993
                }
 
3994
              case CYfbetadrI_record:
 
3995
                {
 
3996
                  recordParts -> storeCommands (*command_line);
 
3997
                  break;
 
3998
                }
 
3999
              case Cl_record:
 
4000
                {
 
4001
                  recordParts -> storeCommands (*command_line);
 
4002
                  break;
 
4003
                }
 
4004
              case ClfadaI_record:
 
4005
                {
 
4006
                  recordParts -> storeCommands (*command_line);
 
4007
                  break;
 
4008
                }
 
4009
              case ClfbetadrI_record:
 
4010
                {
 
4011
                  recordParts -> storeCommands (*command_line);
 
4012
                  break;
 
4013
                }
 
4014
              case Cn_record:
 
4015
                {
 
4016
                  recordParts -> storeCommands (*command_line);
 
4017
                  break;
 
4018
                }
 
4019
              case CnfadaI_record:
 
4020
                {
 
4021
                  recordParts -> storeCommands (*command_line);
 
4022
                  break;
 
4023
                }
 
4024
              case CnfbetadrI_record:
 
4025
                {
 
4026
                  recordParts -> storeCommands (*command_line);
 
4027
                  break;
 
4028
                }
 
4029
 
 
4030
                /******************** Ice Detection ********************/
 
4031
              case CLclean_wing_record:
 
4032
                {
 
4033
                  recordParts -> storeCommands (*command_line);
 
4034
                  break;
 
4035
                }
 
4036
              case CLiced_wing_record:
 
4037
                {
 
4038
                  recordParts -> storeCommands (*command_line);
 
4039
                  break;
 
4040
                }
 
4041
              case CLclean_tail_record:
 
4042
                {
 
4043
                  recordParts -> storeCommands (*command_line);
 
4044
                  break;
 
4045
                }
 
4046
              case CLiced_tail_record:
 
4047
                {
 
4048
                  recordParts -> storeCommands (*command_line);
 
4049
                  break;
 
4050
                }
 
4051
              case Lift_clean_wing_record:
 
4052
                {
 
4053
                  recordParts -> storeCommands (*command_line);
 
4054
                  break;
 
4055
                }
 
4056
              case Lift_iced_wing_record:
 
4057
                {
 
4058
                  recordParts -> storeCommands (*command_line);
 
4059
                  break;
 
4060
                }
 
4061
              case Lift_clean_tail_record:
 
4062
                {
 
4063
                  recordParts -> storeCommands (*command_line);
 
4064
                  break;
 
4065
                }
 
4066
              case Lift_iced_tail_record:
 
4067
                {
 
4068
                  recordParts -> storeCommands (*command_line);
 
4069
                  break;
 
4070
                }
 
4071
              case Gamma_clean_wing_record:
 
4072
                {
 
4073
                  recordParts -> storeCommands (*command_line);
 
4074
                  break;
 
4075
                }
 
4076
              case Gamma_iced_wing_record:
 
4077
                {
 
4078
                  recordParts -> storeCommands (*command_line);
 
4079
                  break;
 
4080
                }
 
4081
              case Gamma_clean_tail_record:
 
4082
                {
 
4083
                  recordParts -> storeCommands (*command_line);
 
4084
                  break;
 
4085
                }
 
4086
              case Gamma_iced_tail_record:
 
4087
                {
 
4088
                  recordParts -> storeCommands (*command_line);
 
4089
                  break;
 
4090
                }
 
4091
              case w_clean_wing_record:
 
4092
                {
 
4093
                  recordParts -> storeCommands (*command_line);
 
4094
                  break;
 
4095
                }
 
4096
              case w_iced_wing_record:
 
4097
                {
 
4098
                  recordParts -> storeCommands (*command_line);
 
4099
                  break;
 
4100
                }
 
4101
              case w_clean_tail_record:
 
4102
                {
 
4103
                  recordParts -> storeCommands (*command_line);
 
4104
                  break;
 
4105
                }
 
4106
              case w_iced_tail_record:
 
4107
                {
 
4108
                  recordParts -> storeCommands (*command_line);
 
4109
                  break;
 
4110
                }
 
4111
              case V_total_clean_wing_record:
 
4112
                {
 
4113
                  recordParts -> storeCommands (*command_line);
 
4114
                  break;
 
4115
                }
 
4116
              case V_total_iced_wing_record:
 
4117
                {
 
4118
                  recordParts -> storeCommands (*command_line);
 
4119
                  break;
 
4120
                }
 
4121
              case V_total_clean_tail_record:
 
4122
                {
 
4123
                  recordParts -> storeCommands (*command_line);
 
4124
                  break;
 
4125
                }
 
4126
              case V_total_iced_tail_record:
 
4127
                {
 
4128
                  recordParts -> storeCommands (*command_line);
 
4129
                  break;
 
4130
                }
 
4131
              case beta_flow_clean_wing_record:
 
4132
                {
 
4133
                  recordParts -> storeCommands (*command_line);
 
4134
                  break;
 
4135
                }
 
4136
              case beta_flow_clean_wing_deg_record:
 
4137
                {
 
4138
                  recordParts -> storeCommands (*command_line);
 
4139
                  break;
 
4140
                }
 
4141
              case beta_flow_iced_wing_record:
 
4142
                {
 
4143
                  recordParts -> storeCommands (*command_line);
 
4144
                  break;
 
4145
                }
 
4146
              case beta_flow_iced_wing_deg_record:
 
4147
                {
 
4148
                  recordParts -> storeCommands (*command_line);
 
4149
                  break;
 
4150
                }
 
4151
              case beta_flow_clean_tail_record:
 
4152
                {
 
4153
                  recordParts -> storeCommands (*command_line);
 
4154
                  break;
 
4155
                }
 
4156
              case beta_flow_clean_tail_deg_record:
 
4157
                {
 
4158
                  recordParts -> storeCommands (*command_line);
 
4159
                  break;
 
4160
                }
 
4161
              case beta_flow_iced_tail_record:
 
4162
                {
 
4163
                  recordParts -> storeCommands (*command_line);
 
4164
                  break;
 
4165
                }
 
4166
              case beta_flow_iced_tail_deg_record:
 
4167
                {
 
4168
                  recordParts -> storeCommands (*command_line);
 
4169
                  break;
 
4170
                }
 
4171
              case Dbeta_flow_wing_record:
 
4172
                {
 
4173
                  recordParts -> storeCommands (*command_line);
 
4174
                  break;
 
4175
                }
 
4176
              case Dbeta_flow_wing_deg_record:
 
4177
                {
 
4178
                  recordParts -> storeCommands (*command_line);
 
4179
                  break;
 
4180
                }
 
4181
              case Dbeta_flow_tail_record:
 
4182
                {
 
4183
                  recordParts -> storeCommands (*command_line);
 
4184
                  break;
 
4185
                }
 
4186
              case Dbeta_flow_tail_deg_record:
 
4187
                {
 
4188
                  recordParts -> storeCommands (*command_line);
 
4189
                  break;
 
4190
                }
 
4191
              case pct_beta_flow_wing_record:
 
4192
                {
 
4193
                  recordParts -> storeCommands (*command_line);
 
4194
                  break;
 
4195
                }
 
4196
              case pct_beta_flow_tail_record:
 
4197
                {
 
4198
                  recordParts -> storeCommands (*command_line);
 
4199
                  break;
 
4200
                }
 
4201
 
 
4202
                /************************ Forces ***********************/
 
4203
              case F_X_wind_record:
 
4204
                {
 
4205
                  recordParts -> storeCommands (*command_line);
 
4206
                  break;
 
4207
                }
 
4208
              case F_Y_wind_record:
 
4209
                {
 
4210
                  recordParts -> storeCommands (*command_line);
 
4211
                  break;
 
4212
                }
 
4213
              case F_Z_wind_record:
 
4214
                {
 
4215
                  recordParts -> storeCommands (*command_line);
 
4216
                  break;
 
4217
                }
 
4218
              case F_X_aero_record:
 
4219
                {
 
4220
                  recordParts -> storeCommands (*command_line);
 
4221
                  break;
 
4222
                }
 
4223
              case F_Y_aero_record:
 
4224
                {
 
4225
                  recordParts -> storeCommands (*command_line);
 
4226
                  break;
 
4227
                }
 
4228
              case F_Z_aero_record:
 
4229
                {
 
4230
                  recordParts -> storeCommands (*command_line);
 
4231
                  break;
 
4232
                }
 
4233
              case F_X_engine_record:
 
4234
                {
 
4235
                  recordParts -> storeCommands (*command_line);
 
4236
                  break;
 
4237
                }
 
4238
              case F_Y_engine_record:
 
4239
                {
 
4240
                  recordParts -> storeCommands (*command_line);
 
4241
                  break;
 
4242
                }
 
4243
              case F_Z_engine_record:
 
4244
                {
 
4245
                  recordParts -> storeCommands (*command_line);
 
4246
                  break;
 
4247
                }
 
4248
              case F_X_gear_record:
 
4249
                {
 
4250
                  recordParts -> storeCommands (*command_line);
 
4251
                  break;
 
4252
                }
 
4253
              case F_Y_gear_record:
 
4254
                {
 
4255
                  recordParts -> storeCommands (*command_line);
 
4256
                  break;
 
4257
                }
 
4258
              case F_Z_gear_record:
 
4259
                {
 
4260
                  recordParts -> storeCommands (*command_line);
 
4261
                  break;
 
4262
                }
 
4263
              case F_X_record:
 
4264
                {
 
4265
                  recordParts -> storeCommands (*command_line);
 
4266
                  break;
 
4267
                }
 
4268
              case F_Y_record:
 
4269
                {
 
4270
                  recordParts -> storeCommands (*command_line);
 
4271
                  break;
 
4272
                }
 
4273
              case F_Z_record:
 
4274
                {
 
4275
                  recordParts -> storeCommands (*command_line);
 
4276
                  break;
 
4277
                }
 
4278
              case F_north_record:
 
4279
                {
 
4280
                  recordParts -> storeCommands (*command_line);
 
4281
                  break;
 
4282
                }
 
4283
              case F_east_record:
 
4284
                {
 
4285
                  recordParts -> storeCommands (*command_line);
 
4286
                  break;
 
4287
                }
 
4288
              case F_down_record:
 
4289
                {
 
4290
                  recordParts -> storeCommands (*command_line);
 
4291
                  break;
 
4292
                }
 
4293
 
 
4294
                /*********************** Moments ***********************/
 
4295
              case M_l_aero_record:
 
4296
                {
 
4297
                  recordParts -> storeCommands (*command_line);
 
4298
                  break;
 
4299
                }
 
4300
              case M_m_aero_record:
 
4301
                {
 
4302
                  recordParts -> storeCommands (*command_line);
 
4303
                  break;
 
4304
                }
 
4305
              case M_n_aero_record:
 
4306
                {
 
4307
                  recordParts -> storeCommands (*command_line);
 
4308
                  break;
 
4309
                }
 
4310
              case M_l_engine_record:
 
4311
                {
 
4312
                  recordParts -> storeCommands (*command_line);
 
4313
                  break;
 
4314
                }
 
4315
              case M_m_engine_record:
 
4316
                {
 
4317
                  recordParts -> storeCommands (*command_line);
 
4318
                  break;
 
4319
                }
 
4320
              case M_n_engine_record:
 
4321
                {
 
4322
                  recordParts -> storeCommands (*command_line);
 
4323
                  break;
 
4324
                }
 
4325
              case M_l_gear_record:
 
4326
                {
 
4327
                  recordParts -> storeCommands (*command_line);
 
4328
                  break;
 
4329
                }
 
4330
              case M_m_gear_record:
 
4331
                {
 
4332
                  recordParts -> storeCommands (*command_line);
 
4333
                  break;
 
4334
                }
 
4335
              case M_n_gear_record:
 
4336
                {
 
4337
                  recordParts -> storeCommands (*command_line);
 
4338
                  break;
 
4339
                }
 
4340
              case M_l_rp_record:
 
4341
                {
 
4342
                  recordParts -> storeCommands (*command_line);
 
4343
                  break;
 
4344
                }
 
4345
              case M_m_rp_record:
 
4346
                {
 
4347
                  recordParts -> storeCommands (*command_line);
 
4348
                  break;
 
4349
                }
 
4350
              case M_n_rp_record:
 
4351
                {
 
4352
                  recordParts -> storeCommands (*command_line);
 
4353
                  break;
 
4354
                }
 
4355
              default:
 
4356
                {
 
4357
                  uiuc_warnings_errors(2, *command_line);
 
4358
                  break;
 
4359
                }
 
4360
              };
 
4361
            break;
 
4362
          } // end record map               
 
4363
 
 
4364
 
 
4365
        case misc_flag:
 
4366
          {
 
4367
            switch(misc_map[linetoken2])
 
4368
              {
 
4369
              case simpleHingeMomentCoef_flag:
 
4370
                {
 
4371
                  if (check_float(linetoken3))
 
4372
                    token3 >> token_value;
 
4373
                  else
 
4374
                    uiuc_warnings_errors(1, *command_line);
 
4375
                  
 
4376
                  simpleHingeMomentCoef = token_value;
 
4377
                  break;
 
4378
                }
 
4379
              case dfTimefdf_flag:
 
4380
                {
 
4381
                  dfTimefdf = linetoken3;
 
4382
                  /* call 1D File Reader with file name (dfTimefdf);
 
4383
                     function returns array of dfs (dfArray) and 
 
4384
                     corresponding time values (TimeArray) and max 
 
4385
                     number of terms in arrays (ndf) */
 
4386
                  uiuc_1DdataFileReader(dfTimefdf,
 
4387
                                        dfTimefdf_dfArray,
 
4388
                                        dfTimefdf_TimeArray,
 
4389
                                        dfTimefdf_ndf);
 
4390
                  break;
 
4391
                }
 
4392
              default:
 
4393
                {
 
4394
                  uiuc_warnings_errors(2, *command_line);
 
4395
                  break;
 
4396
                }
 
4397
              };
 
4398
            break;
 
4399
          } // end misc map
 
4400
 
 
4401
 
 
4402
        default:
 
4403
          {
 
4404
            if (linetoken1=="*")
 
4405
                return;
 
4406
            uiuc_warnings_errors(2, *command_line);
 
4407
            break;
 
4408
          }
 
4409
        };
 
4410
    } // end keyword map
 
4411
  
 
4412
  delete airplane;
 
4413
}
 
4414
 
 
4415
// end menu.cpp