# Created by Octave 3.2.4, Tue Nov 23 12:53:44 2010 EST <mockbuild@jetta.math.Princeton.EDU.private>
# name: cache
# type: cell
# rows: 3
# columns: 15
# name: <cell-element>
# type: string
# elements: 1
# length: 8
calcwing
# name: <cell-element>
# type: string
# elements: 1
# length: 969
 -- Function File: clq = calcwing (wing, varargin)
     Runs the automatic calculation of a wing's aerodynamic
     characteristics for a whole range of angles of attack.  The WING
     argument specifies the wing geometry (as returned from makewing),
     and any following arguments must be in `"option name",
     option_value' pairs. Valid options are:
        * "start"   Initial angle of attack (0)

        * "limit"   Maximum angle of attack (22)

        * "psep"    The minimum past-separation local angle to
          terminate (0)

        * "sstep"   Initial angle step (0.5)

        * "mstep"   Minimum angle step (1e-2)

        * "maxit"   Maximum number of corrector iterations (250)

        * "minit"   Minimum number of corrector iterations (4)

        * "tol"     Minimum tolerance to achieve in corrector.

        * "silent"  Suppress verbose output (false)

        * "use_fsolve"  Use fsolve as a corrector (false)
          (experimental).


# name: <cell-element>
# type: string
# elements: 1
# length: 80
Runs the automatic calculation of a wing's aerodynamic characteristics
for a who

# name: <cell-element>
# type: string
# elements: 1
# length: 13
combinepolars
# name: <cell-element>
# type: string
# elements: 1
# length: 602
 -- Function File: pol = combinepolars (pol1, pol2, coef)
 -- Function File: pol = combinepolars (pol1, pol2, c1, c2, c)
     Combines two polars to get a specific interpolation. Useful when
     you repeatedly change the chord length at a particular section,
     and you don't want to recalculate each time using different local
     Reynolds number. A good streategy here is evaluate the boundary
     values or a few more and then interpolate.  You can either
     directly specify an interpolation coefficient (pol1 is 1, pol2 is
     0), or a pair of chord lengths and a requested chord length.


# name: <cell-element>
# type: string
# elements: 1
# length: 52
Combines two polars to get a specific interpolation.

# name: <cell-element>
# type: string
# elements: 1
# length: 9
corrector
# name: <cell-element>
# type: string
# elements: 1
# length: 327
 -- Function File: flow = corrector (flow, tol, opts, init)
     applies a newton/levenberg-marquardt corrector to a flow state, in
     order to reach local lift/circulation balance. tol specifies
     tolerance.  Reads the options minit, maxit, use_fsolve and silent
     from opts.  Returns empty matrix if not successful.


# name: <cell-element>
# type: string
# elements: 1
# length: 80
applies a newton/levenberg-marquardt corrector to a flow state, in order
to reac

# name: <cell-element>
# type: string
# elements: 1
# length: 6
floweq
# name: <cell-element>
# type: string
# elements: 1
# length: 201
 -- Function File: dg = floweq (g, flow)
     evaluates the right-hand sides of the spanwise flow equations
     given the spanwise distribution of flow control quantities (scaled
     circulations).


# name: <cell-element>
# type: string
# elements: 1
# length: 80
evaluates the right-hand sides of the spanwise flow equations given the
spanwise

# name: <cell-element>
# type: string
# elements: 1
# length: 7
floweqj
# name: <cell-element>
# type: string
# elements: 1
# length: 106
 -- Function File: dg = floweqj (g, flow)
     this function calculates the jacobian of floweq w.r.t. G.


# name: <cell-element>
# type: string
# elements: 1
# length: 50
this function calculates the jacobian of floweq w.

# name: <cell-element>
# type: string
# elements: 1
# length: 11
liftanalyze
# name: <cell-element>
# type: string
# elements: 1
# length: 134
 -- Function File: [a0, amax, clmax] = liftanalyze (al, cl)
     analyzes a lift curve. Searches for a zero-lift and max-lift angle.


# name: <cell-element>
# type: string
# elements: 1
# length: 22
analyzes a lift curve.

# name: <cell-element>
# type: string
# elements: 1
# length: 10
loadpolars
# name: <cell-element>
# type: string
# elements: 1
# length: 633
 -- Function File: pol = loadpolars (pn)
     Load an airfoil polar data in the form of 4 column matrix,
     specified as <angle of attack> <lift coefficient> <moment coefficient> <drag coefficient>
      The angles of attack should form an increasing sequence.  PN can
     either be a single name, a cell array of names, or a structure
     with a "names" field containing a cell array of names, and a "z"
     field containing spanwise coordinates of polars.  In the latter
     case, pol.z will contain the z values.  Duplicate loads are
     avoided, i.e. a file specified twice will only be loaded once and
     then copied.


# name: <cell-element>
# type: string
# elements: 1
# length: 80
Load an airfoil polar data in the form of 4 column matrix, specified as
<angle o

# name: <cell-element>
# type: string
# elements: 1
# length: 8
loadwing
# name: <cell-element>
# type: string
# elements: 1
# length: 602
 -- Function File: [ac, pn, ref] = loadwing (filename)
     Loads the basic wing geometry from file FILENAME.  The geometry
     should be described in the file as follows: mchord <reference mean aerodynamic chord>
     area <reference wing area>
     mcenter <reference mean aerodynamic center>

     centers
     <z1>  <x1>  <y1>  <c1>  <tw1>
                  :
     <zN>  <xN>  <yN>  <cN>  <twN>

     polars
     <polar file name 1>
     <polar file name 2>

     xK, yK, zK are coordinates of the K-th point on the mean center
     line, cK is the corresponding chord length and twK the twist.



# name: <cell-element>
# type: string
# elements: 1
# length: 49
Loads the basic wing geometry from file FILENAME.

# name: <cell-element>
# type: string
# elements: 1
# length: 8
makeflow
# name: <cell-element>
# type: string
# elements: 1
# length: 158
 -- Function File: flow = makeflow (wing, alfa)
     Initializes the flow at a particular global angle of attack by
     computing the sensitivity matrices.


# name: <cell-element>
# type: string
# elements: 1
# length: 80
Initializes the flow at a particular global angle of attack by
computing the sen

# name: <cell-element>
# type: string
# elements: 1
# length: 8
makewing
# name: <cell-element>
# type: string
# elements: 1
# length: 732
 -- Function File: wing = makewing (acs, pols, ref, panels)
     Creates the wing structure necessary for further computations.
     ACS is an N-by-5 array specifying the spanwise geometry
     description.  each row contains `[zac xac yac chord twist]' pols
     is a struct array describing the spanwise wing section data
     distribution. `pols(i).z' is the spanwise coordinate, `pols(i).cl'
     is the lift coefficient on local angle of attack dependence, etc.
     REF contains the reference quantities.  PANELS specifies either an
     approximate number of panels, or directly the z-coordinates of
     panel vertices. In the latter case, PANELS(1) and PANELS(end)
     should match ACS(1,1) and ACS(end,1), respectively.


