src/FDM/YASim/Wing.cpp

   1 #include "Math.hpp"
   2 #include "Surface.hpp"
   3 #include "Wing.hpp"
   4 namespace yasim {
   5
   6 Wing::Wing()
   7 {
   8     _mirror = false;
   9     _base[0] = _base[1] = _base[2] = 0;
  10     _length = 0;
  11     _chord = 0;
  12     _taper = 0;
  13     _sweep = 0;
  14     _dihedral = 0;
  15     _stall = 0;
  16     _stallWidth = 0;
  17     _stallPeak = 0;
  18     _camber = 0;
  19     _incidence = 0;
  20     _dragScale = 1;
  21     _liftRatio = 1;
  22     _flap0Start = 0;
  23     _flap0End = 0;
  24     _flap0Lift = 0;
  25     _flap0Drag = 0;
  26     _flap1Start = 0;
  27     _flap1End = 0;
  28     _flap1Lift = 0;
  29     _flap1Drag = 0;
  30     _spoilerStart = 0;
  31     _spoilerEnd = 0;
  32     _spoilerLift = 0;
  33     _spoilerDrag = 0;
  34     _slatStart = 0;
  35     _slatEnd = 0;
  36     _slatAoA = 0;
  37     _slatDrag = 0;
  38 }
  39
  40 Wing::~Wing()
  41 {
  42     for(int i=0; i<_surfs.size(); i++) {
  43         SurfRec* s = (SurfRec*)_surfs.get(i);
  44         delete s->surface;
  45         delete s;
  46     }
  47 }
  48
  49 int Wing::numSurfaces()
  50 {
  51     return _surfs.size();
  52 }
  53
  54 Surface* Wing::getSurface(int n)
  55 {
  56     return ((SurfRec*)_surfs.get(n))->surface;
  57 }
  58
  59 float Wing::getSurfaceWeight(int n)
  60 {
  61     return ((SurfRec*)_surfs.get(n))->weight;
  62 }
  63
  64 void Wing::setMirror(bool mirror)
  65 {
  66     _mirror = mirror;
  67 }
  68
  69 void Wing::setBase(float* base)
  70 {
  71     for(int i=0; i<3; i++) _base[i] = base[i];
  72 }
  73
  74 void Wing::setLength(float length)
  75 {
  76     _length = length;
  77 }
  78
  79 void Wing::setChord(float chord)
  80 {
  81     _chord = chord;
  82 }
  83
  84 void Wing::setTaper(float taper)
  85 {
  86     _taper = taper;
  87 }
  88
  89 void Wing::setSweep(float sweep)
  90 {
  91     _sweep = sweep;
  92 }
  93
  94 void Wing::setDihedral(float dihedral)
  95 {
  96     _dihedral = dihedral;
  97 }
  98
  99 void Wing::setStall(float aoa)
 100 {
 101     _stall = aoa;
 102 }
 103
 104 void Wing::setStallWidth(float angle)
 105 {
 106     _stallWidth = angle;
 107 }
 108
 109 void Wing::setStallPeak(float fraction)
 110 {
 111     _stallPeak = fraction;
 112 }
 113
 114 void Wing::setCamber(float camber)
 115 {
 116     _camber = camber;
 117 }
 118
 119 void Wing::setIncidence(float incidence)
 120 {
 121     _incidence = incidence;
 122     for(int i=0; i<_surfs.size(); i++)
 123         ((SurfRec*)_surfs.get(i))->surface->setIncidence(incidence);
 124 }
 125
 126 void Wing::setFlap0(float start, float end, float lift, float drag)
 127 {
 128     _flap0Start = start;
 129     _flap0End = end;
 130     _flap0Lift = lift;
 131     _flap0Drag = drag;
 132 }
 133
 134 void Wing::setFlap1(float start, float end, float lift, float drag)
 135 {
 136     _flap1Start = start;
 137     _flap1End = end;
 138     _flap1Lift = lift;
 139     _flap1Drag = drag;
 140 }
 141
 142 void Wing::setSlat(float start, float end, float aoa, float drag)
 143 {
 144     _slatStart = start;
 145     _slatEnd = end;
 146     _slatAoA = aoa;
 147     _slatDrag = drag;
 148 }
 149
 150 void Wing::setSpoiler(float start, float end, float lift, float drag)
 151 {
 152     _spoilerStart = start;
 153     _spoilerEnd = end;
 154     _spoilerLift = lift;
 155     _spoilerDrag = drag;
 156 }
 157
 158 void Wing::setFlap0(float lval, float rval)
 159 {
 160     for(int i=0; i<_flap0Surfs.size(); i++) {
 161         ((Surface*)_flap0Surfs.get(i))->setFlap(lval);
 162         if(_mirror) ((Surface*)_flap0Surfs.get(++i))->setFlap(rval);
 163     }
 164 }
 165
 166 void Wing::setFlap1(float lval, float rval)
 167 {
 168     for(int i=0; i<_flap1Surfs.size(); i++) {
 169         ((Surface*)_flap1Surfs.get(i))->setFlap(lval);
 170         if(_mirror) ((Surface*)_flap1Surfs.get(++i))->setFlap(rval);
 171     }
 172 }
 173
 174 void Wing::setSpoiler(float lval, float rval)
 175 {
 176     for(int i=0; i<_spoilerSurfs.size(); i++) {
 177         ((Surface*)_spoilerSurfs.get(i))->setSpoiler(lval);
 178         if(_mirror) ((Surface*)_spoilerSurfs.get(++i))->setSpoiler(rval);
 179     }
 180 }
 181
 182 void Wing::setSlat(float val)
 183 {
 184     for(int i=0; i<_slatSurfs.size(); i++)
 185         ((Surface*)_slatSurfs.get(i))->setSlat(val);
 186 }
 187
 188 void Wing::compile()
 189 {
 190     // Have we already been compiled?
 191     if(_surfs.size() != 0) return;
 192
 193     // Assemble the start/end coordinates into an array, sort them,
 194     // and remove duplicates.  This gives us the boundaries of our
 195     // segments.
 196     float bounds[8];
 197     bounds[0] = _flap0Start;   bounds[1] = _flap0End;
 198     bounds[2] = _flap1Start;   bounds[3] = _flap1End;
 199     bounds[4] = _spoilerStart; bounds[5] = _spoilerEnd;
 200     bounds[6] = _slatStart;    bounds[7] = _slatEnd;
 201
 202     // Sort in increasing order
 203     for(int i=0; i<8; i++) {
 204         int minIdx = i;
 205         float minVal = bounds[i];
 206         for(int j=i+1; j<8; j++) {
 207             if(bounds[j] < minVal) {
 208                 minIdx = j;
 209                 minVal = bounds[j];
 210             }
 211         }
 212         float tmp = bounds[i];
 213         bounds[i] = minVal; bounds[minIdx] = tmp;
 214     }
 215
 216     // Uniqify
 217     float last = bounds[0];
 218     int nbounds = 1;
 219     for(int i=1; i<8; i++) {
 220         if(bounds[i] != last)
 221             bounds[nbounds++] = bounds[i];
 222         last = bounds[i];
 223     }
 224
 225     // Calculate a "nominal" segment length equal to an average chord,
 226     // normalized to lie within 0-1 over the length of the wing.
 227     float segLen = _chord * (0.5*(_taper+1)) / _length;
 228
 229     // Generating a unit vector pointing out the left wing.
 230     float left[3];
 231     left[0] = -Math::tan(_sweep);
 232     left[1] = Math::cos(_dihedral);
 233     left[2] = Math::sin(_dihedral);
 234     Math::unit3(left, left);
 235
 236     // Calculate coordinates for the root and tip of the wing
 237     float root[3], tip[3];
 238     Math::set3(_base, root);
 239     Math::set3(left, tip);
 240     Math::mul3(_length, tip, tip);
 241     Math::add3(root, tip, tip);
 242
 243     // The wing's Y axis will be the "left" vector.  The Z axis will
 244     // be perpendicular to this and the local (!) X axis, because we
 245     // want motion along the local X axis to be zero AoA (i.e. in the
 246     // wing's XY plane) by definition.  Then the local X coordinate is
 247     // just Y cross Z.
 248     float orient[9], rightOrient[9];
 249     float *x = orient, *y = orient+3, *z = orient+6;
 250     x[0] = 1; x[1] = 0; x[2] = 0;
 251     Math::set3(left, y);
 252     Math::cross3(x, y, z);
 253     Math::unit3(z, z);
 254     Math::cross3(y, z, x);
 255
 256     if(_mirror) {
 257         // Derive the right side orientation matrix from this one.
 258         for(int i=0; i<9; i++)  rightOrient[i] = orient[i];
 259
 260         // Negate all Y coordinates, this gets us a valid basis, but
 261         // it's left handed!  So...
 262         for(int i=1; i<9; i+=3) rightOrient[i] = -rightOrient[i];
 263
 264         // Change the direction of the Y axis to get back to a
 265         // right-handed system.
 266         for(int i=3; i<6; i++)  rightOrient[i] = -rightOrient[i];
 267     }
 268
 269     // Now go through each boundary and make segments
 270     for(int i=0; i<(nbounds-1); i++) {
 271         float start = bounds[i];
 272         float end = bounds[i+1];
 273         float mid = (start+end)/2;
 274
 275         bool flap0=0, flap1=0, slat=0, spoiler=0;
 276         if(_flap0Start   < mid && mid < _flap0End)   flap0 = 1;
 277         if(_flap1Start   < mid && mid < _flap1End)   flap1 = 1;
 278         if(_slatStart    < mid && mid < _slatEnd)    slat = 1;
 279         if(_spoilerStart < mid && mid < _spoilerEnd) spoiler = 1;
 280
 281         // FIXME: Should probably detect an error here if both flap0
 282         // and flap1 are set.  Right now flap1 overrides.
 283
 284         int nSegs = (int)Math::ceil((end-start)/segLen);
 285         float segWid = _length * (end - start)/nSegs;
 286
 287         for(int j=0; j<nSegs; j++) {
 288             float frac = start + (j+0.5) * (end-start)/nSegs;
 289             float pos[3];
 290             interp(root, tip, frac, pos);
 291
 292             float chord = _chord * (1 - (1-_taper)*frac);
 293
 294             Surface *s = newSurface(pos, orient, chord,
 295                                     flap0, flap1, slat, spoiler);
 296
 297             SurfRec *sr = new SurfRec();
 298             sr->surface = s;
 299             sr->weight = chord * segWid;
 300             s->setTotalDrag(sr->weight);
 301             _surfs.add(sr);
 302
 303             if(_mirror) {
 304                 pos[1] = -pos[1];
 305                 s = newSurface(pos, rightOrient, chord,
 306                                flap0, flap1, slat, spoiler);
 307                 sr = new SurfRec();
 308                 sr->surface = s;
 309                 sr->weight = chord * segWid;
 310                 s->setTotalDrag(sr->weight);
 311                 _surfs.add(sr);
 312             }
 313         }
 314     }
 315 }
 316
 317 float Wing::getDragScale()
 318 {
 319     return _dragScale;
 320 }
 321
 322 void Wing::setDragScale(float scale)
 323 {
 324     _dragScale = scale;
 325     for(int i=0; i<_surfs.size(); i++) {
 326         SurfRec* s = (SurfRec*)_surfs.get(i);
 327         s->surface->setTotalDrag(scale * s->weight);
 328     }
 329 }
 330
 331 void Wing::setLiftRatio(float ratio)
 332 {
 333     _liftRatio = ratio;
 334     for(int i=0; i<_surfs.size(); i++)
 335         ((SurfRec*)_surfs.get(i))->surface->setZDrag(ratio);
 336 }
 337
 338 float Wing::getLiftRatio()
 339 {
 340     return _liftRatio;
 341 }
 342
 343 Surface* Wing::newSurface(float* pos, float* orient, float chord,
 344                           bool flap0, bool flap1, bool slat, bool spoiler)
 345 {
 346     Surface* s = new Surface();
 347
 348     s->setPosition(pos);
 349     s->setOrientation(orient);
 350     s->setChord(chord);
 351
 352     // Camber is expressed as a fraction of stall peak, so convert.
 353     s->setBaseZDrag(_camber*_stallPeak);
 354
 355     // The "main" (i.e. normal) stall angle
 356     float stallAoA = _stall - _stallWidth/4;
 357     s->setStall(0, stallAoA);
 358     s->setStallWidth(0, _stallWidth);
 359     s->setStallPeak(0, _stallPeak);
 360
 361     // The negative AoA stall is the same if we're using an uncambered
 362     // airfoil, otherwise a "little badder".
 363     if(_camber > 0) {
 364         s->setStall(1, stallAoA * 0.8);
 365         s->setStallWidth(1, _stallWidth * 0.5);
 366     } else {
 367         s->setStall(1, stallAoA);
 368         s->setStall(1, _stallWidth);
 369     }
 370
 371     // The "reverse" stalls are unmeasurable junk.  Just use 13deg and
 372     // "sharp".
 373     s->setStallPeak(1, 1);
 374     for(int i=2; i<4; i++) {
 375         s->setStall(i, 0.2267);
 376         s->setStallWidth(i, 1);
 377     }
 378
 379     if(flap0)   s->setFlapParams(_flap0Lift, _flap0Drag);
 380     if(flap1)   s->setFlapParams(_flap1Lift, _flap1Drag);
 381     if(slat)    s->setSlatParams(_slatAoA, _slatDrag);
 382     if(spoiler) s->setSpoilerParams(_spoilerLift, _spoilerDrag);
 383
 384     if(flap0)   _flap0Surfs.add(s);
 385     if(flap1)   _flap1Surfs.add(s);
 386     if(slat)    _slatSurfs.add(s);
 387     if(spoiler) _spoilerSurfs.add(s);
 388
 389     return s;
 390 }
 391
 392 void Wing::interp(float* v1, float* v2, float frac, float* out)
 393 {
 394     out[0] = v1[0] + frac*(v2[0]-v1[0]);
 395     out[1] = v1[1] + frac*(v2[1]-v1[1]);
 396     out[2] = v1[2] + frac*(v2[2]-v1[2]);
 397 }
 398
 399 }; // namespace yasim