Consider a sailplane:

span (b)	2m	6.57ft
weight (W)	0.9kg	2lb
wing-area (S)	0.37m2	4ft2

The airspeed required for straight and level flight, at a Cl of 1.0, is:

V	=	[W / (0.5 r S Cl)] 1/2
	=	20.5 ft/sec

Now consider the sailplane in a 60^o banked turn. (q = 60). Because not all of the lift is vertical, the airspeed must increase.

V	=	[ (W / cos(q)) / (½ r S Cl) ] ½
	=	29.0 ft/sec

The radius of the turn is depends only on airspeed (V) and bank angle (q). (See Soaring in a Thermal: Bank Angle, Speed, and Radius Larry Bogan - Aug 1998).

R	=	V 2 / (G * tan(q)
	=	15.17 ft

This is turn radius at the center of the sailplane. The turning radius is obviously small at the inner wingtip, and larger at the outer wingtip. The airspeed at varying radii depends on the average airspeed (V), average radius (R), and the variation from the average radius (r).

Vr

=

V (R + r) / R

The bank angle of the wing itself must also be considered when determining the actual turn radius at each chord position, y, on the wing.

Vy

=

V (R + y cos(q)) / R

The following table calculates the turning radius and the airspeed at each of eight chord positions, V_y, given the required average airspeed, V at a 60^o bank angle.

Span Index	Span Position	Horizontal Span Position	Turn Radius	Airspeed
0	-2.87	-1.44	13.74	26.25
1	-2.05	-1.03	14.15	27.04
2	-1.23	-0.62	14.56	27.82
3	-0.41	-0.21	14.97	28.61
4	0.41	0.21	15.38	29.39
5	1.23	0.62	15.79	30.18
6	2.05	1.03	16.20	30.96
7	2.87	1.44	16.61	31.75

The above airspeed value would be used in a VLM implementation to determine the lift distribution of such a sailplane while circling as described.

The following equations determine various velocities for a banked circling aircraft. They include the sink velocity used to determine the local sink rate at any position along the wing span. This in turn, is used to determine a local angle-of-decent (Aod) which can be used to adjust the local angle-of-attack (Aoa).

V	=	(W / (1/2 r S Cl)) 1/2	required straight and level airspeed to support aircraft
Vs	=	V / L/D	straight and level sink velocity
q			bank angle
Vc	=	V / cos(q)1/2	required circling airspeed
Vcs	=	Vs / cos(q)1.5	sink velocity while circling
R	=	Vc 2 / (G * tan(q))	turning radius
V y	=	Vc (R + y cos(q)) / R	local velocity at span position y
Aod y	=	atan (Vcs / Vy)	local angle-of-decent
Aoa'y	=	Aoa + Aod	locally adjusted angle-of-attack

# invert a matrix, solve for gamma -- C * gamma = alpha

awk '
BEGIN  {
		G      = 32.0
		PI     = 3.1416

		bank   = 60
		sinBk  = sin(bank *PI/180)
		cosBk  = cos(bank *PI/180)
		tanBk  = sinBk / cosBk

		printf "\tsinBk %8.3f\n", sinBk
		printf "\tcosBk %8.3f\n", cosBk
		printf "\ttanBk %8.3f\n", tanBk

		rho    = 0.002378
		weight = 2      # lbs
		area   = 4      # sq.ft.
		span   = 6.57   # ft  (2m)
		Cl     = 1.0

		vel    = sqrt((weight) / (0.5 * rho * area * Cl))
		printf "\tvel   %8.3f\n", vel

		vel    = sqrt((weight/cosBk) / (0.5 * rho * area * Cl))
		printf "\tvel   %8.3f\n", vel

		radius = (vel * vel) / (G * tanBk);
		printf "\tradius %8.3f\n", radius

		N  = 8
		dy = span / N
		K  = -((N/2) - 1/2)
		for (i = 0; i < N; i++)  {
			y = (K + i) * dy
			printf "   %d", i
			printf "   %6.2f", y 

			y *= cosBk
			printf "   %6.2f", y
			printf "   %6.2f", radius + y
			printf "   %6.2f", vel * (radius + y) / radius
			printf "\n"
		}
}

# --------------------------------------------------------------------
function adjust() {
		dy = span / N

		for (i = 0; i < N/2; i++)  {
			y = dy/2 + (dy * i)

			r = (radius + y) / radius
			v = vel * r
			alpha[N/2 + i] *= -4 * PI * v * r

			r = (radius - y) / radius
			v = vel * r
			alpha[N/2 - 1 - i] *= -4 * PI * v * r
		}
}

# --------------------------------------------------------------------
function calcCl () {
		dy = span / N

		for (j = 0; j < N; j++)  {
			cl[j] = gamma[j] * 8 * PI / dy
			printf " %8.4f", cl[j]
		}
		printf "\n"
}

# --------------------------------------------------------------------
function calcLift () {
		dy = span / N
		k  = -4 * PI * span * vel
		L  = 0

		printf "\n"
		for (j = 0; j < N; j++)  {
			g  = k * gamma[j]
			L += rho * vel * g * dy
			printf "  %8.2f gamma %8.2f g %8.2f L\n", gamma[j], g, L
		}
		printf "\n"
}

# --------------------------------------------------------------------
function displayVect (x) {
		printf "\n"
		for (j = 0; j < N; j++)
			printf "  %9.5f\n", x[j]
}

# --------------------------------------------------------------------
function display ()  {
		printf "\n"
		for (j = 0; j < N; j++)  {
			for (k = 0; k < N; k++)
				printf " %7.3f", C[j, k]

			printf "  %7.3f", alpha[j]
			printf "\n"
		}
}

# --------------------------------------------------------------------
function solve ()  {
			for (k = 0; k < N-1; k++)
				for (j = k+1; j < N; j++)  {
					m = C[j, k] / C[k, k];
	
					for (p = k; p < N; p++)  {
						C[j, p] -= m * C[k, p];
					}
	
					alpha[j] -= m * alpha[k];
				}	

			display()

			for (i = N-1; i >= 0; i--)  {
				sum = 0;
				for (j = i+1; j < N; j++)  {
					sum += C[i, j] * gamma[j];
				}
	
				gamma [i] = (alpha[i] - sum) / C[i, i];
			}
}

# --------------------------------------------------------------------

{
		j = NR -1
		for (k = 0; k < NF-1; k++)
			C[j, k] = $(k+1)

		gamma[j] = 1
		alpha[j] = $NF

		N = NR
}

END  {
		display()

		# adjust()
		displayVect(alpha)

		solve()
		displayVect(gamma)

		calcLift()

		# calcCl()
		# displayVect(cl)
}' $*