# name: <cell-element>
# type: string
# elements: 1
# length: 62
Creates the wing structure necessary for further computations.

# name: <cell-element>
# type: string
# elements: 1
# length: 8
polppder
# name: <cell-element>
# type: string
# elements: 1
# length: 115
 @deftypefn{Function File} {ppd =} polppder (pp)
 Differentiates a piecewise polynomial structure.
 @end deftypefn

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 @deftypefn{Function File} {ppd =} polppder (pp)
 Differentiates a piecewise pol

# name: <cell-element>
# type: string
# elements: 1
# length: 9
predictor
# name: <cell-element>
# type: string
# elements: 1
# length: 266
 -- Function File: flow1 = predictor (flow, dalfad)
     Predicts a flow change when the global angle of attack is
     increased, using a Euler finite-difference method. DALFAD
     specifies the angle step in degrees. Returns empty matrix if not
     successful.


# name: <cell-element>
# type: string
# elements: 1
# length: 80
Predicts a flow change when the global angle of attack is increased,
using a Eul

# name: <cell-element>
# type: string
# elements: 1
# length: 5
qcalc
# name: <cell-element>
# type: string
# elements: 1
# length: 377
 -- Function File: [cl, cd, cm, ad] = qcalc (flow)
     Calculates local spanwise quantities for a given flow state.
    CL
          local lift coefficient

    CD
          local viscous drag coefficient

    CL
          local moment coefficient

    CM
          local flow twist (difference of local induced angle of attack
          and global angle of attack)

    ALC


# name: <cell-element>
# type: string
# elements: 1
# length: 60
Calculates local spanwise quantities for a given flow state.

# name: <cell-element>
# type: string
# elements: 1
# length: 7
setalfa
# name: <cell-element>
# type: string
# elements: 1
# length: 343
 -- Function File: flow1 = setalfa (flow, alfad)
     Sets angle of attack directly for a flow. This can be used if
     predictor fails. The scaled circulations are taken from the flow
     if present. Only `flow.wing' is mandatory, any other fields need
     not be initialized. Thus, this function can be used as
     initialization code.


# name: <cell-element>
# type: string
# elements: 1
# length: 41
Sets angle of attack directly for a flow.

# name: <cell-element>
# type: string
# elements: 1
# length: 9
spwinterp
# name: <cell-element>
# type: string
# elements: 1
# length: 501
 -- Loadable Function: val = spwinterp (alfa, wing, pol, deriv)
     spanwise inerpolation of polar data. ALFA is a vector of local
     angles of attack at z(j), and CF and IDX determine the relative
     distribution of z w.r.t zp (the spanwise polar positions) as
     follows:   if idx(i) <= j < idx(i+1) then z(j) = (1-cf(j))*zp(i) +
     cf(j)*zp(i+1),   with 0 <= cf(j) <= 1.  the inerpolation at z(j)
     is obtained by weighting the interpolations at zp(i), zp(i+1) by
     1-cf(j), cf(j).


# name: <cell-element>
# type: string
# elements: 1
# length: 36
spanwise inerpolation of polar data.

