Index: trunk/ppSub/TO_DO
===================================================================
--- trunk/ppSub/TO_DO	(revision 14508)
+++ trunk/ppSub/TO_DO	(revision 14548)
@@ -118,2 +118,60 @@
 multiple direction cuts to ensure the full range of required Gaussian
 widths is obtained.
+
+Fitting the normalisation of a single kernel component, k(u) and the
+background, we obtain the least-squares matrix and vector:
+
+M = ( sum_x C(x)^2/sigma(x)^2    sum_x C(x)/sigma(x)^2 )
+    ( sum_x C(x)/sigma(x)^2      sum_x 1/sigma(x)^2    )
+
+v = ( sum_x I(x)C(x)/sigma(x)^2   sum_x I(x)/sigma(x)^2 )
+
+where C(x) = R(x) * k(u)
+
+Inverting the matrix, multiplying by the vector and taking the
+component corresponding to the kernel normalisation, we get:
+
+f = (ab - cd) / (ae - c^2)
+
+where
+
+a = sum_x 1/sigma(x)^2
+b = sum_x I(x)C(x)/sigma(x)^2
+c = sum_x C(x)/sigma(x)^2
+d = sum_x I(x)/simga(x)^2
+e = sum_x C(x)^2/sigma(x)^2
+
+Note that a and d are independent of the kernel, and so may be
+measured once only.  Note that we are ignoring any spatial variation
+of the kernel here --- we are only interested in which kernel
+components should be in the final solution, not the details of that
+solution.
+
+Assuming that the kernel components are normalised, the kernel
+component normalisation, f, is a measure of how important that kernel
+component is in the final solution of the full problem.  The following
+algorithm is suggested:
+
+(a) For each original kernel component, extract a vector at 0, 45 and
+    90 degrees (x, y and x-y axes).  Ignore one of these sub-kernels
+    in what follows if the standard deviation of the subkernel is
+    zero.  We use these three extraction angles to cover the u, v and
+    uv terms.
+
+(b) For each stamp, extract a vector at 0, 45, and 90 degrees (x, y,
+    and x-y axes).  These sub-stamps go with the corresponding
+    sub-kernel.
+
+(c) For each kernel component, measure b, c, e and therefore determine
+    the kernel normalisation, f.  Use the sub-kernel appropriate for
+    the sub-stamp (matched by extraction angle), and accumulate the
+    values together (sub-kernels all contribute to the same original
+    kernel component).
+
+(d) Take the kernel component with the largest |f| as the 'winner' of
+    this iteration.  Apply this kernel to the sub-stamps for R(x), and
+    mark this kernel component in the list.  It is part of the end
+    solution, but should not be used any more in the iteration.
+
+(e) Repeat from step (c) until the largest |f| is small, say 10^-3 of
+    the first obtained value of |f|.