ROOT logo
// @(#)root/spectrum:$Id: TSpectrum2Transform.cxx 30749 2009-10-15 16:33:04Z brun $
// Author: Miroslav Morhac   25/09/06

//__________________________________________________________________________
//   THIS CLASS CONTAINS 2-DIMENSIONAL ORTHOGONAL TRANSFORM  FUNCTIONS.    //
//                                                                         //
//   These functions were written by:                                      //
//   Miroslav Morhac                                                       //
//   Institute of Physics                                                  //
//   Slovak Academy of Sciences                                            //
//   Dubravska cesta 9, 842 28 BRATISLAVA                                  //
//   SLOVAKIA                                                              //
//                                                                         //
//   email:fyzimiro@savba.sk,    fax:+421 7 54772479                       //
//                                                                         //
//  The original code in C has been repackaged as a C++ class by R.Brun    //
//                                                                         //
//  The algorithms in this class have been published in the following      //
//  references:                                                            //
//                                                                         //
//  [1] C.V. Hampton, B. Lian, Wm. C. McHarris: Fast-Fourier-transform     //
//      spectral enhancement techniques for gamma-ray spectroscopy.NIM A353//
//      (1994) 280-284.                                                    //
//  [2] Morhac M., Matousek V., New adaptive Cosine-Walsh  transform and   //
//      its application to nuclear data compression, IEEE Transactions on  //
//      Signal Processing 48 (2000) 2693.                                  //  
//  [3] Morhac M., Matousek V., Data compression using new fast adaptive   //
//      Cosine-Haar transforms, Digital Signal Processing 8 (1998) 63.     //
//  [4] Morhac M., Matousek V.: Multidimensional nuclear data compression  //
//      using fast adaptive Walsh-Haar transform. Acta Physica Slovaca 51  //
//     (2001) 307.                                                         //
//____________________________________________________________________________

#include "TSpectrum2Transform.h"
#include "TMath.h"

ClassImp(TSpectrum2Transform)  
    
//____________________________________________________________________________    
TSpectrum2Transform::TSpectrum2Transform() 
{
   //default constructor
}

//____________________________________________________________________________    
TSpectrum2Transform::TSpectrum2Transform(Int_t sizeX, Int_t sizeY) :TObject()
{
//the constructor creates TSpectrum2Transform object. Its sizes must be > than zero and must be power of 2.
//It sets default transform type to be Cosine transform. Transform parameters can be changed using setter functions.   
   Int_t j1, j2, n;
   if (sizeX <= 0 || sizeY <= 0){
      Error ("TSpectrumTransform","Invalid length, must be > than 0");
      return;
   }    
   j1 = 0;
   n = 1;
   for (; n < sizeX;) {
      j1 += 1;
      n = n * 2;
   }
   if (n != sizeX){
      Error ("TSpectrumTransform","Invalid length, must be power of 2");
      return;   
   }
   j2 = 0;
   n = 1;
   for (; n < sizeY;) {
      j2 += 1;
      n = n * 2;
   }
   if (n != sizeY){
      Error ("TSpectrumTransform","Invalid length, must be power of 2");
      return;   
   }   
   fSizeX = sizeX, fSizeY = sizeY;
   fTransformType = kTransformCos;
   fDegree = 0;
   fDirection = kTransformForward;
   fXmin = sizeX/4;
   fXmax = sizeX-1;
   fYmin = sizeY/4;
   fYmax = sizeY-1;   
   fFilterCoeff=0;
   fEnhanceCoeff=0.5;
}


//______________________________________________________________________________
TSpectrum2Transform::~TSpectrum2Transform() 
{
   //destructor
}


//////////AUXILIARY FUNCTIONS FOR TRANSFORM BASED FUNCTIONS////////////////////////
//_____________________________________________________________________________
void TSpectrum2Transform::Haar(Float_t *working_space, Int_t num, Int_t direction) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function calculates Haar transform of a part of data                   //
//      Function parameters:                                                    //
//              -working_space-pointer to vector of transformed data            //
//              -num-length of processed data                                   //
//              -direction-forward or inverse transform                         //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t i, ii, li, l2, l3, j, jj, jj1, lj, iter, m, jmin, jmax;
   Double_t a, b, c, wlk;
   Float_t val;
   for (i = 0; i < num; i++)
      working_space[i + num] = 0;
   i = num;
   iter = 0;
   for (; i > 1;) {
      iter += 1;
      i = i / 2;
   }
   if (direction == kTransformForward) {
      for (m = 1; m <= iter; m++) {
         li = iter + 1 - m;
         l2 = (Int_t) TMath::Power(2, li - 1);
         for (i = 0; i < (2 * l2); i++) {
            working_space[num + i] = working_space[i];
         }
         for (j = 0; j < l2; j++) {
            l3 = l2 + j;
            jj = 2 * j;
            val = working_space[jj + num] + working_space[jj + 1 + num];
            working_space[j] = val;
            val = working_space[jj + num] - working_space[jj + 1 + num];
            working_space[l3] = val;
         }
      }
   }
   val = working_space[0];
   val = val / TMath::Sqrt(TMath::Power(2, iter));
   working_space[0] = val;
   val = working_space[1];
   val = val / TMath::Sqrt(TMath::Power(2, iter));
   working_space[1] = val;
   for (ii = 2; ii <= iter; ii++) {
      i = ii - 1;
      wlk = 1 / TMath::Sqrt(TMath::Power(2, iter - i));
      jmin = (Int_t) TMath::Power(2, i);
      jmax = (Int_t) TMath::Power(2, ii) - 1;
      for (j = jmin; j <= jmax; j++) {
         val = working_space[j];
         a = val;
         a = a * wlk;
         val = a;
         working_space[j] = val;
      }
   }
   if (direction == kTransformInverse) {
      for (m = 1; m <= iter; m++) {
         a = 2;
         b = m - 1;
         c = TMath::Power(a, b);
         li = (Int_t) c;
         for (i = 0; i < (2 * li); i++) {
            working_space[i + num] = working_space[i];
         }
         for (j = 0; j < li; j++) {
            lj = li + j;
            jj = 2 * (j + 1) - 1;
            jj1 = jj - 1;
            val = working_space[j + num] - working_space[lj + num];
            working_space[jj] = val;
            val = working_space[j + num] + working_space[lj + num];
            working_space[jj1] = val;
         }
      }
   }
   return;
}

//_____________________________________________________________________________
void TSpectrum2Transform::Walsh(Float_t *working_space, Int_t num) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function calculates Walsh transform of a part of data                  //
//      Function parameters:                                                    //
//              -working_space-pointer to vector of transformed data            //
//              -num-length of processed data                                   //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t i, m, nump = 1, mnum, mnum2, mp, ib, mp2, mnum21, iba, iter;
   Double_t a;
   Float_t val1, val2;
   for (i = 0; i < num; i++)
      working_space[i + num] = 0;
   i = num;
   iter = 0;
   for (; i > 1;) {
      iter += 1;
      i = i / 2;
   }
   for (m = 1; m <= iter; m++) {
      if (m == 1)
         nump = 1;
      
      else
         nump = nump * 2;
      mnum = num / nump;
      mnum2 = mnum / 2;
      for (mp = 0; mp < nump; mp++) {
         ib = mp * mnum;
         for (mp2 = 0; mp2 < mnum2; mp2++) {
            mnum21 = mnum2 + mp2 + ib;
            iba = ib + mp2;
            val1 = working_space[iba];
            val2 = working_space[mnum21];
            working_space[iba + num] = val1 + val2;
            working_space[mnum21 + num] = val1 - val2;
         }
      }
      for (i = 0; i < num; i++) {
         working_space[i] = working_space[i + num];
      }
   }
   a = num;
   a = TMath::Sqrt(a);
   val2 = a;
   for (i = 0; i < num; i++) {
      val1 = working_space[i];
      val1 = val1 / val2;
      working_space[i] = val1;
   }
   return;
}

//_____________________________________________________________________________
void TSpectrum2Transform::BitReverse(Float_t *working_space, Int_t num) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function carries out bir-reverse reordering of data                    //
//      Function parameters:                                                    //
//              -working_space-pointer to vector of processed data              //
//              -num-length of processed data                                   //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t ipower[26];
   Int_t i, ib, il, ibd, ip, ifac, i1;
   for (i = 0; i < num; i++) {
      working_space[i + num] = working_space[i];
   }
   for (i = 1; i <= num; i++) {
      ib = i - 1;
      il = 1;
      lab9: ibd = ib / 2;
      ipower[il - 1] = 1;
      if (ib == (ibd * 2))
         ipower[il - 1] = 0;
      if (ibd == 0)
         goto lab10;
      ib = ibd;
      il = il + 1;
      goto lab9;
      lab10: ip = 1;
      ifac = num;
      for (i1 = 1; i1 <= il; i1++) {
         ifac = ifac / 2;
         ip = ip + ifac * ipower[i1 - 1];
      }
      working_space[ip - 1] = working_space[i - 1 + num];
   }
   return;
}

//_____________________________________________________________________________
void TSpectrum2Transform::Fourier(Float_t *working_space, Int_t num, Int_t hartley,
                           Int_t direction, Int_t zt_clear) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function calculates Fourier based transform of a part of data          //
//      Function parameters:                                                    //
//              -working_space-pointer to vector of transformed data            //
//              -num-length of processed data                                   //
//              -hartley-1 if it is Hartley transform, 0 othewise               //
//              -direction-forward or inverse transform                         //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t nxp2, nxp, i, j, k, m, iter, mxp, j1, j2, n1, n2, it;
   Double_t a, b, c, d, sign, wpwr, arg, wr, wi, tr, ti, pi =
       3.14159265358979323846;
   Float_t val1, val2, val3, val4;
   if (direction == kTransformForward && zt_clear == 0) {
      for (i = 0; i < num; i++)
         working_space[i + num] = 0;
   }
   i = num;
   iter = 0;
   for (; i > 1;) {
      iter += 1;
      i = i / 2;
   }
   sign = -1;
   if (direction == kTransformInverse)
      sign = 1;
   nxp2 = num;
   for (it = 1; it <= iter; it++) {
      nxp = nxp2;
      nxp2 = nxp / 2;
      a = nxp2;
      wpwr = pi / a;
      for (m = 1; m <= nxp2; m++) {
         a = m - 1;
         arg = a * wpwr;
         wr = TMath::Cos(arg);
         wi = sign * TMath::Sin(arg);
         for (mxp = nxp; mxp <= num; mxp += nxp) {
            j1 = mxp - nxp + m;
            j2 = j1 + nxp2;
            val1 = working_space[j1 - 1];
            val2 = working_space[j2 - 1];
            val3 = working_space[j1 - 1 + num];
            val4 = working_space[j2 - 1 + num];
            a = val1;
            b = val2;
            c = val3;
            d = val4;
            tr = a - b;
            ti = c - d;
            a = a + b;
            val1 = a;
            working_space[j1 - 1] = val1;
            c = c + d;
            val1 = c;
            working_space[j1 - 1 + num] = val1;
            a = tr * wr - ti * wi;
            val1 = a;
            working_space[j2 - 1] = val1;
            a = ti * wr + tr * wi;
            val1 = a;
            working_space[j2 - 1 + num] = val1;
         }
      }
   }
   n2 = num / 2;
   n1 = num - 1;
   j = 1;
   for (i = 1; i <= n1; i++) {
      if (i >= j)
         goto lab55;
      val1 = working_space[j - 1];
      val2 = working_space[j - 1 + num];
      val3 = working_space[i - 1];
      working_space[j - 1] = val3;
      working_space[j - 1 + num] = working_space[i - 1 + num];
      working_space[i - 1] = val1;
      working_space[i - 1 + num] = val2;
      lab55: k = n2;
      lab60: if (k >= j) goto lab65;
      j = j - k;
      k = k / 2;
      goto lab60;
      lab65: j = j + k;
   }
   a = num;
   a = TMath::Sqrt(a);
   for (i = 0; i < num; i++) {
      if (hartley == 0) {
         val1 = working_space[i];
         b = val1;
         b = b / a;
         val1 = b;
         working_space[i] = val1;
         b = working_space[i + num];
         b = b / a;
         working_space[i + num] = b;
      }
      
      else {
         b = working_space[i];
         c = working_space[i + num];
         b = (b + c) / a;
         working_space[i] = b;
         working_space[i + num] = 0;
      }
   }
   if (hartley == 1 && direction == kTransformInverse) {
      for (i = 1; i < num; i++)
         working_space[num - i + num] = working_space[i];
      working_space[0 + num] = working_space[0];
      for (i = 0; i < num; i++) {
         working_space[i] = working_space[i + num];
         working_space[i + num] = 0;
      }
   }
   return;
}

//_____________________________________________________________________________
void TSpectrum2Transform::BitReverseHaar(Float_t *working_space, Int_t shift, Int_t num,
                                  Int_t start) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function carries out bir-reverse reordering for Haar transform         //
//      Function parameters:                                                    //
//              -working_space-pointer to vector of processed data              //
//              -shift-shift of position of processing                          //
//              -start-initial position of processed data                       //
//              -num-length of processed data                                   //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t ipower[26];
   Int_t i, ib, il, ibd, ip, ifac, i1;
   for (i = 0; i < num; i++) {
      working_space[i + shift + start] = working_space[i + start];
      working_space[i + shift + start + 2 * shift] =
          working_space[i + start + 2 * shift];
   }
   for (i = 1; i <= num; i++) {
      ib = i - 1;
      il = 1;
      lab9:  ibd = ib / 2;
      ipower[il - 1] = 1;
      if (ib == (ibd * 2))
         ipower[il - 1] = 0;
      if (ibd == 0)
         goto lab10;
      ib = ibd;
      il = il + 1;
      goto lab9;
      lab10:  ip = 1;
      ifac = num;
      for (i1 = 1; i1 <= il; i1++) {
         ifac = ifac / 2;
         ip = ip + ifac * ipower[i1 - 1];
      }
      working_space[ip - 1 + start] =
          working_space[i - 1 + shift + start];
      working_space[ip - 1 + start + 2 * shift] =
          working_space[i - 1 + shift + start + 2 * shift];
   }
   return;
}

//_____________________________________________________________________________
Int_t TSpectrum2Transform::GeneralExe(Float_t *working_space, Int_t zt_clear, Int_t num,
                             Int_t degree, Int_t type) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function calculates generalized (mixed) transforms of different degrees//
//      Function parameters:                                                    //
//              -working_space-pointer to vector of transformed data            //
//              -zt_clear-flag to clear imaginary data before staring           //
//              -num-length of processed data                                   //
//              -degree-degree of transform (see manual)                        //
//              -type-type of mixed transform (see manual)                      //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t i, j, k, m, nump, mnum, mnum2, mp, ib, mp2, mnum21, iba, iter,
       mp2step, mppom, ring;
   Double_t a, b, c, d, wpwr, arg, wr, wi, tr, ti, pi =
       3.14159265358979323846;
   Float_t val1, val2, val3, val4, a0oldr = 0, b0oldr = 0, a0r, b0r;
   if (zt_clear == 0) {
      for (i = 0; i < num; i++)
         working_space[i + 2 * num] = 0;
   }
   i = num;
   iter = 0;
   for (; i > 1;) {
      iter += 1;
      i = i / 2;
   }
   a = num;
   wpwr = 2.0 * pi / a;
   nump = num;
   mp2step = 1;
   ring = num;
   for (i = 0; i < iter - degree; i++)
      ring = ring / 2;
   for (m = 1; m <= iter; m++) {
      nump = nump / 2;
      mnum = num / nump;
      mnum2 = mnum / 2;
      if (m > degree
           && (type == kTransformFourierHaar
               || type == kTransformWalshHaar
               || type == kTransformCosHaar
               || type == kTransformSinHaar))
         mp2step *= 2;
      if (ring > 1)
         ring = ring / 2;
      for (mp = 0; mp < nump; mp++) {
         if (type != kTransformWalshHaar) {
            mppom = mp;
            mppom = mppom % ring;
            a = 0;
            j = 1;
            k = num / 4;
            for (i = 0; i < (iter - 1); i++) {
               if ((mppom & j) != 0)
                  a = a + k;
               j = j * 2;
               k = k / 2;
            }
            arg = a * wpwr;
            wr = TMath::Cos(arg);
            wi = TMath::Sin(arg);
         }
         
         else {
            wr = 1;
            wi = 0;
         }
         ib = mp * mnum;
         for (mp2 = 0; mp2 < mnum2; mp2++) {
            mnum21 = mnum2 + mp2 + ib;
            iba = ib + mp2;
            if (mp2 % mp2step == 0) {
               a0r = a0oldr;
               b0r = b0oldr;
               a0r = 1 / TMath::Sqrt(2.0);
               b0r = 1 / TMath::Sqrt(2.0);
            }
            
            else {
               a0r = 1;
               b0r = 0;
            }
            val1 = working_space[iba];
            val2 = working_space[mnum21];
            val3 = working_space[iba + 2 * num];
            val4 = working_space[mnum21 + 2 * num];
            a = val1;
            b = val2;
            c = val3;
            d = val4;
            tr = a * a0r + b * b0r;
            val1 = tr;
            working_space[num + iba] = val1;
            ti = c * a0r + d * b0r;
            val1 = ti;
            working_space[num + iba + 2 * num] = val1;
            tr =
                a * b0r * wr - c * b0r * wi - b * a0r * wr + d * a0r * wi;
            val1 = tr;
            working_space[num + mnum21] = val1;
            ti =
                c * b0r * wr + a * b0r * wi - d * a0r * wr - b * a0r * wi;
            val1 = ti;
            working_space[num + mnum21 + 2 * num] = val1;
         }
      }
      for (i = 0; i < num; i++) {
         val1 = working_space[num + i];
         working_space[i] = val1;
         val1 = working_space[num + i + 2 * num];
         working_space[i + 2 * num] = val1;
      }
   }
   return (0);
}

//_____________________________________________________________________________
Int_t TSpectrum2Transform::GeneralInv(Float_t *working_space, Int_t num, Int_t degree,
                             Int_t type) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function calculates inverse generalized (mixed) transforms             //
//      Function parameters:                                                    //
//              -working_space-pointer to vector of transformed data            //
//              -num-length of processed data                                   //
//              -degree-degree of transform (see manual)                        //
//              -type-type of mixed transform (see manual)                      //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t i, j, k, m, nump =
       1, mnum, mnum2, mp, ib, mp2, mnum21, iba, iter, mp2step, mppom,
       ring;
   Double_t a, b, c, d, wpwr, arg, wr, wi, tr, ti, pi =
       3.14159265358979323846;
   Float_t val1, val2, val3, val4, a0oldr = 0, b0oldr = 0, a0r, b0r;
   i = num;
   iter = 0;
   for (; i > 1;) {
      iter += 1;
      i = i / 2;
   }
   a = num;
   wpwr = 2.0 * pi / a;
   mp2step = 1;
   if (type == kTransformFourierHaar || type == kTransformWalshHaar
        || type == kTransformCosHaar || type == kTransformSinHaar) {
      for (i = 0; i < iter - degree; i++)
         mp2step *= 2;
   }
   ring = 1;
   for (m = 1; m <= iter; m++) {
      if (m == 1)
         nump = 1;
      
      else
         nump = nump * 2;
      mnum = num / nump;
      mnum2 = mnum / 2;
      if (m > iter - degree + 1)
         ring *= 2;
      for (mp = nump - 1; mp >= 0; mp--) {
         if (type != kTransformWalshHaar) {
            mppom = mp;
            mppom = mppom % ring;
            a = 0;
            j = 1;
            k = num / 4;
            for (i = 0; i < (iter - 1); i++) {
               if ((mppom & j) != 0)
                  a = a + k;
               j = j * 2;
               k = k / 2;
            }
            arg = a * wpwr;
            wr = TMath::Cos(arg);
            wi = TMath::Sin(arg);
         }
         
         else {
            wr = 1;
            wi = 0;
         }
         ib = mp * mnum;
         for (mp2 = 0; mp2 < mnum2; mp2++) {
            mnum21 = mnum2 + mp2 + ib;
            iba = ib + mp2;
            if (mp2 % mp2step == 0) {
               a0r = a0oldr;
               b0r = b0oldr;
               a0r = 1 / TMath::Sqrt(2.0);
               b0r = 1 / TMath::Sqrt(2.0);
            }
            
            else {
               a0r = 1;
               b0r = 0;
            }
            val1 = working_space[iba];
            val2 = working_space[mnum21];
            val3 = working_space[iba + 2 * num];
            val4 = working_space[mnum21 + 2 * num];
            a = val1;
            b = val2;
            c = val3;
            d = val4;
            tr = a * a0r + b * wr * b0r + d * wi * b0r;
            val1 = tr;
            working_space[num + iba] = val1;
            ti = c * a0r + d * wr * b0r - b * wi * b0r;
            val1 = ti;
            working_space[num + iba + 2 * num] = val1;
            tr = a * b0r - b * wr * a0r - d * wi * a0r;
            val1 = tr;
            working_space[num + mnum21] = val1;
            ti = c * b0r - d * wr * a0r + b * wi * a0r;
            val1 = ti;
            working_space[num + mnum21 + 2 * num] = val1;
         }
      }
      if (m <= iter - degree
           && (type == kTransformFourierHaar
               || type == kTransformWalshHaar
               || type == kTransformCosHaar
               || type == kTransformSinHaar))
         mp2step /= 2;
      for (i = 0; i < num; i++) {
         val1 = working_space[num + i];
         working_space[i] = val1;
         val1 = working_space[num + i + 2 * num];
         working_space[i + 2 * num] = val1;
      }
   }
   return (0);
}

//_____________________________________________________________________________
void TSpectrum2Transform::HaarWalsh2(Float_t **working_matrix,
                              Float_t *working_vector, Int_t numx, Int_t numy,
                              Int_t direction, Int_t type) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function calculates 2D Haar and Walsh transforms                       //
//      Function parameters:                                                    //
//              -working_matrix-pointer to matrix of transformed data           //
//              -working_vector-pointer to vector where the data are processed  //
//              -numx,numy-lengths of processed data                            //
//              -direction-forward or inverse                                   //
//              -type-type of transform (see manual)                            //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t i, j;
   if (direction == kTransformForward) {
      for (j = 0; j < numy; j++) {
         for (i = 0; i < numx; i++) {
            working_vector[i] = working_matrix[i][j];
         }
         switch (type) {
         case kTransformHaar:
            Haar(working_vector, numx, kTransformForward);
            break;
         case kTransformWalsh:
            Walsh(working_vector, numx);
            BitReverse(working_vector, numx);
            break;
         }
         for (i = 0; i < numx; i++) {
            working_matrix[i][j] = working_vector[i];
         }
      }
      for (i = 0; i < numx; i++) {
         for (j = 0; j < numy; j++) {
            working_vector[j] = working_matrix[i][j];
         }
         switch (type) {
         case kTransformHaar:
            Haar(working_vector, numy, kTransformForward);
            break;
         case kTransformWalsh:
            Walsh(working_vector, numy);
            BitReverse(working_vector, numy);
            break;
         }
         for (j = 0; j < numy; j++) {
            working_matrix[i][j] = working_vector[j];
         }
      }
   }
   
   else if (direction == kTransformInverse) {
      for (i = 0; i < numx; i++) {
         for (j = 0; j < numy; j++) {
            working_vector[j] = working_matrix[i][j];
         }
         switch (type) {
         case kTransformHaar:
            Haar(working_vector, numy, kTransformInverse);
            break;
         case kTransformWalsh:
            BitReverse(working_vector, numy);
            Walsh(working_vector, numy);
            break;
         }
         for (j = 0; j < numy; j++) {
            working_matrix[i][j] = working_vector[j];
         }
      }
      for (j = 0; j < numy; j++) {
         for (i = 0; i < numx; i++) {
            working_vector[i] = working_matrix[i][j];
         }
         switch (type) {
         case kTransformHaar:
            Haar(working_vector, numx, kTransformInverse);
            break;
         case kTransformWalsh:
            BitReverse(working_vector, numx);
            Walsh(working_vector, numx);
            break;
         }
         for (i = 0; i < numx; i++) {
            working_matrix[i][j] = working_vector[i];
         }
      }
   }
   return;
}

//_____________________________________________________________________________
void TSpectrum2Transform::FourCos2(Float_t **working_matrix, Float_t *working_vector,
                            Int_t numx, Int_t numy, Int_t direction, Int_t type) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function calculates 2D Fourier based transforms                        //
//      Function parameters:                                                    //
//              -working_matrix-pointer to matrix of transformed data           //
//              -working_vector-pointer to vector where the data are processed  //
//              -numx,numy-lengths of processed data                            //
//              -direction-forward or inverse                                   //
//              -type-type of transform (see manual)                            //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t i, j, iterx, itery, n, size;
   Double_t pi = 3.14159265358979323846;
   j = 0;
   n = 1;
   for (; n < numx;) {
      j += 1;
      n = n * 2;
   }
   j = 0;
   n = 1;
   for (; n < numy;) {
      j += 1;
      n = n * 2;
   }
   i = numx;
   iterx = 0;
   for (; i > 1;) {
      iterx += 1;
      i = i / 2;
   }
   i = numy;
   itery = 0;
   for (; i > 1;) {
      itery += 1;
      i = i / 2;
   }
   size = numx;
   if (size < numy)
      size = numy;
   if (direction == kTransformForward) {
      for (j = 0; j < numy; j++) {
         for (i = 0; i < numx; i++) {
            working_vector[i] = working_matrix[i][j];
         }
         switch (type) {
         case kTransformCos:
            for (i = 1; i <= numx; i++) {
               working_vector[2 * numx - i] = working_vector[i - 1];
            }
            Fourier(working_vector, 2 * numx, 0, kTransformForward, 0);
            for (i = 0; i < numx; i++) {
               working_vector[i] =
                   working_vector[i] / TMath::Cos(pi * i / (2 * numx));
            }
            working_vector[0] = working_vector[0] / TMath::Sqrt(2.);
            break;
         case kTransformSin:
            for (i = 1; i <= numx; i++) {
               working_vector[2 * numx - i] = -working_vector[i - 1];
            }
            Fourier(working_vector, 2 * numx, 0, kTransformForward, 0);
            for (i = 1; i < numx; i++) {
               working_vector[i - 1] =
                   working_vector[i] / TMath::Sin(pi * i / (2 * numx));
            }
            working_vector[numx - 1] =
                working_vector[numx] / TMath::Sqrt(2.);
            break;
         case kTransformFourier:
            Fourier(working_vector, numx, 0, kTransformForward, 0);
            break;
         case kTransformHartley:
            Fourier(working_vector, numx, 1, kTransformForward, 0);
            break;
         }
         for (i = 0; i < numx; i++) {
            working_matrix[i][j] = working_vector[i];
            if (type == kTransformFourier)
               working_matrix[i][j + numy] = working_vector[i + numx];
            
            else
               working_matrix[i][j + numy] = working_vector[i + 2 * numx];
         }
      }
      for (i = 0; i < numx; i++) {
         for (j = 0; j < numy; j++) {
            working_vector[j] = working_matrix[i][j];
            if (type == kTransformFourier)
               working_vector[j + numy] = working_matrix[i][j + numy];
            
            else
               working_vector[j + 2 * numy] = working_matrix[i][j + numy];
         }
         switch (type) {
         case kTransformCos:
            for (j = 1; j <= numy; j++) {
               working_vector[2 * numy - j] = working_vector[j - 1];
            }
            Fourier(working_vector, 2 * numy, 0, kTransformForward, 0);
            for (j = 0; j < numy; j++) {
               working_vector[j] =
                   working_vector[j] / TMath::Cos(pi * j / (2 * numy));
               working_vector[j + 2 * numy] = 0;
            }
            working_vector[0] = working_vector[0] / TMath::Sqrt(2.);
            break;
         case kTransformSin:
            for (j = 1; j <= numy; j++) {
               working_vector[2 * numy - j] = -working_vector[j - 1];
            }
            Fourier(working_vector, 2 * numy, 0, kTransformForward, 0);
            for (j = 1; j < numy; j++) {
               working_vector[j - 1] =
                   working_vector[j] / TMath::Sin(pi * j / (2 * numy));
               working_vector[j + numy] = 0;
            }
            working_vector[numy - 1] =
                working_vector[numy] / TMath::Sqrt(2.);
            working_vector[numy] = 0;
            break;
         case kTransformFourier:
            Fourier(working_vector, numy, 0, kTransformForward, 1);
            break;
         case kTransformHartley:
            Fourier(working_vector, numy, 1, kTransformForward, 0);
            break;
         }
         for (j = 0; j < numy; j++) {
            working_matrix[i][j] = working_vector[j];
            if (type == kTransformFourier)
               working_matrix[i][j + numy] = working_vector[j + numy];
            
            else
               working_matrix[i][j + numy] = working_vector[j + 2 * numy];
         }
      }
   }
   
   else if (direction == kTransformInverse) {
      for (i = 0; i < numx; i++) {
         for (j = 0; j < numy; j++) {
            working_vector[j] = working_matrix[i][j];
            if (type == kTransformFourier)
               working_vector[j + numy] = working_matrix[i][j + numy];
            
            else
               working_vector[j + 2 * numy] = working_matrix[i][j + numy];
         }
         switch (type) {
         case kTransformCos:
            working_vector[0] = working_vector[0] * TMath::Sqrt(2.);
            for (j = 0; j < numy; j++) {
               working_vector[j + 2 * numy] =
                   working_vector[j] * TMath::Sin(pi * j / (2 * numy));
               working_vector[j] =
                   working_vector[j] * TMath::Cos(pi * j / (2 * numy));
            }
            for (j = 1; j < numy; j++) {
               working_vector[2 * numy - j] = working_vector[j];
               working_vector[2 * numy - j + 2 * numy] =
                   -working_vector[j + 2 * numy];
            }
            working_vector[numy] = 0;
            working_vector[numy + 2 * numy] = 0;
            Fourier(working_vector, 2 * numy, 0, kTransformInverse, 1);
            break;
         case kTransformSin:
            working_vector[numy] =
                working_vector[numy - 1] * TMath::Sqrt(2.);
            for (j = numy - 1; j > 0; j--) {
               working_vector[j + 2 * numy] =
                   -working_vector[j -
                                   1] * TMath::Cos(pi * j / (2 * numy));
               working_vector[j] =
                   working_vector[j - 1] * TMath::Sin(pi * j / (2 * numy));
            }
            for (j = 1; j < numy; j++) {
               working_vector[2 * numy - j] = working_vector[j];
               working_vector[2 * numy - j + 2 * numy] =
                   -working_vector[j + 2 * numy];
            }
            working_vector[0] = 0;
            working_vector[0 + 2 * numy] = 0;
            working_vector[numy + 2 * numy] = 0;
            Fourier(working_vector, 2 * numy, 0, kTransformInverse, 1);
            break;
         case kTransformFourier:
            Fourier(working_vector, numy, 0, kTransformInverse, 1);
            break;
         case kTransformHartley:
            Fourier(working_vector, numy, 1, kTransformInverse, 1);
            break;
         }
         for (j = 0; j < numy; j++) {
            working_matrix[i][j] = working_vector[j];
            if (type == kTransformFourier)
               working_matrix[i][j + numy] = working_vector[j + numy];
            
            else
               working_matrix[i][j + numy] = working_vector[j + 2 * numy];
         }
      }
      for (j = 0; j < numy; j++) {
         for (i = 0; i < numx; i++) {
            working_vector[i] = working_matrix[i][j];
            if (type == kTransformFourier)
               working_vector[i + numx] = working_matrix[i][j + numy];
            
            else
               working_vector[i + 2 * numx] = working_matrix[i][j + numy];
         }
         switch (type) {
         case kTransformCos:
            working_vector[0] = working_vector[0] * TMath::Sqrt(2.);
            for (i = 0; i < numx; i++) {
               working_vector[i + 2 * numx] =
                   working_vector[i] * TMath::Sin(pi * i / (2 * numx));
               working_vector[i] =
                   working_vector[i] * TMath::Cos(pi * i / (2 * numx));
            }
            for (i = 1; i < numx; i++) {
               working_vector[2 * numx - i] = working_vector[i];
               working_vector[2 * numx - i + 2 * numx] =
                   -working_vector[i + 2 * numx];
            }
            working_vector[numx] = 0;
            working_vector[numx + 2 * numx] = 0;
            Fourier(working_vector, 2 * numx, 0, kTransformInverse, 1);
            break;
         case kTransformSin:
            working_vector[numx] =
                working_vector[numx - 1] * TMath::Sqrt(2.);
            for (i = numx - 1; i > 0; i--) {
               working_vector[i + 2 * numx] =
                   -working_vector[i -
                                   1] * TMath::Cos(pi * i / (2 * numx));
               working_vector[i] =
                   working_vector[i - 1] * TMath::Sin(pi * i / (2 * numx));
            }
            for (i = 1; i < numx; i++) {
               working_vector[2 * numx - i] = working_vector[i];
               working_vector[2 * numx - i + 2 * numx] =
                   -working_vector[i + 2 * numx];
            }
            working_vector[0] = 0;
            working_vector[0 + 2 * numx] = 0;
            working_vector[numx + 2 * numx] = 0;
            Fourier(working_vector, 2 * numx, 0, kTransformInverse, 1);
            break;
         case kTransformFourier:
            Fourier(working_vector, numx, 0, kTransformInverse, 1);
            break;
         case kTransformHartley:
            Fourier(working_vector, numx, 1, kTransformInverse, 1);
            break;
         }
         for (i = 0; i < numx; i++) {
            working_matrix[i][j] = working_vector[i];
         }
      }
   }
   return;
}

//_____________________________________________________________________________
void TSpectrum2Transform::General2(Float_t **working_matrix, Float_t *working_vector,
                            Int_t numx, Int_t numy, Int_t direction, Int_t type,
                            Int_t degree) 
{
//////////////////////////////////////////////////////////////////////////////////
//   AUXILIARY FUNCION                                                          //
//                                                                              //
//   This function calculates generalized (mixed) 2D transforms                  //
//      Function parameters:                                                    //
//              -working_matrix-pointer to matrix of transformed data           //
//              -working_vector-pointer to vector where the data are processed  //
//              -numx,numy-lengths of processed data                            //
//              -direction-forward or inverse                                   //
//              -type-type of transform (see manual)                            //
//              -degree-degree of transform (see manual)                        //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
   Int_t i, j, jstup, kstup, l, m;
   Float_t val, valx, valz;
   Double_t a, b, pi = 3.14159265358979323846;
   if (direction == kTransformForward) {
      for (j = 0; j < numy; j++) {
         kstup = (Int_t) TMath::Power(2, degree);
         jstup = numx / kstup;
         for (i = 0; i < numx; i++) {
            val = working_matrix[i][j];
            if (type == kTransformCosWalsh
                 || type == kTransformCosHaar) {
               jstup = (Int_t) TMath::Power(2, degree) / 2;
               kstup = i / jstup;
               kstup = 2 * kstup * jstup;
               working_vector[kstup + i % jstup] = val;
               working_vector[kstup + 2 * jstup - 1 - i % jstup] = val;
            }
            
            else if (type == kTransformSinWalsh
                     || type == kTransformSinHaar) {
               jstup = (Int_t) TMath::Power(2, degree) / 2;
               kstup = i / jstup;
               kstup = 2 * kstup * jstup;
               working_vector[kstup + i % jstup] = val;
               working_vector[kstup + 2 * jstup - 1 - i % jstup] = -val;
            }
            
            else
               working_vector[i] = val;
         }
         switch (type) {
         case kTransformFourierWalsh:
         case kTransformFourierHaar:
         case kTransformWalshHaar:
            GeneralExe(working_vector, 0, numx, degree, type);
            for (i = 0; i < jstup; i++)
               BitReverseHaar(working_vector, numx, kstup, i * kstup);
            break;
         case kTransformCosWalsh:
         case kTransformCosHaar:
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numx / m;
            for (i = 0; i < l; i++)
               BitReverseHaar(working_vector, 2 * numx, m, i * m);
            GeneralExe(working_vector, 0, 2 * numx, degree, type);
            for (i = 0; i < numx; i++) {
               kstup = i / jstup;
               kstup = 2 * kstup * jstup;
               a = pi * (Double_t) (i % jstup) / (Double_t) (2 * jstup);
               a = TMath::Cos(a);
               b = working_vector[kstup + i % jstup];
               if (i % jstup == 0)
                  a = b / TMath::Sqrt(2.0);
               
               else
                  a = b / a;
               working_vector[i] = a;
               working_vector[i + 4 * numx] = 0;
            }
            break;
         case kTransformSinWalsh:
         case kTransformSinHaar:
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numx / m;
            for (i = 0; i < l; i++)
               BitReverseHaar(working_vector, 2 * numx, m, i * m);
            GeneralExe(working_vector, 0, 2 * numx, degree, type);
            for (i = 0; i < numx; i++) {
               kstup = i / jstup;
               kstup = 2 * kstup * jstup;
               a = pi * (Double_t) (i % jstup) / (Double_t) (2 * jstup);
               a = TMath::Cos(a);
               b = working_vector[jstup + kstup + i % jstup];
               if (i % jstup == 0)
                  a = b / TMath::Sqrt(2.0);
               
               else
                  a = b / a;
               working_vector[jstup + kstup / 2 - i % jstup - 1] = a;
               working_vector[i + 4 * numx] = 0;
            }
            break;
         }
         if (type > kTransformWalshHaar)
            kstup = (Int_t) TMath::Power(2, degree - 1);
         
         else
            kstup = (Int_t) TMath::Power(2, degree);
         jstup = numx / kstup;
         for (i = 0, l = 0; i < numx; i++, l = (l + kstup) % numx) {
            working_vector[numx + i] = working_vector[l + i / jstup];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[numx + i + 2 * numx] =
                   working_vector[l + i / jstup + 2 * numx];
            
            else
               working_vector[numx + i + 4 * numx] =
                   working_vector[l + i / jstup + 4 * numx];
         }
         for (i = 0; i < numx; i++) {
            working_vector[i] = working_vector[numx + i];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[i + 2 * numx] =
                   working_vector[numx + i + 2 * numx];
            
            else
               working_vector[i + 4 * numx] =
                   working_vector[numx + i + 4 * numx];
         }
         for (i = 0; i < numx; i++) {
            working_matrix[i][j] = working_vector[i];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_matrix[i][j + numy] = working_vector[i + 2 * numx];
            
            else
               working_matrix[i][j + numy] = working_vector[i + 4 * numx];
         }
      }
      for (i = 0; i < numx; i++) {
         kstup = (Int_t) TMath::Power(2, degree);
         jstup = numy / kstup;
         for (j = 0; j < numy; j++) {
            valx = working_matrix[i][j];
            valz = working_matrix[i][j + numy];
            if (type == kTransformCosWalsh
                 || type == kTransformCosHaar) {
               jstup = (Int_t) TMath::Power(2, degree) / 2;
               kstup = j / jstup;
               kstup = 2 * kstup * jstup;
               working_vector[kstup + j % jstup] = valx;
               working_vector[kstup + 2 * jstup - 1 - j % jstup] = valx;
               working_vector[kstup + j % jstup + 4 * numy] = valz;
               working_vector[kstup + 2 * jstup - 1 - j % jstup +
                               4 * numy] = valz;
            }
            
            else if (type == kTransformSinWalsh
                     || type == kTransformSinHaar) {
               jstup = (Int_t) TMath::Power(2, degree) / 2;
               kstup = j / jstup;
               kstup = 2 * kstup * jstup;
               working_vector[kstup + j % jstup] = valx;
               working_vector[kstup + 2 * jstup - 1 - j % jstup] = -valx;
               working_vector[kstup + j % jstup + 4 * numy] = valz;
               working_vector[kstup + 2 * jstup - 1 - j % jstup +
                               4 * numy] = -valz;
            }
            
            else {
               working_vector[j] = valx;
               working_vector[j + 2 * numy] = valz;
            }
         }
         switch (type) {
         case kTransformFourierWalsh:
         case kTransformFourierHaar:
         case kTransformWalshHaar:
            GeneralExe(working_vector, 1, numy, degree, type);
            for (j = 0; j < jstup; j++)
               BitReverseHaar(working_vector, numy, kstup, j * kstup);
            break;
         case kTransformCosWalsh:
         case kTransformCosHaar:
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numy / m;
            for (j = 0; j < l; j++)
               BitReverseHaar(working_vector, 2 * numy, m, j * m);
            GeneralExe(working_vector, 1, 2 * numy, degree, type);
            for (j = 0; j < numy; j++) {
               kstup = j / jstup;
               kstup = 2 * kstup * jstup;
               a = pi * (Double_t) (j % jstup) / (Double_t) (2 * jstup);
               a = TMath::Cos(a);
               b = working_vector[kstup + j % jstup];
               if (j % jstup == 0)
                  a = b / TMath::Sqrt(2.0);
               
               else
                  a = b / a;
               working_vector[j] = a;
               working_vector[j + 4 * numy] = 0;
            }
            break;
         case kTransformSinWalsh:
         case kTransformSinHaar:
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numy / m;
            for (j = 0; j < l; j++)
               BitReverseHaar(working_vector, 2 * numy, m, j * m);
            GeneralExe(working_vector, 1, 2 * numy, degree, type);
            for (j = 0; j < numy; j++) {
               kstup = j / jstup;
               kstup = 2 * kstup * jstup;
               a = pi * (Double_t) (j % jstup) / (Double_t) (2 * jstup);
               a = TMath::Cos(a);
               b = working_vector[jstup + kstup + j % jstup];
               if (j % jstup == 0)
                  a = b / TMath::Sqrt(2.0);
               
               else
                  a = b / a;
               working_vector[jstup + kstup / 2 - j % jstup - 1] = a;
               working_vector[j + 4 * numy] = 0;
            }
            break;
         }
         if (type > kTransformWalshHaar)
            kstup = (Int_t) TMath::Power(2, degree - 1);
         
         else
            kstup = (Int_t) TMath::Power(2, degree);
         jstup = numy / kstup;
         for (j = 0, l = 0; j < numy; j++, l = (l + kstup) % numy) {
            working_vector[numy + j] = working_vector[l + j / jstup];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[numy + j + 2 * numy] =
                   working_vector[l + j / jstup + 2 * numy];
            
            else
               working_vector[numy + j + 4 * numy] =
                   working_vector[l + j / jstup + 4 * numy];
         }
         for (j = 0; j < numy; j++) {
            working_vector[j] = working_vector[numy + j];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[j + 2 * numy] =
                   working_vector[numy + j + 2 * numy];
            
            else
               working_vector[j + 4 * numy] =
                   working_vector[numy + j + 4 * numy];
         }
         for (j = 0; j < numy; j++) {
            working_matrix[i][j] = working_vector[j];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_matrix[i][j + numy] = working_vector[j + 2 * numy];
            
            else
               working_matrix[i][j + numy] = working_vector[j + 4 * numy];
         }
      }
   }
   
   else if (direction == kTransformInverse) {
      for (i = 0; i < numx; i++) {
         kstup = (Int_t) TMath::Power(2, degree);
         jstup = numy / kstup;
         for (j = 0; j < numy; j++) {
            working_vector[j] = working_matrix[i][j];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[j + 2 * numy] = working_matrix[i][j + numy];
            
            else
               working_vector[j + 4 * numy] = working_matrix[i][j + numy];
         }
         if (type > kTransformWalshHaar)
            kstup = (Int_t) TMath::Power(2, degree - 1);
         
         else
            kstup = (Int_t) TMath::Power(2, degree);
         jstup = numy / kstup;
         for (j = 0, l = 0; j < numy; j++, l = (l + kstup) % numy) {
            working_vector[numy + l + j / jstup] = working_vector[j];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[numy + l + j / jstup + 2 * numy] =
                   working_vector[j + 2 * numy];
            
            else
               working_vector[numy + l + j / jstup + 4 * numy] =
                   working_vector[j + 4 * numy];
         }
         for (j = 0; j < numy; j++) {
            working_vector[j] = working_vector[numy + j];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[j + 2 * numy] =
                   working_vector[numy + j + 2 * numy];
            
            else
               working_vector[j + 4 * numy] =
                   working_vector[numy + j + 4 * numy];
         }
         switch (type) {
         case kTransformFourierWalsh:
         case kTransformFourierHaar:
         case kTransformWalshHaar:
            for (j = 0; j < jstup; j++)
               BitReverseHaar(working_vector, numy, kstup, j * kstup);
            GeneralInv(working_vector, numy, degree, type);
            break;
         case kTransformCosWalsh:
         case kTransformCosHaar:
            jstup = (Int_t) TMath::Power(2, degree) / 2;
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numy / m;
            for (j = 0; j < numy; j++) {
               kstup = j / jstup;
               kstup = 2 * kstup * jstup;
               a = pi * (Double_t) (j % jstup) / (Double_t) (2 * jstup);
               if (j % jstup == 0) {
                  working_vector[2 * numy + kstup + j % jstup] =
                      working_vector[j] * TMath::Sqrt(2.0);
                  working_vector[2 * numy + kstup + j % jstup +
                                  4 * numy] = 0;
               }
               
               else {
                  b = TMath::Sin(a);
                  a = TMath::Cos(a);
                  working_vector[2 * numy + kstup + j % jstup +
                                  4 * numy] =
                      -(Double_t) working_vector[j] * b;
                  working_vector[2 * numy + kstup + j % jstup] =
                      (Double_t) working_vector[j] * a;
            } } for (j = 0; j < numy; j++) {
               kstup = j / jstup;
               kstup = 2 * kstup * jstup;
               if (j % jstup == 0) {
                  working_vector[2 * numy + kstup + jstup] = 0;
                  working_vector[2 * numy + kstup + jstup + 4 * numy] = 0;
               }
               
               else {
                  working_vector[2 * numy + kstup + 2 * jstup -
                                  j % jstup] =
                      working_vector[2 * numy + kstup + j % jstup];
                  working_vector[2 * numy + kstup + 2 * jstup -
                                  j % jstup + 4 * numy] =
                      -working_vector[2 * numy + kstup + j % jstup +
                                      4 * numy];
               }
            }
            for (j = 0; j < 2 * numy; j++) {
               working_vector[j] = working_vector[2 * numy + j];
               working_vector[j + 4 * numy] =
                   working_vector[2 * numy + j + 4 * numy];
            }
            GeneralInv(working_vector, 2 * numy, degree, type);
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numy / m;
            for (j = 0; j < l; j++)
               BitReverseHaar(working_vector, 2 * numy, m, j * m);
            break;
         case kTransformSinWalsh:
         case kTransformSinHaar:
            jstup = (Int_t) TMath::Power(2, degree) / 2;
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numy / m;
            for (j = 0; j < numy; j++) {
               kstup = j / jstup;
               kstup = 2 * kstup * jstup;
               a = pi * (Double_t) (j % jstup) / (Double_t) (2 * jstup);
               if (j % jstup == 0) {
                  working_vector[2 * numy + kstup + jstup + j % jstup] =
                      working_vector[jstup + kstup / 2 - j % jstup -
                                     1] * TMath::Sqrt(2.0);
                  working_vector[2 * numy + kstup + jstup + j % jstup +
                                  4 * numy] = 0;
               }
               
               else {
                  b = TMath::Sin(a);
                  a = TMath::Cos(a);
                  working_vector[2 * numy + kstup + jstup + j % jstup +
                                  4 * numy] =
                      -(Double_t) working_vector[jstup + kstup / 2 -
                                               j % jstup - 1] * b;
                  working_vector[2 * numy + kstup + jstup + j % jstup] =
                      (Double_t) working_vector[jstup + kstup / 2 -
                                              j % jstup - 1] * a;
            } } for (j = 0; j < numy; j++) {
               kstup = j / jstup;
               kstup = 2 * kstup * jstup;
               if (j % jstup == 0) {
                  working_vector[2 * numy + kstup] = 0;
                  working_vector[2 * numy + kstup + 4 * numy] = 0;
               }
               
               else {
                  working_vector[2 * numy + kstup + j % jstup] =
                      working_vector[2 * numy + kstup + 2 * jstup -
                                     j % jstup];
                  working_vector[2 * numy + kstup + j % jstup +
                                  4 * numy] =
                      -working_vector[2 * numy + kstup + 2 * jstup -
                                      j % jstup + 4 * numy];
               }
            }
            for (j = 0; j < 2 * numy; j++) {
               working_vector[j] = working_vector[2 * numy + j];
               working_vector[j + 4 * numy] =
                   working_vector[2 * numy + j + 4 * numy];
            }
            GeneralInv(working_vector, 2 * numy, degree, type);
            for (j = 0; j < l; j++)
               BitReverseHaar(working_vector, 2 * numy, m, j * m);
            break;
         }
         for (j = 0; j < numy; j++) {
            if (type > kTransformWalshHaar) {
               kstup = j / jstup;
               kstup = 2 * kstup * jstup;
               valx = working_vector[kstup + j % jstup];
               valz = working_vector[kstup + j % jstup + 4 * numy];
            }
            
            else {
               valx = working_vector[j];
               valz = working_vector[j + 2 * numy];
            }
            working_matrix[i][j] = valx;
            working_matrix[i][j + numy] = valz;
         }
      }
      for (j = 0; j < numy; j++) {
         kstup = (Int_t) TMath::Power(2, degree);
         jstup = numy / kstup;
         for (i = 0; i < numx; i++) {
            working_vector[i] = working_matrix[i][j];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[i + 2 * numx] = working_matrix[i][j + numy];
            
            else
               working_vector[i + 4 * numx] = working_matrix[i][j + numy];
         }
         if (type > kTransformWalshHaar)
            kstup = (Int_t) TMath::Power(2, degree - 1);
         
         else
            kstup = (Int_t) TMath::Power(2, degree);
         jstup = numx / kstup;
         for (i = 0, l = 0; i < numx; i++, l = (l + kstup) % numx) {
            working_vector[numx + l + i / jstup] = working_vector[i];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[numx + l + i / jstup + 2 * numx] =
                   working_vector[i + 2 * numx];
            
            else
               working_vector[numx + l + i / jstup + 4 * numx] =
                   working_vector[i + 4 * numx];
         }
         for (i = 0; i < numx; i++) {
            working_vector[i] = working_vector[numx + i];
            if (type == kTransformFourierWalsh
                 || type == kTransformFourierHaar
                 || type == kTransformWalshHaar)
               working_vector[i + 2 * numx] =
                   working_vector[numx + i + 2 * numx];
            
            else
               working_vector[i + 4 * numx] =
                   working_vector[numx + i + 4 * numx];
         }
         switch (type) {
         case kTransformFourierWalsh:
         case kTransformFourierHaar:
         case kTransformWalshHaar:
            for (i = 0; i < jstup; i++)
               BitReverseHaar(working_vector, numx, kstup, i * kstup);
            GeneralInv(working_vector, numx, degree, type);
            break;
         case kTransformCosWalsh:
         case kTransformCosHaar:
            jstup = (Int_t) TMath::Power(2, degree) / 2;
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numx / m;
            for (i = 0; i < numx; i++) {
               kstup = i / jstup;
               kstup = 2 * kstup * jstup;
               a = pi * (Double_t) (i % jstup) / (Double_t) (2 * jstup);
               if (i % jstup == 0) {
                  working_vector[2 * numx + kstup + i % jstup] =
                      working_vector[i] * TMath::Sqrt(2.0);
                  working_vector[2 * numx + kstup + i % jstup +
                                  4 * numx] = 0;
               }
               
               else {
                  b = TMath::Sin(a);
                  a = TMath::Cos(a);
                  working_vector[2 * numx + kstup + i % jstup +
                                  4 * numx] =
                      -(Double_t) working_vector[i] * b;
                  working_vector[2 * numx + kstup + i % jstup] =
                      (Double_t) working_vector[i] * a;
            } } for (i = 0; i < numx; i++) {
               kstup = i / jstup;
               kstup = 2 * kstup * jstup;
               if (i % jstup == 0) {
                  working_vector[2 * numx + kstup + jstup] = 0;
                  working_vector[2 * numx + kstup + jstup + 4 * numx] = 0;
               }
               
               else {
                  working_vector[2 * numx + kstup + 2 * jstup -
                                  i % jstup] =
                      working_vector[2 * numx + kstup + i % jstup];
                  working_vector[2 * numx + kstup + 2 * jstup -
                                  i % jstup + 4 * numx] =
                      -working_vector[2 * numx + kstup + i % jstup +
                                      4 * numx];
               }
            }
            for (i = 0; i < 2 * numx; i++) {
               working_vector[i] = working_vector[2 * numx + i];
               working_vector[i + 4 * numx] =
                   working_vector[2 * numx + i + 4 * numx];
            }
            GeneralInv(working_vector, 2 * numx, degree, type);
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numx / m;
            for (i = 0; i < l; i++)
               BitReverseHaar(working_vector, 2 * numx, m, i * m);
            break;
         case kTransformSinWalsh:
         case kTransformSinHaar:
            jstup = (Int_t) TMath::Power(2, degree) / 2;
            m = (Int_t) TMath::Power(2, degree);
            l = 2 * numx / m;
            for (i = 0; i < numx; i++) {
               kstup = i / jstup;
               kstup = 2 * kstup * jstup;
               a = pi * (Double_t) (i % jstup) / (Double_t) (2 * jstup);
               if (i % jstup == 0) {
                  working_vector[2 * numx + kstup + jstup + i % jstup] =
                      working_vector[jstup + kstup / 2 - i % jstup -
                                     1] * TMath::Sqrt(2.0);
                  working_vector[2 * numx + kstup + jstup + i % jstup +
                                  4 * numx] = 0;
               }
               
               else {
                  b = TMath::Sin(a);
                  a = TMath::Cos(a);
                  working_vector[2 * numx + kstup + jstup + i % jstup +
                                  4 * numx] =
                      -(Double_t) working_vector[jstup + kstup / 2 -
                                               i % jstup - 1] * b;
                  working_vector[2 * numx + kstup + jstup + i % jstup] =
                      (Double_t) working_vector[jstup + kstup / 2 -
                                              i % jstup - 1] * a;
            } } for (i = 0; i < numx; i++) {
               kstup = i / jstup;
               kstup = 2 * kstup * jstup;
               if (i % jstup == 0) {
                  working_vector[2 * numx + kstup] = 0;
                  working_vector[2 * numx + kstup + 4 * numx] = 0;
               }
               
               else {
                  working_vector[2 * numx + kstup + i % jstup] =
                      working_vector[2 * numx + kstup + 2 * jstup -
                                     i % jstup];
                  working_vector[2 * numx + kstup + i % jstup +
                                  4 * numx] =
                      -working_vector[2 * numx + kstup + 2 * jstup -
                                      i % jstup + 4 * numx];
               }
            }
            for (i = 0; i < 2 * numx; i++) {
               working_vector[i] = working_vector[2 * numx + i];
               working_vector[i + 4 * numx] =
                   working_vector[2 * numx + i + 4 * numx];
            }
            GeneralInv(working_vector, 2 * numx, degree, type);
            for (i = 0; i < l; i++)
               BitReverseHaar(working_vector, 2 * numx, m, i * m);
            break;
         }
         for (i = 0; i < numx; i++) {
            if (type > kTransformWalshHaar) {
               kstup = i / jstup;
               kstup = 2 * kstup * jstup;
               val = working_vector[kstup + i % jstup];
            }
            
            else
               val = working_vector[i];
            working_matrix[i][j] = val;
         }
      }
   }
   return;
}

///////////////////////END OF AUXILIARY TRANSFORM2 FUNCTIONS//////////////////////////////////////////

    
//////////TRANSFORM2 FUNCTION - CALCULATES DIFFERENT 2-D DIRECT AND INVERSE ORTHOGONAL TRANSFORMS//////
//_____________________________________________________________________________
void TSpectrum2Transform::Transform(const Float_t **fSource, Float_t **fDest)
{
//////////////////////////////////////////////////////////////////////////////////////////
/* TWO-DIMENSIONAL TRANSFORM FUNCTION                    */ 
/* This function transforms the source spectrum. The calling program               */ 
/*      should fill in input parameters.                                          */ 
/* Transformed data are written into dest spectrum.                                */ 
/*                         */ 
/* Function parameters:                      */ 
/* fSource-pointer to the matrix of source spectrum, its size should               */ 
/*             be fSizex*fSizey except for inverse FOURIER, FOUR-WALSH, FOUR-HAAR       */ 
/*             transform. These need fSizex*2*fSizey length to supply real and          */ 
/*             imaginary coefficients.                                                  */ 
/* fDest-pointer to the matrix of destination data, its size should be             */ 
/*           fSizex*fSizey except for direct FOURIER, FOUR-WALSh, FOUR-HAAR. These      */ 
/*           need fSizex*2*fSizey length to store real and imaginary coefficients       */ 
/* fSizex,fSizey-basic dimensions of source and dest spectra                       */ 
/*                         */ 
//////////////////////////////////////////////////////////////////////////////////////////
//Begin_Html <!--
/* -->
<div class=Section1>

<p class=MsoNormal><b><span style='font-size:14.0pt'>Transform methods</span></b></p>

<p class=MsoNormal style='text-align:justify'><i>&nbsp;</i></p>

<p class=MsoNormal style='text-align:justify'><i>Goal: to analyze experimental
data using orthogonal transforms</i></p>

<p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
-18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span>orthogonal transforms can be successfully used for the processing of
nuclear spectra (not only) </p>

<p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
-18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span>they can be used to remove high frequency noise, to increase
signal-to-background ratio as well as to enhance low intensity components [1],
to carry out e.g. Fourier analysis etc. </p>

<p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
-18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span>we have implemented the function for the calculation of the commonly
used orthogonal transforms as well as functions for the filtration and
enhancement of experimental data</p>

<p class=MsoNormal><i>&nbsp;</i></p>

<p class=MsoNormal><i>Function:</i></p>

<p class=MsoNormal>void <a
href="http://root.cern.ch/root/html/TSpectrum.html#TSpectrum:Fit1Awmi"><b>TSpectrumTransform2::Transform</b></a><b>(const
<a href="http://root.cern.ch/root/html/ListOfTypes.html#float">float</a> **fSource,
<a href="http://root.cern.ch/root/html/ListOfTypes.html#float">float</a> **fDest)</b></p>

<p class=MsoNormal style='text-align:justify'>&nbsp;</p>

<p class=MsoNormal style='text-align:justify'>This function transforms the
source spectrum according to the given input parameters. Transformed data are
written into dest spectrum. Before the Transform function is called the class
must be created by constructor and the type of the transform as well as some
other parameters must be set using a set of setter functions:</p>

<p class=MsoNormal><span lang=FR>&nbsp;</span></p>

<p class=MsoNormal><i><span style='color:red'>Member variables of
TSpectrumTransform2 class:</span></i></p>

<p class=MsoNormal style='margin-left:25.65pt;text-align:justify'><b>fSource</b>-pointer
to the matrix of source spectrum. Its lengths should be equal to the “fSizex,
fSizey” parameters except for inverse FOURIER, FOUR-WALSH, FOUR-HAAR
transforms. These need “2*fSizex*fSizey” length to supply real and imaginary
coefficients.                   </p>

<p class=MsoNormal style='margin-left:25.65pt;text-align:justify'><b>fDest</b>-pointer
to the matrix of destination spectrum. Its lengths should be equal to the
“fSizex, fSizey” parameters except for inverse FOURIER, FOUR-WALSH, FOUR-HAAR
transforms. These need “2*fSizex*fSizey” length to store real and imaginary
coefficients. </p>

<p class=MsoNormal style='text-align:justify'>        <b>fSizeX,fSizeY</b>-basic
lengths of the source and dest spectra. They<span style='color:fuchsia'> should
be power  </span></p>

<p class=MsoNormal style='text-align:justify'><span style='color:fuchsia'>     
of 2.</span></p>

<p class=MsoNormal style='margin-left:25.65pt;text-align:justify;text-indent:
-2.85pt'><b>fType</b>-type of transform</p>

<p class=MsoNormal style='text-align:justify'>            Classic transforms:</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformHaar
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformWalsh
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformCos
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformSin
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformFourier
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformHartley
</p>

<p class=MsoNormal style='text-align:justify'>            Mixed transforms:</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformFourierWalsh
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformFourierHaar
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformWalshHaar
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformCosWalsh
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformCosHaar
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformSinWalsh
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformSinHaar
</p>

<p class=MsoNormal style='text-align:justify;text-indent:22.8pt'><b>fDirection</b>-direction-transform
direction (forward, inverse)</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformForward
</p>

<p class=MsoNormal style='text-align:justify'>                        kTransformInverse
</p>

<p class=MsoNormal style='text-align:justify;text-indent:22.8pt'><b>fDegree</b>-applies
only for mixed transforms [2], [3], [4]. </p>

<p class=MsoNormal style='text-align:justify;text-indent:22.8pt'>                
<span style='color:fuchsia'> Allowed range  <sub><img border=0 width=100
height=27 src="gif/spectrum2transform_transform_image001.gif"></sub>. </span></p>

<p class=MsoNormal style='text-align:justify'><b><i>References:</i></b></p>

<p class=MsoNormal style='text-align:justify'>[1] C.V. Hampton, B. Lian, Wm. C.
McHarris: Fast-Fourier-transform spectral enhancement techniques for gamma-ray
spectroscopy. NIM A353 (1994) 280-284. </p>

<p class=MsoNormal style='text-align:justify'>[2] Morhá&#269; M., Matoušek V.,
New adaptive Cosine-Walsh  transform and its application to nuclear data
compression, IEEE Transactions on Signal Processing 48 (2000) 2693.  </p>

<p class=MsoNormal style='text-align:justify'>[3] Morhá&#269; M., Matoušek V.,
Data compression using new fast adaptive Cosine-Haar transforms, Digital Signal
Processing 8 (1998) 63. </p>

<p class=MsoNormal style='text-align:justify'>[4] Morhá&#269; M., Matoušek V.:
Multidimensional nuclear data compression using fast adaptive Walsh-Haar
transform. Acta Physica Slovaca 51 (2001) 307. </p>

<p class=MsoNormal style='text-align:justify'>&nbsp;</p>

<p class=MsoNormal style='text-align:justify'><i>Example 1 – script Transform2.c:</i></p>

<p class=MsoNormal style='text-align:justify'><span style='font-size:16.0pt'><img
border=0 width=602 height=455 src="gif/spectrum2transform_transform_image002.jpg"></span></p>

<p class=MsoNormal><b>Fig. 1 Original two-dimensional noisy spectrum</b></p>

<p class=MsoNormal style='text-align:justify'><span style='font-size:16.0pt'><img
border=0 width=602 height=455 src="gif/spectrum2transform_transform_image003.jpg"></span></p>

<p class=MsoNormal style='text-align:justify'><b>Fig. 2 Transformed spectrum
from Fig. 1 using Cosine transform. Energy of the trasnsformed data is
concentrated around the beginning of the coordinate system</b></p>

<p class=MsoNormal><b><span style='font-size:16.0pt;color:#339966'>&nbsp;</span></b></p>

<p class=MsoNormal><b><span style='color:#339966'>Script:</span></b></p>

<p class=MsoNormal><span style='font-size:10.0pt'>// Example to illustrate
Transform function (class TSpectrumTransform2).</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>// To execute this example,
do</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>// root &gt; .x Transform2.C</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>void Transform2() {</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t i, j;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsx =
256;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsy =
256;   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmin  = 0;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmax  =
nbinsx;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymin  = 0;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymax  = nbinsy;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
style='font-size:10.0pt'>Float_t ** source = new float *[nbinsx];   </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   Float_t ** dest = new
float *[nbinsx];      </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   for (i=0;i&lt;nbinsx;i++)</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                                                source[i]=new
float[nbinsy];</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   for (i=0;i&lt;nbinsx;i++)</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                                                dest[i]=new
float[nbinsy];   </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   TH2F *trans = new
TH2F(&quot;trans&quot;,&quot;Background
estimation&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   TFile *f = new
TFile(&quot;TSpectrum2.root&quot;);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   trans=(TH2F*)
f-&gt;Get(&quot;back3;1&quot;);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   TCanvas *Tr = new
TCanvas(&quot;Transform&quot;,&quot;Illustation of transform
function&quot;,10,10,1000,700);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
i++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
nbinsy; j++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                    source[i][j]
= trans-&gt;GetBinContent(i + 1,j + 1); </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>                 }</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   }           </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
TSpectrumTransform2 *t = new TSpectrumTransform2(256,256);   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
t-&gt;SetTransformType(t-&gt;kTransformCos,0);</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   t-&gt;SetDirection(t-&gt;kTransformForward);</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
t-&gt;Transform(source,dest);</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
style='font-size:10.0pt'>for (i = 0; i &lt; nbinsx; i++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
nbinsy; j++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                  trans-&gt;SetBinContent(i
+ 1, j + 1,dest[i][j]);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                 }</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   }   </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>  
trans-&gt;Draw(&quot;SURF&quot;);      </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>}</span></p>

</div>

<!-- */
// --> End_Html
   Int_t i, j;
   Int_t size;
   Float_t *working_vector = 0, **working_matrix = 0;
   size = (Int_t) TMath::Max(fSizeX, fSizeY);
   switch (fTransformType) {
   case kTransformHaar:
   case kTransformWalsh:
      working_vector = new Float_t[2 * size];
      working_matrix = new Float_t *[fSizeX];
      for (i = 0; i < fSizeX; i++)
         working_matrix[i] = new Float_t[fSizeY];
      break;
   case kTransformCos:
   case kTransformSin:
   case kTransformFourier:
   case kTransformHartley:
   case kTransformFourierWalsh:
   case kTransformFourierHaar:
   case kTransformWalshHaar:
      working_vector = new Float_t[4 * size];
      working_matrix = new Float_t *[fSizeX];
      for (i = 0; i < fSizeX; i++)
         working_matrix[i] = new Float_t[2 * fSizeY];
      break;
   case kTransformCosWalsh:
   case kTransformCosHaar:
   case kTransformSinWalsh:
   case kTransformSinHaar:
      working_vector = new Float_t[8 * size];
      working_matrix = new Float_t *[fSizeX];
      for (i = 0; i < fSizeX; i++)
         working_matrix[i] = new Float_t[2 * fSizeY];
      break;
   }
   if (fDirection == kTransformForward) {
      switch (fTransformType) {
      case kTransformHaar:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                     fDirection, kTransformHaar);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformWalsh:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                     fDirection, kTransformWalsh);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformCos:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         FourCos2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   kTransformCos);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformSin:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         FourCos2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   kTransformSin);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformFourier:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         FourCos2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   kTransformFourier);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j + fSizeY] = working_matrix[i][j + fSizeY];
            }
         }
         break;
      case kTransformHartley:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         FourCos2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   kTransformHartley);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformFourierWalsh:
      case kTransformFourierHaar:
      case kTransformWalshHaar:
      case kTransformCosWalsh:
      case kTransformCosHaar:
      case kTransformSinWalsh:
      case kTransformSinHaar:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         General2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   fTransformType, fDegree);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         if (fTransformType == kTransformFourierWalsh
              || fTransformType == kTransformFourierHaar) {
            for (i = 0; i < fSizeX; i++) {
               for (j = 0; j < fSizeY; j++) {
                  fDest[i][j + fSizeY] = working_matrix[i][j + fSizeY];
               }
            }
         }
         break;
      }
   }
   
   else if (fDirection == kTransformInverse) {
      switch (fTransformType) {
      case kTransformHaar:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                     fDirection, kTransformHaar);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformWalsh:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                     fDirection, kTransformWalsh);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformCos:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         FourCos2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   kTransformCos);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformSin:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         FourCos2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   kTransformSin);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformFourier:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j + fSizeY] = fSource[i][j + fSizeY];
            }
         }
         FourCos2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   kTransformFourier);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformHartley:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         FourCos2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   kTransformHartley);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      case kTransformFourierWalsh:
      case kTransformFourierHaar:
      case kTransformWalshHaar:
      case kTransformCosWalsh:
      case kTransformCosHaar:
      case kTransformSinWalsh:
      case kTransformSinHaar:
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               working_matrix[i][j] = fSource[i][j];
            }
         }
         if (fTransformType == kTransformFourierWalsh
              || fTransformType == kTransformFourierHaar) {
            for (i = 0; i < fSizeX; i++) {
               for (j = 0; j < fSizeY; j++) {
                  working_matrix[i][j + fSizeY] = fSource[i][j + fSizeY];
               }
            }
         }
         General2(working_matrix, working_vector, fSizeX, fSizeY, fDirection,
                   fTransformType, fDegree);
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j];
            }
         }
         break;
      }
   }
   for (i = 0; i < fSizeX; i++) {
      delete[]working_matrix[i];
   }
   delete[]working_matrix;
   delete[]working_vector;
   return;
}
//////////END OF TRANSFORM2 FUNCTION/////////////////////////////////
//_______________________________________________________________________________________
//////////FILTER2_ZONAL FUNCTION - CALCULATES DIFFERENT 2-D ORTHOGONAL TRANSFORMS, SETS GIVEN REGION TO FILTER COEFFICIENT AND TRANSFORMS IT BACK//////
void TSpectrum2Transform::FilterZonal(const Float_t **fSource, Float_t **fDest) 
{
//////////////////////////////////////////////////////////////////////////////////////////
/* TWO-DIMENSIONAL FILTER ZONAL FUNCTION                      */ 
/* This function transforms the source spectrum. The calling program               */ 
/*      should fill in input parameters. Then it sets transformed                       */ 
/*      coefficients in the given region to the given                                   */ 
/*      filter_coeff and transforms it back                                             */ 
/* Filtered data are written into dest spectrum.                                   */ 
/*                         */ 
/* Function parameters:                      */ 
/* fSource-pointer to the matrix of source spectrum, its size should               */ 
/*             be fSizeX*fSizeY                                                         */ 
/* fDest-pointer to the matrix of destination data, its size should be             */ 
/*           fSizeX*fSizeY                                                              */ 
/*                         */ 
//////////////////////////////////////////////////////////////////////////////////////////
//Begin_Html <!--
/* -->
<div class=Section2>

<p class=MsoNormal><b><span style='font-size:14.0pt'>Example of zonal filtering</span></b></p>

<p class=MsoNormal><i>&nbsp;</i></p>

<p class=MsoNormal><i>Function:</i></p>

<p class=MsoNormal>void <a
href="http://root.cern.ch/root/html/TSpectrum.html#TSpectrum:Fit1Awmi"><b>TSpectrumTransform2::FilterZonal</b></a><b>(const
<a href="http://root.cern.ch/root/html/ListOfTypes.html#float">float</a> **fSource,
<a href="http://root.cern.ch/root/html/ListOfTypes.html#float">float</a> **fDest)</b></p>

<p class=MsoNormal style='text-align:justify'>&nbsp;</p>

<p class=MsoNormal style='text-align:justify'>This function transforms the
source spectrum (for details see Transform function).  Before the FilterZonal
function is called the class must be created by constructor and the type of the
transform as well as some other parameters must be set using a set of setter
functions. The FilterZonal function sets transformed coefficients in the given
region (fXmin, fXmax) to the given fFilterCoeff and transforms it back. Filtered
data are written into dest spectrum. </p>

<p class=MsoNormal style='text-align:justify'>&nbsp;</p>

<p class=MsoNormal style='text-align:justify'><i>Example  – script Fitler2.c:</i></p>

<p class=MsoNormal style='text-align:justify'><span style='font-size:16.0pt'><img
border=0 width=602 height=455 src="gif/spectrum2transform_filter_image001.jpg"></span></p>

<p class=MsoNormal><b>Fig. 1 Original two-dimensional noisy spectrum</b></p>

<p class=MsoNormal><b><span style='font-size:14.0pt'><img border=0 width=602
height=455 src="gif/spectrum2transform_filter_image002.jpg"></span></b></p>

<p class=MsoNormal style='text-align:justify'><b>Fig. 2 Filtered spectrum using
Cosine transform and zonal filtration (channels in regions (128-255)x(0-255)
and (0-255)x(128-255) were set to 0).  </b></p>

<p class=MsoNormal><b><span style='color:#339966'>&nbsp;</span></b></p>

<p class=MsoNormal><b><span style='color:#339966'>Script:</span></b></p>

<p class=MsoNormal><span style='font-size:10.0pt'>// Example to illustrate
zonal filtration (class TSpectrumTransform2).</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>// To execute this example,
do</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>// root &gt; .x Filter2.C</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'> </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>void Filter2() {</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   Int_t i, j;</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   </span><span lang=FR
style='font-size:10.0pt'>Int_t nbinsx = 256;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsy =
256;   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmin  = 0;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmax  =
nbinsx;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymin  = 0;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymax  =
nbinsy;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
style='font-size:10.0pt'>Float_t ** source = new float *[nbinsx];   </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   Float_t ** dest = new
float *[nbinsx];      </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   for (i=0;i&lt;nbinsx;i++)</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                                                source[i]=new
float[nbinsy];</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   for (i=0;i&lt;nbinsx;i++)</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                                                dest[i]=new
float[nbinsy];   </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   TH2F *trans = new
TH2F(&quot;trans&quot;,&quot;Background
estimation&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   TFile *f = new
TFile(&quot;TSpectrum2.root&quot;);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   trans=(TH2F*)
f-&gt;Get(&quot;back3;1&quot;);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   TCanvas *Tr = new
TCanvas(&quot;Transform&quot;,&quot;Illustation of transform
function&quot;,10,10,1000,700);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
i++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
nbinsy; j++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                    </span><span
lang=FR style='font-size:10.0pt'>source[i][j] = trans-&gt;GetBinContent(i + 1,j
+ 1); </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>                 }</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   }           </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
TSpectrumTransform2 *t = new TSpectrumTransform2(256,256);   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   t-&gt;SetTransformType(t-&gt;kTransformCos,0);  
</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
t-&gt;SetRegion(0,255,128,255);</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
t-&gt;FilterZonal(source,dest);     </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
style='font-size:10.0pt'>for (i = 0; i &lt; nbinsx; i++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
nbinsy; j++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                    </span><span
lang=FR style='font-size:10.0pt'>source[i][j] = dest[i][j]; </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>                 }</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   }   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
t-&gt;SetRegion(128,255,0,255);</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   t-&gt;FilterZonal(source,dest);       
</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>  
trans-&gt;Draw(&quot;SURF&quot;);     </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>}</span></p>

</div>

<!-- */
// --> End_Html

   Int_t i, j;
   Double_t a, old_area = 0, new_area = 0;
   Int_t size;
   Float_t *working_vector = 0, **working_matrix = 0;
   size = (Int_t) TMath::Max(fSizeX, fSizeY);
   switch (fTransformType) {
   case kTransformHaar:
   case kTransformWalsh:
      working_vector = new Float_t[2 * size];
      working_matrix = new Float_t *[fSizeX];
      for (i = 0; i < fSizeX; i++)
         working_matrix[i] = new Float_t[fSizeY];
      break;
   case kTransformCos:
   case kTransformSin:
   case kTransformFourier:
   case kTransformHartley:
   case kTransformFourierWalsh:
   case kTransformFourierHaar:
   case kTransformWalshHaar:
      working_vector = new Float_t[4 * size];
      working_matrix = new Float_t *[fSizeX];
      for (i = 0; i < fSizeX; i++)
         working_matrix[i] = new Float_t[2 * fSizeY];
      break;
   case kTransformCosWalsh:
   case kTransformCosHaar:
   case kTransformSinWalsh:
   case kTransformSinHaar:
      working_vector = new Float_t[8 * size];
      working_matrix = new Float_t *[fSizeX];
      for (i = 0; i < fSizeX; i++)
         working_matrix[i] = new Float_t[2 * fSizeY];
      break;
   }
   switch (fTransformType) {
   case kTransformHaar:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                  kTransformForward, kTransformHaar);
      break;
   case kTransformWalsh:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                  kTransformForward, kTransformWalsh);
      break;
   case kTransformCos:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, kTransformCos);
      break;
   case kTransformSin:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, kTransformSin);
      break;
   case kTransformFourier:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, kTransformFourier);
      break;
   case kTransformHartley:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, kTransformHartley);
      break;
   case kTransformFourierWalsh:
   case kTransformFourierHaar:
   case kTransformWalshHaar:
   case kTransformCosWalsh:
   case kTransformCosHaar:
   case kTransformSinWalsh:
   case kTransformSinHaar:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      General2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, fTransformType, fDegree);
      break;
   }
   for (i = 0; i < fSizeX; i++) {
      for (j = 0; j < fSizeY; j++) {
         if (i >= fXmin && i <= fXmax && j >= fYmin && j <= fYmax)
            working_matrix[i][j] = fFilterCoeff;
      }
   }
   if (fTransformType == kTransformFourier || fTransformType == kTransformFourierWalsh
        || fTransformType == kTransformFourierHaar) {
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            if (i >= fXmin && i <= fXmax && j >= fYmin && j <= fYmax)
               working_matrix[i][j + fSizeY] = fFilterCoeff;
         }
      }
   }
   switch (fTransformType) {
   case kTransformHaar:
      HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                  kTransformInverse, kTransformHaar);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformWalsh:
      HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                  kTransformInverse, kTransformWalsh);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformCos:
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, kTransformCos);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformSin:
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, kTransformSin);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformFourier:
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, kTransformFourier);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformHartley:
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, kTransformHartley);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformFourierWalsh:
   case kTransformFourierHaar:
   case kTransformWalshHaar:
   case kTransformCosWalsh:
   case kTransformCosHaar:
   case kTransformSinWalsh:
   case kTransformSinHaar:
      General2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, fTransformType, fDegree);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   }
   for (i = 0; i < fSizeX; i++) {
      delete[]working_matrix[i];
   }
   delete[]working_matrix;
   delete[]working_vector;
   return;
}


//////////  END OF FILTER2_ZONAL FUNCTION/////////////////////////////////
//////////ENHANCE2 FUNCTION - CALCULATES DIFFERENT 2-D ORTHOGONAL TRANSFORMS, MULTIPLIES GIVEN REGION BY ENHANCE COEFFICIENT AND TRANSFORMS IT BACK//////
//______________________________________________________________________
void TSpectrum2Transform::Enhance(const Float_t **fSource, Float_t **fDest)
{
//////////////////////////////////////////////////////////////////////////////////////////
/* TWO-DIMENSIONAL ENHANCE ZONAL FUNCTION                     */ 
/* This function transforms the source spectrum. The calling program               */ 
/*      should fill in input parameters. Then it multiplies transformed                 */ 
/*      coefficients in the given region by the given                                   */ 
/*      enhance_coeff and transforms it back                                            */ 
/*                         */ 
/* Function parameters:                      */ 
/* fSource-pointer to the matrix of source spectrum, its size should               */ 
/*             be fSizeX*fSizeY                                                         */ 
/* fDest-pointer to the matrix of destination data, its size should be             */ 
/*           fSizeX*fSizeY                                                              */ 
/*                         */ 
//////////////////////////////////////////////////////////////////////////////////////////
//Begin_Html <!--
/* -->
<div class=Section3>

<p class=MsoNormal><b><span style='font-size:14.0pt'>Example of enhancement</span></b></p>

<p class=MsoNormal><i>&nbsp;</i></p>

<p class=MsoNormal><i>Function:</i></p>

<p class=MsoNormal>void <a
href="http://root.cern.ch/root/html/TSpectrum.html#TSpectrum:Fit1Awmi"><b>TSpectrumTransform2::Enhance</b></a><b>(const
<a href="http://root.cern.ch/root/html/ListOfTypes.html#float">float</a>
**fSource, <a href="http://root.cern.ch/root/html/ListOfTypes.html#float">float</a>
**fDest)</b></p>

<p class=MsoNormal style='text-align:justify'>&nbsp;</p>

<p class=MsoNormal style='text-align:justify'>This function transforms the
source spectrum (for details see Transform function).  Before the Enhance
function is called the class must be created by constructor and the type of the
transform as well as some other parameters must be set using a set of setter
functions. The Enhance function multiplies transformed coefficients in the given
region (fXmin, fXmax, fYmin, fYmax) by the given fEnhancCoeff and transforms it
back. Enhanced data are written into dest spectrum.</p>

<p class=MsoNormal style='text-align:justify'><i>Example – script Enhance2.c:</i></p>

<p class=MsoNormal style='text-align:justify'><span style='font-size:16.0pt'><img
border=0 width=602 height=455 src="gif/spectrum2transform_enhance_image001.jpg"></span></p>

<p class=MsoNormal><b>Fig. 1 Original two-dimensional noisy spectrum</b></p>

<p class=MsoNormal style='text-align:justify'><i><span style='font-size:16.0pt'><img
border=0 width=602 height=455 src="gif/spectrum2transform_enhance_image002.jpg"></span></i></p>

<p class=MsoNormal style='text-align:justify'><b>Fig. 2 Enhanced spectrum of
the data from Fig. 1 using Cosine transform (channels in region (0-63)x(0-63)
were multiplied by 5) </b></p>

<p class=MsoNormal><b><span style='font-size:16.0pt;color:#339966'>&nbsp;</span></b></p>

<p class=MsoNormal><b><span style='color:#339966'>Script:</span></b></p>

<p class=MsoNormal><span style='font-size:10.0pt'>// Example to illustrate
enhancement (class TSpectrumTransform2).</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>// To execute this example,
do</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>// root &gt; .x Enhance2.C</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'> </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>void Enhance2() {</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t i, j;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsx =
256;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsy =
256;   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmin  = 0;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmax  =
nbinsx;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymin  = 0;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymax  =
nbinsy;</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
style='font-size:10.0pt'>Float_t ** source = new float *[nbinsx];   </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   Float_t ** dest = new
float *[nbinsx];      </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   for (i=0;i&lt;nbinsx;i++)</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                                                source[i]=new
float[nbinsy];</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   for (i=0;i&lt;nbinsx;i++)</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                                                dest[i]=new
float[nbinsy];   </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   TH2F *trans = new
TH2F(&quot;trans&quot;,&quot;Background
estimation&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   TFile *f = new
TFile(&quot;TSpectrum2.root&quot;);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   trans=(TH2F*)
f-&gt;Get(&quot;back3;1&quot;);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   TCanvas *Tr = new
TCanvas(&quot;Transform&quot;,&quot;Illustation of transform
function&quot;,10,10,1000,700);</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
i++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
nbinsy; j++){</span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>                    </span><span
lang=FR style='font-size:10.0pt'>source[i][j] = trans-&gt;GetBinContent(i + 1,j
+ 1); </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>                 }</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   }           </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
TSpectrumTransform2 *t = new TSpectrumTransform2(256,256);   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
t-&gt;SetTransformType(t-&gt;kTransformCos,0);   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
t-&gt;SetRegion(0,63,0,63);   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
t-&gt;SetEnhanceCoeff(5);</span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'>  
t-&gt;Enhance(source,dest);   </span></p>

<p class=MsoNormal><span lang=FR style='font-size:10.0pt'> </span><span
style='font-size:10.0pt'>  trans-&gt;Draw(&quot;SURF&quot;);     </span></p>

<p class=MsoNormal><span style='font-size:10.0pt'>}</span></p>

</div>

<!-- */
// --> End_Html

   Int_t i, j;
   Double_t a, old_area = 0, new_area = 0;
   Int_t size;
   Float_t *working_vector = 0, **working_matrix = 0;
   size = (Int_t) TMath::Max(fSizeX, fSizeY);
   switch (fTransformType) {
   case kTransformHaar:
   case kTransformWalsh:
      working_vector = new Float_t[2 * size];
      working_matrix = new Float_t *[fSizeX];
      for (i = 0; i < fSizeX; i++)
         working_matrix[i] = new Float_t[fSizeY];
      break;
   case kTransformCos:
   case kTransformSin:
   case kTransformFourier:
   case kTransformHartley:
   case kTransformFourierWalsh:
   case kTransformFourierHaar:
   case kTransformWalshHaar:
      working_vector = new Float_t[4 * size];
      working_matrix = new Float_t *[fSizeX];
      for (i = 0; i < fSizeX; i++)
         working_matrix[i] = new Float_t[2 * fSizeY];
      break;
   case kTransformCosWalsh:
   case kTransformCosHaar:
   case kTransformSinWalsh:
   case kTransformSinHaar:
      working_vector = new Float_t[8 * size];
      working_matrix = new Float_t *[fSizeX];
      for (i = 0; i < fSizeX; i++)
         working_matrix[i] = new Float_t[2 * fSizeY];
      break;
   }
   switch (fTransformType) {
   case kTransformHaar:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                  kTransformForward, kTransformHaar);
      break;
   case kTransformWalsh:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                  kTransformForward, kTransformWalsh);
      break;
   case kTransformCos:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, kTransformCos);
      break;
   case kTransformSin:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, kTransformSin);
      break;
   case kTransformFourier:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, kTransformFourier);
      break;
   case kTransformHartley:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, kTransformHartley);
      break;
   case kTransformFourierWalsh:
   case kTransformFourierHaar:
   case kTransformWalshHaar:
   case kTransformCosWalsh:
   case kTransformCosHaar:
   case kTransformSinWalsh:
   case kTransformSinHaar:
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            working_matrix[i][j] = fSource[i][j];
            old_area = old_area + fSource[i][j];
         }
      }
      General2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformForward, fTransformType, fDegree);
      break;
   }
   for (i = 0; i < fSizeX; i++) {
      for (j = 0; j < fSizeY; j++) {
         if (i >= fXmin && i <= fXmax && j >= fYmin && j <= fYmax)
            working_matrix[i][j] *= fEnhanceCoeff;
      }
   }
   if (fTransformType == kTransformFourier || fTransformType == kTransformFourierWalsh
        || fTransformType == kTransformFourierHaar) {
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            if (i >= fXmin && i <= fXmax && j >= fYmin && j <= fYmax)
               working_matrix[i][j + fSizeY] *= fEnhanceCoeff;
         }
      }
   }
   switch (fTransformType) {
   case kTransformHaar:
      HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                  kTransformInverse, kTransformHaar);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformWalsh:
      HaarWalsh2(working_matrix, working_vector, fSizeX, fSizeY,
                  kTransformInverse, kTransformWalsh);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformCos:
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, kTransformCos);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformSin:
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, kTransformSin);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformFourier:
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, kTransformFourier);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformHartley:
      FourCos2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, kTransformHartley);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   case kTransformFourierWalsh:
   case kTransformFourierHaar:
   case kTransformWalshHaar:
   case kTransformCosWalsh:
   case kTransformCosHaar:
   case kTransformSinWalsh:
   case kTransformSinHaar:
      General2(working_matrix, working_vector, fSizeX, fSizeY,
                kTransformInverse, fTransformType, fDegree);
      for (i = 0; i < fSizeX; i++) {
         for (j = 0; j < fSizeY; j++) {
            new_area = new_area + working_matrix[i][j];
         }
      }
      if (new_area != 0) {
         a = old_area / new_area;
         for (i = 0; i < fSizeX; i++) {
            for (j = 0; j < fSizeY; j++) {
               fDest[i][j] = working_matrix[i][j] * a;
            }
         }
      }
      break;
   }
   for (i = 0; i < fSizeX; i++) {
      delete[]working_matrix[i];
   }
   delete[]working_matrix;
   delete[]working_vector;
   return;
}


//////////  END OF ENHANCE2 FUNCTION/////////////////////////////////

//______________________________________________________________________
void TSpectrum2Transform::SetTransformType(Int_t transType, Int_t degree)
{
//////////////////////////////////////////////////////////////////////////////
//   SETTER FUNCION                                                      
//                                                     
//   This function sets the following parameters for transform:
//         -transType - type of transform (Haar, Walsh, Cosine, Sine, Fourier, Hartley, Fourier-Walsh, Fourier-Haar, Walsh-Haar, Cosine-Walsh, Cosine-Haar, Sine-Walsh, Sine-Haar)
//         -degree - degree of mixed transform, applies only for Fourier-Walsh, Fourier-Haar, Walsh-Haar, Cosine-Walsh, Cosine-Haar, Sine-Walsh, Sine-Haar transforms
//////////////////////////////////////////////////////////////////////////////      
   
   Int_t j1, j2, n;
   j1 = 0;
   n = 1;
   for (; n < fSizeX;) {
      j1 += 1;
      n = n * 2;
   }
   j2 = 0;
   n = 1;
   for (; n < fSizeY;) {
      j2 += 1;
      n = n * 2;
   }
   if (transType < kTransformHaar || transType > kTransformSinHaar){
      Error ("TSpectrumTransform","Invalid type of transform");
      return;       
   }
   if (transType >= kTransformFourierWalsh && transType <= kTransformSinHaar) {
      if (degree > j1 || degree > j2 || degree < 1){
         Error ("TSpectrumTransform","Invalid degree of mixed transform");
         return;          
      }
   }
   fTransformType = transType;
   fDegree = degree;
}
    
//______________________________________________________________________
void TSpectrum2Transform::SetRegion(Int_t xmin, Int_t xmax, Int_t ymin, Int_t ymax)
{
//////////////////////////////////////////////////////////////////////////////
//   SETTER FUNCION                                                      
//                                                     
//   This function sets the filtering or enhancement region:
//         -xmin, xmax, ymin, ymax
//////////////////////////////////////////////////////////////////////////////         
   if(xmin<0 || xmax < xmin || xmax >= fSizeX){ 
      Error("TSpectrumTransform", "Wrong range");      
      return;
   }         
   if(ymin<0 || ymax < ymin || ymax >= fSizeY){ 
      Error("TSpectrumTransform", "Wrong range");      
      return;
   }            
   fXmin = xmin;
   fXmax = xmax;
   fYmin = ymin;
   fYmax = ymax;   
}

//______________________________________________________________________
void TSpectrum2Transform::SetDirection(Int_t direction)
{
//////////////////////////////////////////////////////////////////////////////
//   SETTER FUNCION                                                      
//                                                     
//   This function sets the direction of the transform:
//         -direction (forward or inverse)
//////////////////////////////////////////////////////////////////////////////      
   if(direction != kTransformForward && direction != kTransformInverse){ 
      Error("TSpectrumTransform", "Wrong direction");      
      return;
   }         
   fDirection = direction;
}

//______________________________________________________________________
void TSpectrum2Transform::SetFilterCoeff(Float_t filterCoeff)
{
//////////////////////////////////////////////////////////////////////////////
//   SETTER FUNCION                                                      
//                                                     
//   This function sets the filter coefficient:
//         -filterCoeff - after the transform the filtered region (xmin, xmax, ymin, ymax) is replaced by this coefficient. Applies only for filtereng operation.
//////////////////////////////////////////////////////////////////////////////      
   fFilterCoeff = filterCoeff;
}

//______________________________________________________________________
void TSpectrum2Transform::SetEnhanceCoeff(Float_t enhanceCoeff)
{
//////////////////////////////////////////////////////////////////////////////
//   SETTER FUNCION                                                      
//                                                     
//   This function sets the enhancement coefficient:
//         -enhanceCoeff - after the transform the enhanced region (xmin, xmax, ymin, ymax) is multiplied by this coefficient. Applies only for enhancement operation.
//////////////////////////////////////////////////////////////////////////////      
   fEnhanceCoeff = enhanceCoeff;
}
    
 TSpectrum2Transform.cxx:1
 TSpectrum2Transform.cxx:2
 TSpectrum2Transform.cxx:3
 TSpectrum2Transform.cxx:4
 TSpectrum2Transform.cxx:5
 TSpectrum2Transform.cxx:6
 TSpectrum2Transform.cxx:7
 TSpectrum2Transform.cxx:8
 TSpectrum2Transform.cxx:9
 TSpectrum2Transform.cxx:10
 TSpectrum2Transform.cxx:11
 TSpectrum2Transform.cxx:12
 TSpectrum2Transform.cxx:13
 TSpectrum2Transform.cxx:14
 TSpectrum2Transform.cxx:15
 TSpectrum2Transform.cxx:16
 TSpectrum2Transform.cxx:17
 TSpectrum2Transform.cxx:18
 TSpectrum2Transform.cxx:19
 TSpectrum2Transform.cxx:20
 TSpectrum2Transform.cxx:21
 TSpectrum2Transform.cxx:22
 TSpectrum2Transform.cxx:23
 TSpectrum2Transform.cxx:24
 TSpectrum2Transform.cxx:25
 TSpectrum2Transform.cxx:26
 TSpectrum2Transform.cxx:27
 TSpectrum2Transform.cxx:28
 TSpectrum2Transform.cxx:29
 TSpectrum2Transform.cxx:30
 TSpectrum2Transform.cxx:31
 TSpectrum2Transform.cxx:32
 TSpectrum2Transform.cxx:33
 TSpectrum2Transform.cxx:34
 TSpectrum2Transform.cxx:35
 TSpectrum2Transform.cxx:36
 TSpectrum2Transform.cxx:37
 TSpectrum2Transform.cxx:38
 TSpectrum2Transform.cxx:39
 TSpectrum2Transform.cxx:40
 TSpectrum2Transform.cxx:41
 TSpectrum2Transform.cxx:42
 TSpectrum2Transform.cxx:43
 TSpectrum2Transform.cxx:44
 TSpectrum2Transform.cxx:45
 TSpectrum2Transform.cxx:46
 TSpectrum2Transform.cxx:47
 TSpectrum2Transform.cxx:48
 TSpectrum2Transform.cxx:49
 TSpectrum2Transform.cxx:50
 TSpectrum2Transform.cxx:51
 TSpectrum2Transform.cxx:52
 TSpectrum2Transform.cxx:53
 TSpectrum2Transform.cxx:54
 TSpectrum2Transform.cxx:55
 TSpectrum2Transform.cxx:56
 TSpectrum2Transform.cxx:57
 TSpectrum2Transform.cxx:58
 TSpectrum2Transform.cxx:59
 TSpectrum2Transform.cxx:60
 TSpectrum2Transform.cxx:61
 TSpectrum2Transform.cxx:62
 TSpectrum2Transform.cxx:63
 TSpectrum2Transform.cxx:64
 TSpectrum2Transform.cxx:65
 TSpectrum2Transform.cxx:66
 TSpectrum2Transform.cxx:67
 TSpectrum2Transform.cxx:68
 TSpectrum2Transform.cxx:69
 TSpectrum2Transform.cxx:70
 TSpectrum2Transform.cxx:71
 TSpectrum2Transform.cxx:72
 TSpectrum2Transform.cxx:73
 TSpectrum2Transform.cxx:74
 TSpectrum2Transform.cxx:75
 TSpectrum2Transform.cxx:76
 TSpectrum2Transform.cxx:77
 TSpectrum2Transform.cxx:78
 TSpectrum2Transform.cxx:79
 TSpectrum2Transform.cxx:80
 TSpectrum2Transform.cxx:81
 TSpectrum2Transform.cxx:82
 TSpectrum2Transform.cxx:83
 TSpectrum2Transform.cxx:84
 TSpectrum2Transform.cxx:85
 TSpectrum2Transform.cxx:86
 TSpectrum2Transform.cxx:87
 TSpectrum2Transform.cxx:88
 TSpectrum2Transform.cxx:89
 TSpectrum2Transform.cxx:90
 TSpectrum2Transform.cxx:91
 TSpectrum2Transform.cxx:92
 TSpectrum2Transform.cxx:93
 TSpectrum2Transform.cxx:94
 TSpectrum2Transform.cxx:95
 TSpectrum2Transform.cxx:96
 TSpectrum2Transform.cxx:97
 TSpectrum2Transform.cxx:98
 TSpectrum2Transform.cxx:99
 TSpectrum2Transform.cxx:100
 TSpectrum2Transform.cxx:101
 TSpectrum2Transform.cxx:102
 TSpectrum2Transform.cxx:103
 TSpectrum2Transform.cxx:104
 TSpectrum2Transform.cxx:105
 TSpectrum2Transform.cxx:106
 TSpectrum2Transform.cxx:107
 TSpectrum2Transform.cxx:108
 TSpectrum2Transform.cxx:109
 TSpectrum2Transform.cxx:110
 TSpectrum2Transform.cxx:111
 TSpectrum2Transform.cxx:112
 TSpectrum2Transform.cxx:113
 TSpectrum2Transform.cxx:114
 TSpectrum2Transform.cxx:115
 TSpectrum2Transform.cxx:116
 TSpectrum2Transform.cxx:117
 TSpectrum2Transform.cxx:118
 TSpectrum2Transform.cxx:119
 TSpectrum2Transform.cxx:120
 TSpectrum2Transform.cxx:121
 TSpectrum2Transform.cxx:122
 TSpectrum2Transform.cxx:123
 TSpectrum2Transform.cxx:124
 TSpectrum2Transform.cxx:125
 TSpectrum2Transform.cxx:126
 TSpectrum2Transform.cxx:127
 TSpectrum2Transform.cxx:128
 TSpectrum2Transform.cxx:129
 TSpectrum2Transform.cxx:130
 TSpectrum2Transform.cxx:131
 TSpectrum2Transform.cxx:132
 TSpectrum2Transform.cxx:133
 TSpectrum2Transform.cxx:134
 TSpectrum2Transform.cxx:135
 TSpectrum2Transform.cxx:136
 TSpectrum2Transform.cxx:137
 TSpectrum2Transform.cxx:138
 TSpectrum2Transform.cxx:139
 TSpectrum2Transform.cxx:140
 TSpectrum2Transform.cxx:141
 TSpectrum2Transform.cxx:142
 TSpectrum2Transform.cxx:143
 TSpectrum2Transform.cxx:144
 TSpectrum2Transform.cxx:145
 TSpectrum2Transform.cxx:146
 TSpectrum2Transform.cxx:147
 TSpectrum2Transform.cxx:148
 TSpectrum2Transform.cxx:149
 TSpectrum2Transform.cxx:150
 TSpectrum2Transform.cxx:151
 TSpectrum2Transform.cxx:152
 TSpectrum2Transform.cxx:153
 TSpectrum2Transform.cxx:154
 TSpectrum2Transform.cxx:155
 TSpectrum2Transform.cxx:156
 TSpectrum2Transform.cxx:157
 TSpectrum2Transform.cxx:158
 TSpectrum2Transform.cxx:159
 TSpectrum2Transform.cxx:160
 TSpectrum2Transform.cxx:161
 TSpectrum2Transform.cxx:162
 TSpectrum2Transform.cxx:163
 TSpectrum2Transform.cxx:164
 TSpectrum2Transform.cxx:165
 TSpectrum2Transform.cxx:166
 TSpectrum2Transform.cxx:167
 TSpectrum2Transform.cxx:168
 TSpectrum2Transform.cxx:169
 TSpectrum2Transform.cxx:170
 TSpectrum2Transform.cxx:171
 TSpectrum2Transform.cxx:172
 TSpectrum2Transform.cxx:173
 TSpectrum2Transform.cxx:174
 TSpectrum2Transform.cxx:175
 TSpectrum2Transform.cxx:176
 TSpectrum2Transform.cxx:177
 TSpectrum2Transform.cxx:178
 TSpectrum2Transform.cxx:179
 TSpectrum2Transform.cxx:180
 TSpectrum2Transform.cxx:181
 TSpectrum2Transform.cxx:182
 TSpectrum2Transform.cxx:183
 TSpectrum2Transform.cxx:184
 TSpectrum2Transform.cxx:185
 TSpectrum2Transform.cxx:186
 TSpectrum2Transform.cxx:187
 TSpectrum2Transform.cxx:188
 TSpectrum2Transform.cxx:189
 TSpectrum2Transform.cxx:190
 TSpectrum2Transform.cxx:191
 TSpectrum2Transform.cxx:192
 TSpectrum2Transform.cxx:193
 TSpectrum2Transform.cxx:194
 TSpectrum2Transform.cxx:195
 TSpectrum2Transform.cxx:196
 TSpectrum2Transform.cxx:197
 TSpectrum2Transform.cxx:198
 TSpectrum2Transform.cxx:199
 TSpectrum2Transform.cxx:200
 TSpectrum2Transform.cxx:201
 TSpectrum2Transform.cxx:202
 TSpectrum2Transform.cxx:203
 TSpectrum2Transform.cxx:204
 TSpectrum2Transform.cxx:205
 TSpectrum2Transform.cxx:206
 TSpectrum2Transform.cxx:207
 TSpectrum2Transform.cxx:208
 TSpectrum2Transform.cxx:209
 TSpectrum2Transform.cxx:210
 TSpectrum2Transform.cxx:211
 TSpectrum2Transform.cxx:212
 TSpectrum2Transform.cxx:213
 TSpectrum2Transform.cxx:214
 TSpectrum2Transform.cxx:215
 TSpectrum2Transform.cxx:216
 TSpectrum2Transform.cxx:217
 TSpectrum2Transform.cxx:218
 TSpectrum2Transform.cxx:219
 TSpectrum2Transform.cxx:220
 TSpectrum2Transform.cxx:221
 TSpectrum2Transform.cxx:222
 TSpectrum2Transform.cxx:223
 TSpectrum2Transform.cxx:224
 TSpectrum2Transform.cxx:225
 TSpectrum2Transform.cxx:226
 TSpectrum2Transform.cxx:227
 TSpectrum2Transform.cxx:228
 TSpectrum2Transform.cxx:229
 TSpectrum2Transform.cxx:230
 TSpectrum2Transform.cxx:231
 TSpectrum2Transform.cxx:232
 TSpectrum2Transform.cxx:233
 TSpectrum2Transform.cxx:234
 TSpectrum2Transform.cxx:235
 TSpectrum2Transform.cxx:236
 TSpectrum2Transform.cxx:237
 TSpectrum2Transform.cxx:238
 TSpectrum2Transform.cxx:239
 TSpectrum2Transform.cxx:240
 TSpectrum2Transform.cxx:241
 TSpectrum2Transform.cxx:242
 TSpectrum2Transform.cxx:243
 TSpectrum2Transform.cxx:244
 TSpectrum2Transform.cxx:245
 TSpectrum2Transform.cxx:246
 TSpectrum2Transform.cxx:247
 TSpectrum2Transform.cxx:248
 TSpectrum2Transform.cxx:249
 TSpectrum2Transform.cxx:250
 TSpectrum2Transform.cxx:251
 TSpectrum2Transform.cxx:252
 TSpectrum2Transform.cxx:253
 TSpectrum2Transform.cxx:254
 TSpectrum2Transform.cxx:255
 TSpectrum2Transform.cxx:256
 TSpectrum2Transform.cxx:257
 TSpectrum2Transform.cxx:258
 TSpectrum2Transform.cxx:259
 TSpectrum2Transform.cxx:260
 TSpectrum2Transform.cxx:261
 TSpectrum2Transform.cxx:262
 TSpectrum2Transform.cxx:263
 TSpectrum2Transform.cxx:264
 TSpectrum2Transform.cxx:265
 TSpectrum2Transform.cxx:266
 TSpectrum2Transform.cxx:267
 TSpectrum2Transform.cxx:268
 TSpectrum2Transform.cxx:269
 TSpectrum2Transform.cxx:270
 TSpectrum2Transform.cxx:271
 TSpectrum2Transform.cxx:272
 TSpectrum2Transform.cxx:273
 TSpectrum2Transform.cxx:274
 TSpectrum2Transform.cxx:275
 TSpectrum2Transform.cxx:276
 TSpectrum2Transform.cxx:277
 TSpectrum2Transform.cxx:278
 TSpectrum2Transform.cxx:279
 TSpectrum2Transform.cxx:280
 TSpectrum2Transform.cxx:281
 TSpectrum2Transform.cxx:282
 TSpectrum2Transform.cxx:283
 TSpectrum2Transform.cxx:284
 TSpectrum2Transform.cxx:285
 TSpectrum2Transform.cxx:286
 TSpectrum2Transform.cxx:287
 TSpectrum2Transform.cxx:288
 TSpectrum2Transform.cxx:289
 TSpectrum2Transform.cxx:290
 TSpectrum2Transform.cxx:291
 TSpectrum2Transform.cxx:292
 TSpectrum2Transform.cxx:293
 TSpectrum2Transform.cxx:294
 TSpectrum2Transform.cxx:295
 TSpectrum2Transform.cxx:296
 TSpectrum2Transform.cxx:297
 TSpectrum2Transform.cxx:298
 TSpectrum2Transform.cxx:299
 TSpectrum2Transform.cxx:300
 TSpectrum2Transform.cxx:301
 TSpectrum2Transform.cxx:302
 TSpectrum2Transform.cxx:303
 TSpectrum2Transform.cxx:304
 TSpectrum2Transform.cxx:305
 TSpectrum2Transform.cxx:306
 TSpectrum2Transform.cxx:307
 TSpectrum2Transform.cxx:308
 TSpectrum2Transform.cxx:309
 TSpectrum2Transform.cxx:310
 TSpectrum2Transform.cxx:311
 TSpectrum2Transform.cxx:312
 TSpectrum2Transform.cxx:313
 TSpectrum2Transform.cxx:314
 TSpectrum2Transform.cxx:315
 TSpectrum2Transform.cxx:316
 TSpectrum2Transform.cxx:317
 TSpectrum2Transform.cxx:318
 TSpectrum2Transform.cxx:319
 TSpectrum2Transform.cxx:320
 TSpectrum2Transform.cxx:321
 TSpectrum2Transform.cxx:322
 TSpectrum2Transform.cxx:323
 TSpectrum2Transform.cxx:324
 TSpectrum2Transform.cxx:325
 TSpectrum2Transform.cxx:326
 TSpectrum2Transform.cxx:327
 TSpectrum2Transform.cxx:328
 TSpectrum2Transform.cxx:329
 TSpectrum2Transform.cxx:330
 TSpectrum2Transform.cxx:331
 TSpectrum2Transform.cxx:332
 TSpectrum2Transform.cxx:333
 TSpectrum2Transform.cxx:334
 TSpectrum2Transform.cxx:335
 TSpectrum2Transform.cxx:336
 TSpectrum2Transform.cxx:337
 TSpectrum2Transform.cxx:338
 TSpectrum2Transform.cxx:339
 TSpectrum2Transform.cxx:340
 TSpectrum2Transform.cxx:341
 TSpectrum2Transform.cxx:342
 TSpectrum2Transform.cxx:343
 TSpectrum2Transform.cxx:344
 TSpectrum2Transform.cxx:345
 TSpectrum2Transform.cxx:346
 TSpectrum2Transform.cxx:347
 TSpectrum2Transform.cxx:348
 TSpectrum2Transform.cxx:349
 TSpectrum2Transform.cxx:350
 TSpectrum2Transform.cxx:351
 TSpectrum2Transform.cxx:352
 TSpectrum2Transform.cxx:353
 TSpectrum2Transform.cxx:354
 TSpectrum2Transform.cxx:355
 TSpectrum2Transform.cxx:356
 TSpectrum2Transform.cxx:357
 TSpectrum2Transform.cxx:358
 TSpectrum2Transform.cxx:359
 TSpectrum2Transform.cxx:360
 TSpectrum2Transform.cxx:361
 TSpectrum2Transform.cxx:362
 TSpectrum2Transform.cxx:363
 TSpectrum2Transform.cxx:364
 TSpectrum2Transform.cxx:365
 TSpectrum2Transform.cxx:366
 TSpectrum2Transform.cxx:367
 TSpectrum2Transform.cxx:368
 TSpectrum2Transform.cxx:369
 TSpectrum2Transform.cxx:370
 TSpectrum2Transform.cxx:371
 TSpectrum2Transform.cxx:372
 TSpectrum2Transform.cxx:373
 TSpectrum2Transform.cxx:374
 TSpectrum2Transform.cxx:375
 TSpectrum2Transform.cxx:376
 TSpectrum2Transform.cxx:377
 TSpectrum2Transform.cxx:378
 TSpectrum2Transform.cxx:379
 TSpectrum2Transform.cxx:380
 TSpectrum2Transform.cxx:381
 TSpectrum2Transform.cxx:382
 TSpectrum2Transform.cxx:383
 TSpectrum2Transform.cxx:384
 TSpectrum2Transform.cxx:385
 TSpectrum2Transform.cxx:386
 TSpectrum2Transform.cxx:387
 TSpectrum2Transform.cxx:388
 TSpectrum2Transform.cxx:389
 TSpectrum2Transform.cxx:390
 TSpectrum2Transform.cxx:391
 TSpectrum2Transform.cxx:392
 TSpectrum2Transform.cxx:393
 TSpectrum2Transform.cxx:394
 TSpectrum2Transform.cxx:395
 TSpectrum2Transform.cxx:396
 TSpectrum2Transform.cxx:397
 TSpectrum2Transform.cxx:398
 TSpectrum2Transform.cxx:399
 TSpectrum2Transform.cxx:400
 TSpectrum2Transform.cxx:401
 TSpectrum2Transform.cxx:402
 TSpectrum2Transform.cxx:403
 TSpectrum2Transform.cxx:404
 TSpectrum2Transform.cxx:405
 TSpectrum2Transform.cxx:406
 TSpectrum2Transform.cxx:407
 TSpectrum2Transform.cxx:408
 TSpectrum2Transform.cxx:409
 TSpectrum2Transform.cxx:410
 TSpectrum2Transform.cxx:411
 TSpectrum2Transform.cxx:412
 TSpectrum2Transform.cxx:413
 TSpectrum2Transform.cxx:414
 TSpectrum2Transform.cxx:415
 TSpectrum2Transform.cxx:416
 TSpectrum2Transform.cxx:417
 TSpectrum2Transform.cxx:418
 TSpectrum2Transform.cxx:419
 TSpectrum2Transform.cxx:420
 TSpectrum2Transform.cxx:421
 TSpectrum2Transform.cxx:422
 TSpectrum2Transform.cxx:423
 TSpectrum2Transform.cxx:424
 TSpectrum2Transform.cxx:425
 TSpectrum2Transform.cxx:426
 TSpectrum2Transform.cxx:427
 TSpectrum2Transform.cxx:428
 TSpectrum2Transform.cxx:429
 TSpectrum2Transform.cxx:430
 TSpectrum2Transform.cxx:431
 TSpectrum2Transform.cxx:432
 TSpectrum2Transform.cxx:433
 TSpectrum2Transform.cxx:434
 TSpectrum2Transform.cxx:435
 TSpectrum2Transform.cxx:436
 TSpectrum2Transform.cxx:437
 TSpectrum2Transform.cxx:438
 TSpectrum2Transform.cxx:439
 TSpectrum2Transform.cxx:440
 TSpectrum2Transform.cxx:441
 TSpectrum2Transform.cxx:442
 TSpectrum2Transform.cxx:443
 TSpectrum2Transform.cxx:444
 TSpectrum2Transform.cxx:445
 TSpectrum2Transform.cxx:446
 TSpectrum2Transform.cxx:447
 TSpectrum2Transform.cxx:448
 TSpectrum2Transform.cxx:449
 TSpectrum2Transform.cxx:450
 TSpectrum2Transform.cxx:451
 TSpectrum2Transform.cxx:452
 TSpectrum2Transform.cxx:453
 TSpectrum2Transform.cxx:454
 TSpectrum2Transform.cxx:455
 TSpectrum2Transform.cxx:456
 TSpectrum2Transform.cxx:457
 TSpectrum2Transform.cxx:458
 TSpectrum2Transform.cxx:459
 TSpectrum2Transform.cxx:460
 TSpectrum2Transform.cxx:461
 TSpectrum2Transform.cxx:462
 TSpectrum2Transform.cxx:463
 TSpectrum2Transform.cxx:464
 TSpectrum2Transform.cxx:465
 TSpectrum2Transform.cxx:466
 TSpectrum2Transform.cxx:467
 TSpectrum2Transform.cxx:468
 TSpectrum2Transform.cxx:469
 TSpectrum2Transform.cxx:470
 TSpectrum2Transform.cxx:471
 TSpectrum2Transform.cxx:472
 TSpectrum2Transform.cxx:473
 TSpectrum2Transform.cxx:474
 TSpectrum2Transform.cxx:475
 TSpectrum2Transform.cxx:476
 TSpectrum2Transform.cxx:477
 TSpectrum2Transform.cxx:478
 TSpectrum2Transform.cxx:479
 TSpectrum2Transform.cxx:480
 TSpectrum2Transform.cxx:481
 TSpectrum2Transform.cxx:482
 TSpectrum2Transform.cxx:483
 TSpectrum2Transform.cxx:484
 TSpectrum2Transform.cxx:485
 TSpectrum2Transform.cxx:486
 TSpectrum2Transform.cxx:487
 TSpectrum2Transform.cxx:488
 TSpectrum2Transform.cxx:489
 TSpectrum2Transform.cxx:490
 TSpectrum2Transform.cxx:491
 TSpectrum2Transform.cxx:492
 TSpectrum2Transform.cxx:493
 TSpectrum2Transform.cxx:494
 TSpectrum2Transform.cxx:495
 TSpectrum2Transform.cxx:496
 TSpectrum2Transform.cxx:497
 TSpectrum2Transform.cxx:498
 TSpectrum2Transform.cxx:499
 TSpectrum2Transform.cxx:500
 TSpectrum2Transform.cxx:501
 TSpectrum2Transform.cxx:502
 TSpectrum2Transform.cxx:503
 TSpectrum2Transform.cxx:504
 TSpectrum2Transform.cxx:505
 TSpectrum2Transform.cxx:506
 TSpectrum2Transform.cxx:507
 TSpectrum2Transform.cxx:508
 TSpectrum2Transform.cxx:509
 TSpectrum2Transform.cxx:510
 TSpectrum2Transform.cxx:511
 TSpectrum2Transform.cxx:512
 TSpectrum2Transform.cxx:513
 TSpectrum2Transform.cxx:514
 TSpectrum2Transform.cxx:515
 TSpectrum2Transform.cxx:516
 TSpectrum2Transform.cxx:517
 TSpectrum2Transform.cxx:518
 TSpectrum2Transform.cxx:519
 TSpectrum2Transform.cxx:520
 TSpectrum2Transform.cxx:521
 TSpectrum2Transform.cxx:522
 TSpectrum2Transform.cxx:523
 TSpectrum2Transform.cxx:524
 TSpectrum2Transform.cxx:525
 TSpectrum2Transform.cxx:526
 TSpectrum2Transform.cxx:527
 TSpectrum2Transform.cxx:528
 TSpectrum2Transform.cxx:529
 TSpectrum2Transform.cxx:530
 TSpectrum2Transform.cxx:531
 TSpectrum2Transform.cxx:532
 TSpectrum2Transform.cxx:533
 TSpectrum2Transform.cxx:534
 TSpectrum2Transform.cxx:535
 TSpectrum2Transform.cxx:536
 TSpectrum2Transform.cxx:537
 TSpectrum2Transform.cxx:538
 TSpectrum2Transform.cxx:539
 TSpectrum2Transform.cxx:540
 TSpectrum2Transform.cxx:541
 TSpectrum2Transform.cxx:542
 TSpectrum2Transform.cxx:543
 TSpectrum2Transform.cxx:544
 TSpectrum2Transform.cxx:545
 TSpectrum2Transform.cxx:546
 TSpectrum2Transform.cxx:547
 TSpectrum2Transform.cxx:548
 TSpectrum2Transform.cxx:549
 TSpectrum2Transform.cxx:550
 TSpectrum2Transform.cxx:551
 TSpectrum2Transform.cxx:552
 TSpectrum2Transform.cxx:553
 TSpectrum2Transform.cxx:554
 TSpectrum2Transform.cxx:555
 TSpectrum2Transform.cxx:556
 TSpectrum2Transform.cxx:557
 TSpectrum2Transform.cxx:558
 TSpectrum2Transform.cxx:559
 TSpectrum2Transform.cxx:560
 TSpectrum2Transform.cxx:561
 TSpectrum2Transform.cxx:562
 TSpectrum2Transform.cxx:563
 TSpectrum2Transform.cxx:564
 TSpectrum2Transform.cxx:565
 TSpectrum2Transform.cxx:566
 TSpectrum2Transform.cxx:567
 TSpectrum2Transform.cxx:568
 TSpectrum2Transform.cxx:569
 TSpectrum2Transform.cxx:570
 TSpectrum2Transform.cxx:571
 TSpectrum2Transform.cxx:572
 TSpectrum2Transform.cxx:573
 TSpectrum2Transform.cxx:574
 TSpectrum2Transform.cxx:575
 TSpectrum2Transform.cxx:576
 TSpectrum2Transform.cxx:577
 TSpectrum2Transform.cxx:578
 TSpectrum2Transform.cxx:579
 TSpectrum2Transform.cxx:580
 TSpectrum2Transform.cxx:581
 TSpectrum2Transform.cxx:582
 TSpectrum2Transform.cxx:583
 TSpectrum2Transform.cxx:584
 TSpectrum2Transform.cxx:585
 TSpectrum2Transform.cxx:586
 TSpectrum2Transform.cxx:587
 TSpectrum2Transform.cxx:588
 TSpectrum2Transform.cxx:589
 TSpectrum2Transform.cxx:590
 TSpectrum2Transform.cxx:591
 TSpectrum2Transform.cxx:592
 TSpectrum2Transform.cxx:593
 TSpectrum2Transform.cxx:594
 TSpectrum2Transform.cxx:595
 TSpectrum2Transform.cxx:596
 TSpectrum2Transform.cxx:597
 TSpectrum2Transform.cxx:598
 TSpectrum2Transform.cxx:599
 TSpectrum2Transform.cxx:600
 TSpectrum2Transform.cxx:601
 TSpectrum2Transform.cxx:602
 TSpectrum2Transform.cxx:603
 TSpectrum2Transform.cxx:604
 TSpectrum2Transform.cxx:605
 TSpectrum2Transform.cxx:606
 TSpectrum2Transform.cxx:607
 TSpectrum2Transform.cxx:608
 TSpectrum2Transform.cxx:609
 TSpectrum2Transform.cxx:610
 TSpectrum2Transform.cxx:611
 TSpectrum2Transform.cxx:612
 TSpectrum2Transform.cxx:613
 TSpectrum2Transform.cxx:614
 TSpectrum2Transform.cxx:615
 TSpectrum2Transform.cxx:616
 TSpectrum2Transform.cxx:617
 TSpectrum2Transform.cxx:618
 TSpectrum2Transform.cxx:619
 TSpectrum2Transform.cxx:620
 TSpectrum2Transform.cxx:621
 TSpectrum2Transform.cxx:622
 TSpectrum2Transform.cxx:623
 TSpectrum2Transform.cxx:624
 TSpectrum2Transform.cxx:625
 TSpectrum2Transform.cxx:626
 TSpectrum2Transform.cxx:627
 TSpectrum2Transform.cxx:628
 TSpectrum2Transform.cxx:629
 TSpectrum2Transform.cxx:630
 TSpectrum2Transform.cxx:631
 TSpectrum2Transform.cxx:632
 TSpectrum2Transform.cxx:633
 TSpectrum2Transform.cxx:634
 TSpectrum2Transform.cxx:635
 TSpectrum2Transform.cxx:636
 TSpectrum2Transform.cxx:637
 TSpectrum2Transform.cxx:638
 TSpectrum2Transform.cxx:639
 TSpectrum2Transform.cxx:640
 TSpectrum2Transform.cxx:641
 TSpectrum2Transform.cxx:642
 TSpectrum2Transform.cxx:643
 TSpectrum2Transform.cxx:644
 TSpectrum2Transform.cxx:645
 TSpectrum2Transform.cxx:646
 TSpectrum2Transform.cxx:647
 TSpectrum2Transform.cxx:648
 TSpectrum2Transform.cxx:649
 TSpectrum2Transform.cxx:650
 TSpectrum2Transform.cxx:651
 TSpectrum2Transform.cxx:652
 TSpectrum2Transform.cxx:653
 TSpectrum2Transform.cxx:654
 TSpectrum2Transform.cxx:655
 TSpectrum2Transform.cxx:656
 TSpectrum2Transform.cxx:657
 TSpectrum2Transform.cxx:658
 TSpectrum2Transform.cxx:659
 TSpectrum2Transform.cxx:660
 TSpectrum2Transform.cxx:661
 TSpectrum2Transform.cxx:662
 TSpectrum2Transform.cxx:663
 TSpectrum2Transform.cxx:664
 TSpectrum2Transform.cxx:665
 TSpectrum2Transform.cxx:666
 TSpectrum2Transform.cxx:667
 TSpectrum2Transform.cxx:668
 TSpectrum2Transform.cxx:669
 TSpectrum2Transform.cxx:670
 TSpectrum2Transform.cxx:671
 TSpectrum2Transform.cxx:672
 TSpectrum2Transform.cxx:673
 TSpectrum2Transform.cxx:674
 TSpectrum2Transform.cxx:675
 TSpectrum2Transform.cxx:676
 TSpectrum2Transform.cxx:677
 TSpectrum2Transform.cxx:678
 TSpectrum2Transform.cxx:679
 TSpectrum2Transform.cxx:680
 TSpectrum2Transform.cxx:681
 TSpectrum2Transform.cxx:682
 TSpectrum2Transform.cxx:683
 TSpectrum2Transform.cxx:684
 TSpectrum2Transform.cxx:685
 TSpectrum2Transform.cxx:686
 TSpectrum2Transform.cxx:687
 TSpectrum2Transform.cxx:688
 TSpectrum2Transform.cxx:689
 TSpectrum2Transform.cxx:690
 TSpectrum2Transform.cxx:691
 TSpectrum2Transform.cxx:692
 TSpectrum2Transform.cxx:693
 TSpectrum2Transform.cxx:694
 TSpectrum2Transform.cxx:695
 TSpectrum2Transform.cxx:696
 TSpectrum2Transform.cxx:697
 TSpectrum2Transform.cxx:698
 TSpectrum2Transform.cxx:699
 TSpectrum2Transform.cxx:700
 TSpectrum2Transform.cxx:701
 TSpectrum2Transform.cxx:702
 TSpectrum2Transform.cxx:703
 TSpectrum2Transform.cxx:704
 TSpectrum2Transform.cxx:705
 TSpectrum2Transform.cxx:706
 TSpectrum2Transform.cxx:707
 TSpectrum2Transform.cxx:708
 TSpectrum2Transform.cxx:709
 TSpectrum2Transform.cxx:710
 TSpectrum2Transform.cxx:711
 TSpectrum2Transform.cxx:712
 TSpectrum2Transform.cxx:713
 TSpectrum2Transform.cxx:714
 TSpectrum2Transform.cxx:715
 TSpectrum2Transform.cxx:716
 TSpectrum2Transform.cxx:717
 TSpectrum2Transform.cxx:718
 TSpectrum2Transform.cxx:719
 TSpectrum2Transform.cxx:720
 TSpectrum2Transform.cxx:721
 TSpectrum2Transform.cxx:722
 TSpectrum2Transform.cxx:723
 TSpectrum2Transform.cxx:724
 TSpectrum2Transform.cxx:725
 TSpectrum2Transform.cxx:726
 TSpectrum2Transform.cxx:727
 TSpectrum2Transform.cxx:728
 TSpectrum2Transform.cxx:729
 TSpectrum2Transform.cxx:730
 TSpectrum2Transform.cxx:731
 TSpectrum2Transform.cxx:732
 TSpectrum2Transform.cxx:733
 TSpectrum2Transform.cxx:734
 TSpectrum2Transform.cxx:735
 TSpectrum2Transform.cxx:736
 TSpectrum2Transform.cxx:737
 TSpectrum2Transform.cxx:738
 TSpectrum2Transform.cxx:739
 TSpectrum2Transform.cxx:740
 TSpectrum2Transform.cxx:741
 TSpectrum2Transform.cxx:742
 TSpectrum2Transform.cxx:743
 TSpectrum2Transform.cxx:744
 TSpectrum2Transform.cxx:745
 TSpectrum2Transform.cxx:746
 TSpectrum2Transform.cxx:747
 TSpectrum2Transform.cxx:748
 TSpectrum2Transform.cxx:749
 TSpectrum2Transform.cxx:750
 TSpectrum2Transform.cxx:751
 TSpectrum2Transform.cxx:752
 TSpectrum2Transform.cxx:753
 TSpectrum2Transform.cxx:754
 TSpectrum2Transform.cxx:755
 TSpectrum2Transform.cxx:756
 TSpectrum2Transform.cxx:757
 TSpectrum2Transform.cxx:758
 TSpectrum2Transform.cxx:759
 TSpectrum2Transform.cxx:760
 TSpectrum2Transform.cxx:761
 TSpectrum2Transform.cxx:762
 TSpectrum2Transform.cxx:763
 TSpectrum2Transform.cxx:764
 TSpectrum2Transform.cxx:765
 TSpectrum2Transform.cxx:766
 TSpectrum2Transform.cxx:767
 TSpectrum2Transform.cxx:768
 TSpectrum2Transform.cxx:769
 TSpectrum2Transform.cxx:770
 TSpectrum2Transform.cxx:771
 TSpectrum2Transform.cxx:772
 TSpectrum2Transform.cxx:773
 TSpectrum2Transform.cxx:774
 TSpectrum2Transform.cxx:775
 TSpectrum2Transform.cxx:776
 TSpectrum2Transform.cxx:777
 TSpectrum2Transform.cxx:778
 TSpectrum2Transform.cxx:779
 TSpectrum2Transform.cxx:780
 TSpectrum2Transform.cxx:781
 TSpectrum2Transform.cxx:782
 TSpectrum2Transform.cxx:783
 TSpectrum2Transform.cxx:784
 TSpectrum2Transform.cxx:785
 TSpectrum2Transform.cxx:786
 TSpectrum2Transform.cxx:787
 TSpectrum2Transform.cxx:788
 TSpectrum2Transform.cxx:789
 TSpectrum2Transform.cxx:790
 TSpectrum2Transform.cxx:791
 TSpectrum2Transform.cxx:792
 TSpectrum2Transform.cxx:793
 TSpectrum2Transform.cxx:794
 TSpectrum2Transform.cxx:795
 TSpectrum2Transform.cxx:796
 TSpectrum2Transform.cxx:797
 TSpectrum2Transform.cxx:798
 TSpectrum2Transform.cxx:799
 TSpectrum2Transform.cxx:800
 TSpectrum2Transform.cxx:801
 TSpectrum2Transform.cxx:802
 TSpectrum2Transform.cxx:803
 TSpectrum2Transform.cxx:804
 TSpectrum2Transform.cxx:805
 TSpectrum2Transform.cxx:806
 TSpectrum2Transform.cxx:807
 TSpectrum2Transform.cxx:808
 TSpectrum2Transform.cxx:809
 TSpectrum2Transform.cxx:810
 TSpectrum2Transform.cxx:811
 TSpectrum2Transform.cxx:812
 TSpectrum2Transform.cxx:813
 TSpectrum2Transform.cxx:814
 TSpectrum2Transform.cxx:815
 TSpectrum2Transform.cxx:816
 TSpectrum2Transform.cxx:817
 TSpectrum2Transform.cxx:818
 TSpectrum2Transform.cxx:819
 TSpectrum2Transform.cxx:820
 TSpectrum2Transform.cxx:821
 TSpectrum2Transform.cxx:822
 TSpectrum2Transform.cxx:823
 TSpectrum2Transform.cxx:824
 TSpectrum2Transform.cxx:825
 TSpectrum2Transform.cxx:826
 TSpectrum2Transform.cxx:827
 TSpectrum2Transform.cxx:828
 TSpectrum2Transform.cxx:829
 TSpectrum2Transform.cxx:830
 TSpectrum2Transform.cxx:831
 TSpectrum2Transform.cxx:832
 TSpectrum2Transform.cxx:833
 TSpectrum2Transform.cxx:834
 TSpectrum2Transform.cxx:835
 TSpectrum2Transform.cxx:836
 TSpectrum2Transform.cxx:837
 TSpectrum2Transform.cxx:838
 TSpectrum2Transform.cxx:839
 TSpectrum2Transform.cxx:840
 TSpectrum2Transform.cxx:841
 TSpectrum2Transform.cxx:842
 TSpectrum2Transform.cxx:843
 TSpectrum2Transform.cxx:844
 TSpectrum2Transform.cxx:845
 TSpectrum2Transform.cxx:846
 TSpectrum2Transform.cxx:847
 TSpectrum2Transform.cxx:848
 TSpectrum2Transform.cxx:849
 TSpectrum2Transform.cxx:850
 TSpectrum2Transform.cxx:851
 TSpectrum2Transform.cxx:852
 TSpectrum2Transform.cxx:853
 TSpectrum2Transform.cxx:854
 TSpectrum2Transform.cxx:855
 TSpectrum2Transform.cxx:856
 TSpectrum2Transform.cxx:857
 TSpectrum2Transform.cxx:858
 TSpectrum2Transform.cxx:859
 TSpectrum2Transform.cxx:860
 TSpectrum2Transform.cxx:861
 TSpectrum2Transform.cxx:862
 TSpectrum2Transform.cxx:863
 TSpectrum2Transform.cxx:864
 TSpectrum2Transform.cxx:865
 TSpectrum2Transform.cxx:866
 TSpectrum2Transform.cxx:867
 TSpectrum2Transform.cxx:868
 TSpectrum2Transform.cxx:869
 TSpectrum2Transform.cxx:870
 TSpectrum2Transform.cxx:871
 TSpectrum2Transform.cxx:872
 TSpectrum2Transform.cxx:873
 TSpectrum2Transform.cxx:874
 TSpectrum2Transform.cxx:875
 TSpectrum2Transform.cxx:876
 TSpectrum2Transform.cxx:877
 TSpectrum2Transform.cxx:878
 TSpectrum2Transform.cxx:879
 TSpectrum2Transform.cxx:880
 TSpectrum2Transform.cxx:881
 TSpectrum2Transform.cxx:882
 TSpectrum2Transform.cxx:883
 TSpectrum2Transform.cxx:884
 TSpectrum2Transform.cxx:885
 TSpectrum2Transform.cxx:886
 TSpectrum2Transform.cxx:887
 TSpectrum2Transform.cxx:888
 TSpectrum2Transform.cxx:889
 TSpectrum2Transform.cxx:890
 TSpectrum2Transform.cxx:891
 TSpectrum2Transform.cxx:892
 TSpectrum2Transform.cxx:893
 TSpectrum2Transform.cxx:894
 TSpectrum2Transform.cxx:895
 TSpectrum2Transform.cxx:896
 TSpectrum2Transform.cxx:897
 TSpectrum2Transform.cxx:898
 TSpectrum2Transform.cxx:899
 TSpectrum2Transform.cxx:900
 TSpectrum2Transform.cxx:901
 TSpectrum2Transform.cxx:902
 TSpectrum2Transform.cxx:903
 TSpectrum2Transform.cxx:904
 TSpectrum2Transform.cxx:905
 TSpectrum2Transform.cxx:906
 TSpectrum2Transform.cxx:907
 TSpectrum2Transform.cxx:908
 TSpectrum2Transform.cxx:909
 TSpectrum2Transform.cxx:910
 TSpectrum2Transform.cxx:911
 TSpectrum2Transform.cxx:912
 TSpectrum2Transform.cxx:913
 TSpectrum2Transform.cxx:914
 TSpectrum2Transform.cxx:915
 TSpectrum2Transform.cxx:916
 TSpectrum2Transform.cxx:917
 TSpectrum2Transform.cxx:918
 TSpectrum2Transform.cxx:919
 TSpectrum2Transform.cxx:920
 TSpectrum2Transform.cxx:921
 TSpectrum2Transform.cxx:922
 TSpectrum2Transform.cxx:923
 TSpectrum2Transform.cxx:924
 TSpectrum2Transform.cxx:925
 TSpectrum2Transform.cxx:926
 TSpectrum2Transform.cxx:927
 TSpectrum2Transform.cxx:928
 TSpectrum2Transform.cxx:929
 TSpectrum2Transform.cxx:930
 TSpectrum2Transform.cxx:931
 TSpectrum2Transform.cxx:932
 TSpectrum2Transform.cxx:933
 TSpectrum2Transform.cxx:934
 TSpectrum2Transform.cxx:935
 TSpectrum2Transform.cxx:936
 TSpectrum2Transform.cxx:937
 TSpectrum2Transform.cxx:938
 TSpectrum2Transform.cxx:939
 TSpectrum2Transform.cxx:940
 TSpectrum2Transform.cxx:941
 TSpectrum2Transform.cxx:942
 TSpectrum2Transform.cxx:943
 TSpectrum2Transform.cxx:944
 TSpectrum2Transform.cxx:945
 TSpectrum2Transform.cxx:946
 TSpectrum2Transform.cxx:947
 TSpectrum2Transform.cxx:948
 TSpectrum2Transform.cxx:949
 TSpectrum2Transform.cxx:950
 TSpectrum2Transform.cxx:951
 TSpectrum2Transform.cxx:952
 TSpectrum2Transform.cxx:953
 TSpectrum2Transform.cxx:954
 TSpectrum2Transform.cxx:955
 TSpectrum2Transform.cxx:956
 TSpectrum2Transform.cxx:957
 TSpectrum2Transform.cxx:958
 TSpectrum2Transform.cxx:959
 TSpectrum2Transform.cxx:960
 TSpectrum2Transform.cxx:961
 TSpectrum2Transform.cxx:962
 TSpectrum2Transform.cxx:963
 TSpectrum2Transform.cxx:964
 TSpectrum2Transform.cxx:965
 TSpectrum2Transform.cxx:966
 TSpectrum2Transform.cxx:967
 TSpectrum2Transform.cxx:968
 TSpectrum2Transform.cxx:969
 TSpectrum2Transform.cxx:970
 TSpectrum2Transform.cxx:971
 TSpectrum2Transform.cxx:972
 TSpectrum2Transform.cxx:973
 TSpectrum2Transform.cxx:974
 TSpectrum2Transform.cxx:975
 TSpectrum2Transform.cxx:976
 TSpectrum2Transform.cxx:977
 TSpectrum2Transform.cxx:978
 TSpectrum2Transform.cxx:979
 TSpectrum2Transform.cxx:980
 TSpectrum2Transform.cxx:981
 TSpectrum2Transform.cxx:982
 TSpectrum2Transform.cxx:983
 TSpectrum2Transform.cxx:984
 TSpectrum2Transform.cxx:985
 TSpectrum2Transform.cxx:986
 TSpectrum2Transform.cxx:987
 TSpectrum2Transform.cxx:988
 TSpectrum2Transform.cxx:989
 TSpectrum2Transform.cxx:990
 TSpectrum2Transform.cxx:991
 TSpectrum2Transform.cxx:992
 TSpectrum2Transform.cxx:993
 TSpectrum2Transform.cxx:994
 TSpectrum2Transform.cxx:995
 TSpectrum2Transform.cxx:996
 TSpectrum2Transform.cxx:997
 TSpectrum2Transform.cxx:998
 TSpectrum2Transform.cxx:999
 TSpectrum2Transform.cxx:1000
 TSpectrum2Transform.cxx:1001
 TSpectrum2Transform.cxx:1002
 TSpectrum2Transform.cxx:1003
 TSpectrum2Transform.cxx:1004
 TSpectrum2Transform.cxx:1005
 TSpectrum2Transform.cxx:1006
 TSpectrum2Transform.cxx:1007
 TSpectrum2Transform.cxx:1008
 TSpectrum2Transform.cxx:1009
 TSpectrum2Transform.cxx:1010
 TSpectrum2Transform.cxx:1011
 TSpectrum2Transform.cxx:1012
 TSpectrum2Transform.cxx:1013
 TSpectrum2Transform.cxx:1014
 TSpectrum2Transform.cxx:1015
 TSpectrum2Transform.cxx:1016
 TSpectrum2Transform.cxx:1017
 TSpectrum2Transform.cxx:1018
 TSpectrum2Transform.cxx:1019
 TSpectrum2Transform.cxx:1020
 TSpectrum2Transform.cxx:1021
 TSpectrum2Transform.cxx:1022
 TSpectrum2Transform.cxx:1023
 TSpectrum2Transform.cxx:1024
 TSpectrum2Transform.cxx:1025
 TSpectrum2Transform.cxx:1026
 TSpectrum2Transform.cxx:1027
 TSpectrum2Transform.cxx:1028
 TSpectrum2Transform.cxx:1029
 TSpectrum2Transform.cxx:1030
 TSpectrum2Transform.cxx:1031
 TSpectrum2Transform.cxx:1032
 TSpectrum2Transform.cxx:1033
 TSpectrum2Transform.cxx:1034
 TSpectrum2Transform.cxx:1035
 TSpectrum2Transform.cxx:1036
 TSpectrum2Transform.cxx:1037
 TSpectrum2Transform.cxx:1038
 TSpectrum2Transform.cxx:1039
 TSpectrum2Transform.cxx:1040
 TSpectrum2Transform.cxx:1041
 TSpectrum2Transform.cxx:1042
 TSpectrum2Transform.cxx:1043
 TSpectrum2Transform.cxx:1044
 TSpectrum2Transform.cxx:1045
 TSpectrum2Transform.cxx:1046
 TSpectrum2Transform.cxx:1047
 TSpectrum2Transform.cxx:1048
 TSpectrum2Transform.cxx:1049
 TSpectrum2Transform.cxx:1050
 TSpectrum2Transform.cxx:1051
 TSpectrum2Transform.cxx:1052
 TSpectrum2Transform.cxx:1053
 TSpectrum2Transform.cxx:1054
 TSpectrum2Transform.cxx:1055
 TSpectrum2Transform.cxx:1056
 TSpectrum2Transform.cxx:1057
 TSpectrum2Transform.cxx:1058
 TSpectrum2Transform.cxx:1059
 TSpectrum2Transform.cxx:1060
 TSpectrum2Transform.cxx:1061
 TSpectrum2Transform.cxx:1062
 TSpectrum2Transform.cxx:1063
 TSpectrum2Transform.cxx:1064
 TSpectrum2Transform.cxx:1065
 TSpectrum2Transform.cxx:1066
 TSpectrum2Transform.cxx:1067
 TSpectrum2Transform.cxx:1068
 TSpectrum2Transform.cxx:1069
 TSpectrum2Transform.cxx:1070
 TSpectrum2Transform.cxx:1071
 TSpectrum2Transform.cxx:1072
 TSpectrum2Transform.cxx:1073
 TSpectrum2Transform.cxx:1074
 TSpectrum2Transform.cxx:1075
 TSpectrum2Transform.cxx:1076
 TSpectrum2Transform.cxx:1077
 TSpectrum2Transform.cxx:1078
 TSpectrum2Transform.cxx:1079
 TSpectrum2Transform.cxx:1080
 TSpectrum2Transform.cxx:1081
 TSpectrum2Transform.cxx:1082
 TSpectrum2Transform.cxx:1083
 TSpectrum2Transform.cxx:1084
 TSpectrum2Transform.cxx:1085
 TSpectrum2Transform.cxx:1086
 TSpectrum2Transform.cxx:1087
 TSpectrum2Transform.cxx:1088
 TSpectrum2Transform.cxx:1089
 TSpectrum2Transform.cxx:1090
 TSpectrum2Transform.cxx:1091
 TSpectrum2Transform.cxx:1092
 TSpectrum2Transform.cxx:1093
 TSpectrum2Transform.cxx:1094
 TSpectrum2Transform.cxx:1095
 TSpectrum2Transform.cxx:1096
 TSpectrum2Transform.cxx:1097
 TSpectrum2Transform.cxx:1098
 TSpectrum2Transform.cxx:1099
 TSpectrum2Transform.cxx:1100
 TSpectrum2Transform.cxx:1101
 TSpectrum2Transform.cxx:1102
 TSpectrum2Transform.cxx:1103
 TSpectrum2Transform.cxx:1104
 TSpectrum2Transform.cxx:1105
 TSpectrum2Transform.cxx:1106
 TSpectrum2Transform.cxx:1107
 TSpectrum2Transform.cxx:1108
 TSpectrum2Transform.cxx:1109
 TSpectrum2Transform.cxx:1110
 TSpectrum2Transform.cxx:1111
 TSpectrum2Transform.cxx:1112
 TSpectrum2Transform.cxx:1113
 TSpectrum2Transform.cxx:1114
 TSpectrum2Transform.cxx:1115
 TSpectrum2Transform.cxx:1116
 TSpectrum2Transform.cxx:1117
 TSpectrum2Transform.cxx:1118
 TSpectrum2Transform.cxx:1119
 TSpectrum2Transform.cxx:1120
 TSpectrum2Transform.cxx:1121
 TSpectrum2Transform.cxx:1122
 TSpectrum2Transform.cxx:1123
 TSpectrum2Transform.cxx:1124
 TSpectrum2Transform.cxx:1125
 TSpectrum2Transform.cxx:1126
 TSpectrum2Transform.cxx:1127
 TSpectrum2Transform.cxx:1128
 TSpectrum2Transform.cxx:1129
 TSpectrum2Transform.cxx:1130
 TSpectrum2Transform.cxx:1131
 TSpectrum2Transform.cxx:1132
 TSpectrum2Transform.cxx:1133
 TSpectrum2Transform.cxx:1134
 TSpectrum2Transform.cxx:1135
 TSpectrum2Transform.cxx:1136
 TSpectrum2Transform.cxx:1137
 TSpectrum2Transform.cxx:1138
 TSpectrum2Transform.cxx:1139
 TSpectrum2Transform.cxx:1140
 TSpectrum2Transform.cxx:1141
 TSpectrum2Transform.cxx:1142
 TSpectrum2Transform.cxx:1143
 TSpectrum2Transform.cxx:1144
 TSpectrum2Transform.cxx:1145
 TSpectrum2Transform.cxx:1146
 TSpectrum2Transform.cxx:1147
 TSpectrum2Transform.cxx:1148
 TSpectrum2Transform.cxx:1149
 TSpectrum2Transform.cxx:1150
 TSpectrum2Transform.cxx:1151
 TSpectrum2Transform.cxx:1152
 TSpectrum2Transform.cxx:1153
 TSpectrum2Transform.cxx:1154
 TSpectrum2Transform.cxx:1155
 TSpectrum2Transform.cxx:1156
 TSpectrum2Transform.cxx:1157
 TSpectrum2Transform.cxx:1158
 TSpectrum2Transform.cxx:1159
 TSpectrum2Transform.cxx:1160
 TSpectrum2Transform.cxx:1161
 TSpectrum2Transform.cxx:1162
 TSpectrum2Transform.cxx:1163
 TSpectrum2Transform.cxx:1164
 TSpectrum2Transform.cxx:1165
 TSpectrum2Transform.cxx:1166
 TSpectrum2Transform.cxx:1167
 TSpectrum2Transform.cxx:1168
 TSpectrum2Transform.cxx:1169
 TSpectrum2Transform.cxx:1170
 TSpectrum2Transform.cxx:1171
 TSpectrum2Transform.cxx:1172
 TSpectrum2Transform.cxx:1173
 TSpectrum2Transform.cxx:1174
 TSpectrum2Transform.cxx:1175
 TSpectrum2Transform.cxx:1176
 TSpectrum2Transform.cxx:1177
 TSpectrum2Transform.cxx:1178
 TSpectrum2Transform.cxx:1179
 TSpectrum2Transform.cxx:1180
 TSpectrum2Transform.cxx:1181
 TSpectrum2Transform.cxx:1182
 TSpectrum2Transform.cxx:1183
 TSpectrum2Transform.cxx:1184
 TSpectrum2Transform.cxx:1185
 TSpectrum2Transform.cxx:1186
 TSpectrum2Transform.cxx:1187
 TSpectrum2Transform.cxx:1188
 TSpectrum2Transform.cxx:1189
 TSpectrum2Transform.cxx:1190
 TSpectrum2Transform.cxx:1191
 TSpectrum2Transform.cxx:1192
 TSpectrum2Transform.cxx:1193
 TSpectrum2Transform.cxx:1194
 TSpectrum2Transform.cxx:1195
 TSpectrum2Transform.cxx:1196
 TSpectrum2Transform.cxx:1197
 TSpectrum2Transform.cxx:1198
 TSpectrum2Transform.cxx:1199
 TSpectrum2Transform.cxx:1200
 TSpectrum2Transform.cxx:1201
 TSpectrum2Transform.cxx:1202
 TSpectrum2Transform.cxx:1203
 TSpectrum2Transform.cxx:1204
 TSpectrum2Transform.cxx:1205
 TSpectrum2Transform.cxx:1206
 TSpectrum2Transform.cxx:1207
 TSpectrum2Transform.cxx:1208
 TSpectrum2Transform.cxx:1209
 TSpectrum2Transform.cxx:1210
 TSpectrum2Transform.cxx:1211
 TSpectrum2Transform.cxx:1212
 TSpectrum2Transform.cxx:1213
 TSpectrum2Transform.cxx:1214
 TSpectrum2Transform.cxx:1215
 TSpectrum2Transform.cxx:1216
 TSpectrum2Transform.cxx:1217
 TSpectrum2Transform.cxx:1218
 TSpectrum2Transform.cxx:1219
 TSpectrum2Transform.cxx:1220
 TSpectrum2Transform.cxx:1221
 TSpectrum2Transform.cxx:1222
 TSpectrum2Transform.cxx:1223
 TSpectrum2Transform.cxx:1224
 TSpectrum2Transform.cxx:1225
 TSpectrum2Transform.cxx:1226
 TSpectrum2Transform.cxx:1227
 TSpectrum2Transform.cxx:1228
 TSpectrum2Transform.cxx:1229
 TSpectrum2Transform.cxx:1230
 TSpectrum2Transform.cxx:1231
 TSpectrum2Transform.cxx:1232
 TSpectrum2Transform.cxx:1233
 TSpectrum2Transform.cxx:1234
 TSpectrum2Transform.cxx:1235
 TSpectrum2Transform.cxx:1236
 TSpectrum2Transform.cxx:1237
 TSpectrum2Transform.cxx:1238
 TSpectrum2Transform.cxx:1239
 TSpectrum2Transform.cxx:1240
 TSpectrum2Transform.cxx:1241
 TSpectrum2Transform.cxx:1242
 TSpectrum2Transform.cxx:1243
 TSpectrum2Transform.cxx:1244
 TSpectrum2Transform.cxx:1245
 TSpectrum2Transform.cxx:1246
 TSpectrum2Transform.cxx:1247
 TSpectrum2Transform.cxx:1248
 TSpectrum2Transform.cxx:1249
 TSpectrum2Transform.cxx:1250
 TSpectrum2Transform.cxx:1251
 TSpectrum2Transform.cxx:1252
 TSpectrum2Transform.cxx:1253
 TSpectrum2Transform.cxx:1254
 TSpectrum2Transform.cxx:1255
 TSpectrum2Transform.cxx:1256
 TSpectrum2Transform.cxx:1257
 TSpectrum2Transform.cxx:1258
 TSpectrum2Transform.cxx:1259
 TSpectrum2Transform.cxx:1260
 TSpectrum2Transform.cxx:1261
 TSpectrum2Transform.cxx:1262
 TSpectrum2Transform.cxx:1263
 TSpectrum2Transform.cxx:1264
 TSpectrum2Transform.cxx:1265
 TSpectrum2Transform.cxx:1266
 TSpectrum2Transform.cxx:1267
 TSpectrum2Transform.cxx:1268
 TSpectrum2Transform.cxx:1269
 TSpectrum2Transform.cxx:1270
 TSpectrum2Transform.cxx:1271
 TSpectrum2Transform.cxx:1272
 TSpectrum2Transform.cxx:1273
 TSpectrum2Transform.cxx:1274
 TSpectrum2Transform.cxx:1275
 TSpectrum2Transform.cxx:1276
 TSpectrum2Transform.cxx:1277
 TSpectrum2Transform.cxx:1278
 TSpectrum2Transform.cxx:1279
 TSpectrum2Transform.cxx:1280
 TSpectrum2Transform.cxx:1281
 TSpectrum2Transform.cxx:1282
 TSpectrum2Transform.cxx:1283
 TSpectrum2Transform.cxx:1284
 TSpectrum2Transform.cxx:1285
 TSpectrum2Transform.cxx:1286
 TSpectrum2Transform.cxx:1287
 TSpectrum2Transform.cxx:1288
 TSpectrum2Transform.cxx:1289
 TSpectrum2Transform.cxx:1290
 TSpectrum2Transform.cxx:1291
 TSpectrum2Transform.cxx:1292
 TSpectrum2Transform.cxx:1293
 TSpectrum2Transform.cxx:1294
 TSpectrum2Transform.cxx:1295
 TSpectrum2Transform.cxx:1296
 TSpectrum2Transform.cxx:1297
 TSpectrum2Transform.cxx:1298
 TSpectrum2Transform.cxx:1299
 TSpectrum2Transform.cxx:1300
 TSpectrum2Transform.cxx:1301
 TSpectrum2Transform.cxx:1302
 TSpectrum2Transform.cxx:1303
 TSpectrum2Transform.cxx:1304
 TSpectrum2Transform.cxx:1305
 TSpectrum2Transform.cxx:1306
 TSpectrum2Transform.cxx:1307
 TSpectrum2Transform.cxx:1308
 TSpectrum2Transform.cxx:1309
 TSpectrum2Transform.cxx:1310
 TSpectrum2Transform.cxx:1311
 TSpectrum2Transform.cxx:1312
 TSpectrum2Transform.cxx:1313
 TSpectrum2Transform.cxx:1314
 TSpectrum2Transform.cxx:1315
 TSpectrum2Transform.cxx:1316
 TSpectrum2Transform.cxx:1317
 TSpectrum2Transform.cxx:1318
 TSpectrum2Transform.cxx:1319
 TSpectrum2Transform.cxx:1320
 TSpectrum2Transform.cxx:1321
 TSpectrum2Transform.cxx:1322
 TSpectrum2Transform.cxx:1323
 TSpectrum2Transform.cxx:1324
 TSpectrum2Transform.cxx:1325
 TSpectrum2Transform.cxx:1326
 TSpectrum2Transform.cxx:1327
 TSpectrum2Transform.cxx:1328
 TSpectrum2Transform.cxx:1329
 TSpectrum2Transform.cxx:1330
 TSpectrum2Transform.cxx:1331
 TSpectrum2Transform.cxx:1332
 TSpectrum2Transform.cxx:1333
 TSpectrum2Transform.cxx:1334
 TSpectrum2Transform.cxx:1335
 TSpectrum2Transform.cxx:1336
 TSpectrum2Transform.cxx:1337
 TSpectrum2Transform.cxx:1338
 TSpectrum2Transform.cxx:1339
 TSpectrum2Transform.cxx:1340
 TSpectrum2Transform.cxx:1341
 TSpectrum2Transform.cxx:1342
 TSpectrum2Transform.cxx:1343
 TSpectrum2Transform.cxx:1344
 TSpectrum2Transform.cxx:1345
 TSpectrum2Transform.cxx:1346
 TSpectrum2Transform.cxx:1347
 TSpectrum2Transform.cxx:1348
 TSpectrum2Transform.cxx:1349
 TSpectrum2Transform.cxx:1350
 TSpectrum2Transform.cxx:1351
 TSpectrum2Transform.cxx:1352
 TSpectrum2Transform.cxx:1353
 TSpectrum2Transform.cxx:1354
 TSpectrum2Transform.cxx:1355
 TSpectrum2Transform.cxx:1356
 TSpectrum2Transform.cxx:1357
 TSpectrum2Transform.cxx:1358
 TSpectrum2Transform.cxx:1359
 TSpectrum2Transform.cxx:1360
 TSpectrum2Transform.cxx:1361
 TSpectrum2Transform.cxx:1362
 TSpectrum2Transform.cxx:1363
 TSpectrum2Transform.cxx:1364
 TSpectrum2Transform.cxx:1365
 TSpectrum2Transform.cxx:1366
 TSpectrum2Transform.cxx:1367
 TSpectrum2Transform.cxx:1368
 TSpectrum2Transform.cxx:1369
 TSpectrum2Transform.cxx:1370
 TSpectrum2Transform.cxx:1371
 TSpectrum2Transform.cxx:1372
 TSpectrum2Transform.cxx:1373
 TSpectrum2Transform.cxx:1374
 TSpectrum2Transform.cxx:1375
 TSpectrum2Transform.cxx:1376
 TSpectrum2Transform.cxx:1377
 TSpectrum2Transform.cxx:1378
 TSpectrum2Transform.cxx:1379
 TSpectrum2Transform.cxx:1380
 TSpectrum2Transform.cxx:1381
 TSpectrum2Transform.cxx:1382
 TSpectrum2Transform.cxx:1383
 TSpectrum2Transform.cxx:1384
 TSpectrum2Transform.cxx:1385
 TSpectrum2Transform.cxx:1386
 TSpectrum2Transform.cxx:1387
 TSpectrum2Transform.cxx:1388
 TSpectrum2Transform.cxx:1389
 TSpectrum2Transform.cxx:1390
 TSpectrum2Transform.cxx:1391
 TSpectrum2Transform.cxx:1392
 TSpectrum2Transform.cxx:1393
 TSpectrum2Transform.cxx:1394
 TSpectrum2Transform.cxx:1395
 TSpectrum2Transform.cxx:1396
 TSpectrum2Transform.cxx:1397
 TSpectrum2Transform.cxx:1398
 TSpectrum2Transform.cxx:1399
 TSpectrum2Transform.cxx:1400
 TSpectrum2Transform.cxx:1401
 TSpectrum2Transform.cxx:1402
 TSpectrum2Transform.cxx:1403
 TSpectrum2Transform.cxx:1404
 TSpectrum2Transform.cxx:1405
 TSpectrum2Transform.cxx:1406
 TSpectrum2Transform.cxx:1407
 TSpectrum2Transform.cxx:1408
 TSpectrum2Transform.cxx:1409
 TSpectrum2Transform.cxx:1410
 TSpectrum2Transform.cxx:1411
 TSpectrum2Transform.cxx:1412
 TSpectrum2Transform.cxx:1413
 TSpectrum2Transform.cxx:1414
 TSpectrum2Transform.cxx:1415
 TSpectrum2Transform.cxx:1416
 TSpectrum2Transform.cxx:1417
 TSpectrum2Transform.cxx:1418
 TSpectrum2Transform.cxx:1419
 TSpectrum2Transform.cxx:1420
 TSpectrum2Transform.cxx:1421
 TSpectrum2Transform.cxx:1422
 TSpectrum2Transform.cxx:1423
 TSpectrum2Transform.cxx:1424
 TSpectrum2Transform.cxx:1425
 TSpectrum2Transform.cxx:1426
 TSpectrum2Transform.cxx:1427
 TSpectrum2Transform.cxx:1428
 TSpectrum2Transform.cxx:1429
 TSpectrum2Transform.cxx:1430
 TSpectrum2Transform.cxx:1431
 TSpectrum2Transform.cxx:1432
 TSpectrum2Transform.cxx:1433
 TSpectrum2Transform.cxx:1434
 TSpectrum2Transform.cxx:1435
 TSpectrum2Transform.cxx:1436
 TSpectrum2Transform.cxx:1437
 TSpectrum2Transform.cxx:1438
 TSpectrum2Transform.cxx:1439
 TSpectrum2Transform.cxx:1440
 TSpectrum2Transform.cxx:1441
 TSpectrum2Transform.cxx:1442
 TSpectrum2Transform.cxx:1443
 TSpectrum2Transform.cxx:1444
 TSpectrum2Transform.cxx:1445
 TSpectrum2Transform.cxx:1446
 TSpectrum2Transform.cxx:1447
 TSpectrum2Transform.cxx:1448
 TSpectrum2Transform.cxx:1449
 TSpectrum2Transform.cxx:1450
 TSpectrum2Transform.cxx:1451
 TSpectrum2Transform.cxx:1452
 TSpectrum2Transform.cxx:1453
 TSpectrum2Transform.cxx:1454
 TSpectrum2Transform.cxx:1455
 TSpectrum2Transform.cxx:1456
 TSpectrum2Transform.cxx:1457
 TSpectrum2Transform.cxx:1458
 TSpectrum2Transform.cxx:1459
 TSpectrum2Transform.cxx:1460
 TSpectrum2Transform.cxx:1461
 TSpectrum2Transform.cxx:1462
 TSpectrum2Transform.cxx:1463
 TSpectrum2Transform.cxx:1464
 TSpectrum2Transform.cxx:1465
 TSpectrum2Transform.cxx:1466
 TSpectrum2Transform.cxx:1467
 TSpectrum2Transform.cxx:1468
 TSpectrum2Transform.cxx:1469
 TSpectrum2Transform.cxx:1470
 TSpectrum2Transform.cxx:1471
 TSpectrum2Transform.cxx:1472
 TSpectrum2Transform.cxx:1473
 TSpectrum2Transform.cxx:1474
 TSpectrum2Transform.cxx:1475
 TSpectrum2Transform.cxx:1476
 TSpectrum2Transform.cxx:1477
 TSpectrum2Transform.cxx:1478
 TSpectrum2Transform.cxx:1479
 TSpectrum2Transform.cxx:1480
 TSpectrum2Transform.cxx:1481
 TSpectrum2Transform.cxx:1482
 TSpectrum2Transform.cxx:1483
 TSpectrum2Transform.cxx:1484
 TSpectrum2Transform.cxx:1485
 TSpectrum2Transform.cxx:1486
 TSpectrum2Transform.cxx:1487
 TSpectrum2Transform.cxx:1488
 TSpectrum2Transform.cxx:1489
 TSpectrum2Transform.cxx:1490
 TSpectrum2Transform.cxx:1491
 TSpectrum2Transform.cxx:1492
 TSpectrum2Transform.cxx:1493
 TSpectrum2Transform.cxx:1494
 TSpectrum2Transform.cxx:1495
 TSpectrum2Transform.cxx:1496
 TSpectrum2Transform.cxx:1497
 TSpectrum2Transform.cxx:1498
 TSpectrum2Transform.cxx:1499
 TSpectrum2Transform.cxx:1500
 TSpectrum2Transform.cxx:1501
 TSpectrum2Transform.cxx:1502
 TSpectrum2Transform.cxx:1503
 TSpectrum2Transform.cxx:1504
 TSpectrum2Transform.cxx:1505
 TSpectrum2Transform.cxx:1506
 TSpectrum2Transform.cxx:1507
 TSpectrum2Transform.cxx:1508
 TSpectrum2Transform.cxx:1509
 TSpectrum2Transform.cxx:1510
 TSpectrum2Transform.cxx:1511
 TSpectrum2Transform.cxx:1512
 TSpectrum2Transform.cxx:1513
 TSpectrum2Transform.cxx:1514
 TSpectrum2Transform.cxx:1515
 TSpectrum2Transform.cxx:1516
 TSpectrum2Transform.cxx:1517
 TSpectrum2Transform.cxx:1518
 TSpectrum2Transform.cxx:1519
 TSpectrum2Transform.cxx:1520
 TSpectrum2Transform.cxx:1521
 TSpectrum2Transform.cxx:1522
 TSpectrum2Transform.cxx:1523
 TSpectrum2Transform.cxx:1524
 TSpectrum2Transform.cxx:1525
 TSpectrum2Transform.cxx:1526
 TSpectrum2Transform.cxx:1527
 TSpectrum2Transform.cxx:1528
 TSpectrum2Transform.cxx:1529
 TSpectrum2Transform.cxx:1530
 TSpectrum2Transform.cxx:1531
 TSpectrum2Transform.cxx:1532
 TSpectrum2Transform.cxx:1533
 TSpectrum2Transform.cxx:1534
 TSpectrum2Transform.cxx:1535
 TSpectrum2Transform.cxx:1536
 TSpectrum2Transform.cxx:1537
 TSpectrum2Transform.cxx:1538
 TSpectrum2Transform.cxx:1539
 TSpectrum2Transform.cxx:1540
 TSpectrum2Transform.cxx:1541
 TSpectrum2Transform.cxx:1542
 TSpectrum2Transform.cxx:1543
 TSpectrum2Transform.cxx:1544
 TSpectrum2Transform.cxx:1545
 TSpectrum2Transform.cxx:1546
 TSpectrum2Transform.cxx:1547
 TSpectrum2Transform.cxx:1548
 TSpectrum2Transform.cxx:1549
 TSpectrum2Transform.cxx:1550
 TSpectrum2Transform.cxx:1551
 TSpectrum2Transform.cxx:1552
 TSpectrum2Transform.cxx:1553
 TSpectrum2Transform.cxx:1554
 TSpectrum2Transform.cxx:1555
 TSpectrum2Transform.cxx:1556
 TSpectrum2Transform.cxx:1557
 TSpectrum2Transform.cxx:1558
 TSpectrum2Transform.cxx:1559
 TSpectrum2Transform.cxx:1560
 TSpectrum2Transform.cxx:1561
 TSpectrum2Transform.cxx:1562
 TSpectrum2Transform.cxx:1563
 TSpectrum2Transform.cxx:1564
 TSpectrum2Transform.cxx:1565
 TSpectrum2Transform.cxx:1566
 TSpectrum2Transform.cxx:1567
 TSpectrum2Transform.cxx:1568
 TSpectrum2Transform.cxx:1569
 TSpectrum2Transform.cxx:1570
 TSpectrum2Transform.cxx:1571
 TSpectrum2Transform.cxx:1572
 TSpectrum2Transform.cxx:1573
 TSpectrum2Transform.cxx:1574
 TSpectrum2Transform.cxx:1575
 TSpectrum2Transform.cxx:1576
 TSpectrum2Transform.cxx:1577
 TSpectrum2Transform.cxx:1578
 TSpectrum2Transform.cxx:1579
 TSpectrum2Transform.cxx:1580
 TSpectrum2Transform.cxx:1581
 TSpectrum2Transform.cxx:1582
 TSpectrum2Transform.cxx:1583
 TSpectrum2Transform.cxx:1584
 TSpectrum2Transform.cxx:1585
 TSpectrum2Transform.cxx:1586
 TSpectrum2Transform.cxx:1587
 TSpectrum2Transform.cxx:1588
 TSpectrum2Transform.cxx:1589
 TSpectrum2Transform.cxx:1590
 TSpectrum2Transform.cxx:1591
 TSpectrum2Transform.cxx:1592
 TSpectrum2Transform.cxx:1593
 TSpectrum2Transform.cxx:1594
 TSpectrum2Transform.cxx:1595
 TSpectrum2Transform.cxx:1596
 TSpectrum2Transform.cxx:1597
 TSpectrum2Transform.cxx:1598
 TSpectrum2Transform.cxx:1599
 TSpectrum2Transform.cxx:1600
 TSpectrum2Transform.cxx:1601
 TSpectrum2Transform.cxx:1602
 TSpectrum2Transform.cxx:1603
 TSpectrum2Transform.cxx:1604
 TSpectrum2Transform.cxx:1605
 TSpectrum2Transform.cxx:1606
 TSpectrum2Transform.cxx:1607
 TSpectrum2Transform.cxx:1608
 TSpectrum2Transform.cxx:1609
 TSpectrum2Transform.cxx:1610
 TSpectrum2Transform.cxx:1611
 TSpectrum2Transform.cxx:1612
 TSpectrum2Transform.cxx:1613
 TSpectrum2Transform.cxx:1614
 TSpectrum2Transform.cxx:1615
 TSpectrum2Transform.cxx:1616
 TSpectrum2Transform.cxx:1617
 TSpectrum2Transform.cxx:1618
 TSpectrum2Transform.cxx:1619
 TSpectrum2Transform.cxx:1620
 TSpectrum2Transform.cxx:1621
 TSpectrum2Transform.cxx:1622
 TSpectrum2Transform.cxx:1623
 TSpectrum2Transform.cxx:1624
 TSpectrum2Transform.cxx:1625
 TSpectrum2Transform.cxx:1626
 TSpectrum2Transform.cxx:1627
 TSpectrum2Transform.cxx:1628
 TSpectrum2Transform.cxx:1629
 TSpectrum2Transform.cxx:1630
 TSpectrum2Transform.cxx:1631
 TSpectrum2Transform.cxx:1632
 TSpectrum2Transform.cxx:1633
 TSpectrum2Transform.cxx:1634
 TSpectrum2Transform.cxx:1635
 TSpectrum2Transform.cxx:1636
 TSpectrum2Transform.cxx:1637
 TSpectrum2Transform.cxx:1638
 TSpectrum2Transform.cxx:1639
 TSpectrum2Transform.cxx:1640
 TSpectrum2Transform.cxx:1641
 TSpectrum2Transform.cxx:1642
 TSpectrum2Transform.cxx:1643
 TSpectrum2Transform.cxx:1644
 TSpectrum2Transform.cxx:1645
 TSpectrum2Transform.cxx:1646
 TSpectrum2Transform.cxx:1647
 TSpectrum2Transform.cxx:1648
 TSpectrum2Transform.cxx:1649
 TSpectrum2Transform.cxx:1650
 TSpectrum2Transform.cxx:1651
 TSpectrum2Transform.cxx:1652
 TSpectrum2Transform.cxx:1653
 TSpectrum2Transform.cxx:1654
 TSpectrum2Transform.cxx:1655
 TSpectrum2Transform.cxx:1656
 TSpectrum2Transform.cxx:1657
 TSpectrum2Transform.cxx:1658
 TSpectrum2Transform.cxx:1659
 TSpectrum2Transform.cxx:1660
 TSpectrum2Transform.cxx:1661
 TSpectrum2Transform.cxx:1662
 TSpectrum2Transform.cxx:1663
 TSpectrum2Transform.cxx:1664
 TSpectrum2Transform.cxx:1665
 TSpectrum2Transform.cxx:1666
 TSpectrum2Transform.cxx:1667
 TSpectrum2Transform.cxx:1668
 TSpectrum2Transform.cxx:1669
 TSpectrum2Transform.cxx:1670
 TSpectrum2Transform.cxx:1671
 TSpectrum2Transform.cxx:1672
 TSpectrum2Transform.cxx:1673
 TSpectrum2Transform.cxx:1674
 TSpectrum2Transform.cxx:1675
 TSpectrum2Transform.cxx:1676
 TSpectrum2Transform.cxx:1677
 TSpectrum2Transform.cxx:1678
 TSpectrum2Transform.cxx:1679
 TSpectrum2Transform.cxx:1680
 TSpectrum2Transform.cxx:1681
 TSpectrum2Transform.cxx:1682
 TSpectrum2Transform.cxx:1683
 TSpectrum2Transform.cxx:1684
 TSpectrum2Transform.cxx:1685
 TSpectrum2Transform.cxx:1686
 TSpectrum2Transform.cxx:1687
 TSpectrum2Transform.cxx:1688
 TSpectrum2Transform.cxx:1689
 TSpectrum2Transform.cxx:1690
 TSpectrum2Transform.cxx:1691
 TSpectrum2Transform.cxx:1692
 TSpectrum2Transform.cxx:1693
 TSpectrum2Transform.cxx:1694
 TSpectrum2Transform.cxx:1695
 TSpectrum2Transform.cxx:1696
 TSpectrum2Transform.cxx:1697
 TSpectrum2Transform.cxx:1698
 TSpectrum2Transform.cxx:1699
 TSpectrum2Transform.cxx:1700
 TSpectrum2Transform.cxx:1701
 TSpectrum2Transform.cxx:1702
 TSpectrum2Transform.cxx:1703
 TSpectrum2Transform.cxx:1704
 TSpectrum2Transform.cxx:1705
 TSpectrum2Transform.cxx:1706
 TSpectrum2Transform.cxx:1707
 TSpectrum2Transform.cxx:1708
 TSpectrum2Transform.cxx:1709
 TSpectrum2Transform.cxx:1710
 TSpectrum2Transform.cxx:1711
 TSpectrum2Transform.cxx:1712
 TSpectrum2Transform.cxx:1713
 TSpectrum2Transform.cxx:1714
 TSpectrum2Transform.cxx:1715
 TSpectrum2Transform.cxx:1716
 TSpectrum2Transform.cxx:1717
 TSpectrum2Transform.cxx:1718
 TSpectrum2Transform.cxx:1719
 TSpectrum2Transform.cxx:1720
 TSpectrum2Transform.cxx:1721
 TSpectrum2Transform.cxx:1722
 TSpectrum2Transform.cxx:1723
 TSpectrum2Transform.cxx:1724
 TSpectrum2Transform.cxx:1725
 TSpectrum2Transform.cxx:1726
 TSpectrum2Transform.cxx:1727
 TSpectrum2Transform.cxx:1728
 TSpectrum2Transform.cxx:1729
 TSpectrum2Transform.cxx:1730
 TSpectrum2Transform.cxx:1731
 TSpectrum2Transform.cxx:1732
 TSpectrum2Transform.cxx:1733
 TSpectrum2Transform.cxx:1734
 TSpectrum2Transform.cxx:1735
 TSpectrum2Transform.cxx:1736
 TSpectrum2Transform.cxx:1737
 TSpectrum2Transform.cxx:1738
 TSpectrum2Transform.cxx:1739
 TSpectrum2Transform.cxx:1740
 TSpectrum2Transform.cxx:1741
 TSpectrum2Transform.cxx:1742
 TSpectrum2Transform.cxx:1743
 TSpectrum2Transform.cxx:1744
 TSpectrum2Transform.cxx:1745
 TSpectrum2Transform.cxx:1746
 TSpectrum2Transform.cxx:1747
 TSpectrum2Transform.cxx:1748
 TSpectrum2Transform.cxx:1749
 TSpectrum2Transform.cxx:1750
 TSpectrum2Transform.cxx:1751
 TSpectrum2Transform.cxx:1752
 TSpectrum2Transform.cxx:1753
 TSpectrum2Transform.cxx:1754
 TSpectrum2Transform.cxx:1755
 TSpectrum2Transform.cxx:1756
 TSpectrum2Transform.cxx:1757
 TSpectrum2Transform.cxx:1758
 TSpectrum2Transform.cxx:1759
 TSpectrum2Transform.cxx:1760
 TSpectrum2Transform.cxx:1761
 TSpectrum2Transform.cxx:1762
 TSpectrum2Transform.cxx:1763
 TSpectrum2Transform.cxx:1764
 TSpectrum2Transform.cxx:1765
 TSpectrum2Transform.cxx:1766
 TSpectrum2Transform.cxx:1767
 TSpectrum2Transform.cxx:1768
 TSpectrum2Transform.cxx:1769
 TSpectrum2Transform.cxx:1770
 TSpectrum2Transform.cxx:1771
 TSpectrum2Transform.cxx:1772
 TSpectrum2Transform.cxx:1773
 TSpectrum2Transform.cxx:1774
 TSpectrum2Transform.cxx:1775
 TSpectrum2Transform.cxx:1776
 TSpectrum2Transform.cxx:1777
 TSpectrum2Transform.cxx:1778
 TSpectrum2Transform.cxx:1779
 TSpectrum2Transform.cxx:1780
 TSpectrum2Transform.cxx:1781
 TSpectrum2Transform.cxx:1782
 TSpectrum2Transform.cxx:1783
 TSpectrum2Transform.cxx:1784
 TSpectrum2Transform.cxx:1785
 TSpectrum2Transform.cxx:1786
 TSpectrum2Transform.cxx:1787
 TSpectrum2Transform.cxx:1788
 TSpectrum2Transform.cxx:1789
 TSpectrum2Transform.cxx:1790
 TSpectrum2Transform.cxx:1791
 TSpectrum2Transform.cxx:1792
 TSpectrum2Transform.cxx:1793
 TSpectrum2Transform.cxx:1794
 TSpectrum2Transform.cxx:1795
 TSpectrum2Transform.cxx:1796
 TSpectrum2Transform.cxx:1797
 TSpectrum2Transform.cxx:1798
 TSpectrum2Transform.cxx:1799
 TSpectrum2Transform.cxx:1800
 TSpectrum2Transform.cxx:1801
 TSpectrum2Transform.cxx:1802
 TSpectrum2Transform.cxx:1803
 TSpectrum2Transform.cxx:1804
 TSpectrum2Transform.cxx:1805
 TSpectrum2Transform.cxx:1806
 TSpectrum2Transform.cxx:1807
 TSpectrum2Transform.cxx:1808
 TSpectrum2Transform.cxx:1809
 TSpectrum2Transform.cxx:1810
 TSpectrum2Transform.cxx:1811
 TSpectrum2Transform.cxx:1812
 TSpectrum2Transform.cxx:1813
 TSpectrum2Transform.cxx:1814
 TSpectrum2Transform.cxx:1815
 TSpectrum2Transform.cxx:1816
 TSpectrum2Transform.cxx:1817
 TSpectrum2Transform.cxx:1818
 TSpectrum2Transform.cxx:1819
 TSpectrum2Transform.cxx:1820
 TSpectrum2Transform.cxx:1821
 TSpectrum2Transform.cxx:1822
 TSpectrum2Transform.cxx:1823
 TSpectrum2Transform.cxx:1824
 TSpectrum2Transform.cxx:1825
 TSpectrum2Transform.cxx:1826
 TSpectrum2Transform.cxx:1827
 TSpectrum2Transform.cxx:1828
 TSpectrum2Transform.cxx:1829
 TSpectrum2Transform.cxx:1830
 TSpectrum2Transform.cxx:1831
 TSpectrum2Transform.cxx:1832
 TSpectrum2Transform.cxx:1833
 TSpectrum2Transform.cxx:1834
 TSpectrum2Transform.cxx:1835
 TSpectrum2Transform.cxx:1836
 TSpectrum2Transform.cxx:1837
 TSpectrum2Transform.cxx:1838
 TSpectrum2Transform.cxx:1839
 TSpectrum2Transform.cxx:1840
 TSpectrum2Transform.cxx:1841
 TSpectrum2Transform.cxx:1842
 TSpectrum2Transform.cxx:1843
 TSpectrum2Transform.cxx:1844
 TSpectrum2Transform.cxx:1845
 TSpectrum2Transform.cxx:1846
 TSpectrum2Transform.cxx:1847
 TSpectrum2Transform.cxx:1848
 TSpectrum2Transform.cxx:1849
 TSpectrum2Transform.cxx:1850
 TSpectrum2Transform.cxx:1851
 TSpectrum2Transform.cxx:1852
 TSpectrum2Transform.cxx:1853
 TSpectrum2Transform.cxx:1854
 TSpectrum2Transform.cxx:1855
 TSpectrum2Transform.cxx:1856
 TSpectrum2Transform.cxx:1857
 TSpectrum2Transform.cxx:1858
 TSpectrum2Transform.cxx:1859
 TSpectrum2Transform.cxx:1860
 TSpectrum2Transform.cxx:1861
 TSpectrum2Transform.cxx:1862
 TSpectrum2Transform.cxx:1863
 TSpectrum2Transform.cxx:1864
 TSpectrum2Transform.cxx:1865
 TSpectrum2Transform.cxx:1866
 TSpectrum2Transform.cxx:1867
 TSpectrum2Transform.cxx:1868
 TSpectrum2Transform.cxx:1869
 TSpectrum2Transform.cxx:1870
 TSpectrum2Transform.cxx:1871
 TSpectrum2Transform.cxx:1872
 TSpectrum2Transform.cxx:1873
 TSpectrum2Transform.cxx:1874
 TSpectrum2Transform.cxx:1875
 TSpectrum2Transform.cxx:1876
 TSpectrum2Transform.cxx:1877
 TSpectrum2Transform.cxx:1878
 TSpectrum2Transform.cxx:1879
 TSpectrum2Transform.cxx:1880
 TSpectrum2Transform.cxx:1881
 TSpectrum2Transform.cxx:1882
 TSpectrum2Transform.cxx:1883
 TSpectrum2Transform.cxx:1884
 TSpectrum2Transform.cxx:1885
 TSpectrum2Transform.cxx:1886
 TSpectrum2Transform.cxx:1887
 TSpectrum2Transform.cxx:1888
 TSpectrum2Transform.cxx:1889
 TSpectrum2Transform.cxx:1890
 TSpectrum2Transform.cxx:1891
 TSpectrum2Transform.cxx:1892
 TSpectrum2Transform.cxx:1893
 TSpectrum2Transform.cxx:1894
 TSpectrum2Transform.cxx:1895
 TSpectrum2Transform.cxx:1896
 TSpectrum2Transform.cxx:1897
 TSpectrum2Transform.cxx:1898
 TSpectrum2Transform.cxx:1899
 TSpectrum2Transform.cxx:1900
 TSpectrum2Transform.cxx:1901
 TSpectrum2Transform.cxx:1902
 TSpectrum2Transform.cxx:1903
 TSpectrum2Transform.cxx:1904
 TSpectrum2Transform.cxx:1905
 TSpectrum2Transform.cxx:1906
 TSpectrum2Transform.cxx:1907
 TSpectrum2Transform.cxx:1908
 TSpectrum2Transform.cxx:1909
 TSpectrum2Transform.cxx:1910
 TSpectrum2Transform.cxx:1911
 TSpectrum2Transform.cxx:1912
 TSpectrum2Transform.cxx:1913
 TSpectrum2Transform.cxx:1914
 TSpectrum2Transform.cxx:1915
 TSpectrum2Transform.cxx:1916
 TSpectrum2Transform.cxx:1917
 TSpectrum2Transform.cxx:1918
 TSpectrum2Transform.cxx:1919
 TSpectrum2Transform.cxx:1920
 TSpectrum2Transform.cxx:1921
 TSpectrum2Transform.cxx:1922
 TSpectrum2Transform.cxx:1923
 TSpectrum2Transform.cxx:1924
 TSpectrum2Transform.cxx:1925
 TSpectrum2Transform.cxx:1926
 TSpectrum2Transform.cxx:1927
 TSpectrum2Transform.cxx:1928
 TSpectrum2Transform.cxx:1929
 TSpectrum2Transform.cxx:1930
 TSpectrum2Transform.cxx:1931
 TSpectrum2Transform.cxx:1932
 TSpectrum2Transform.cxx:1933
 TSpectrum2Transform.cxx:1934
 TSpectrum2Transform.cxx:1935
 TSpectrum2Transform.cxx:1936
 TSpectrum2Transform.cxx:1937
 TSpectrum2Transform.cxx:1938
 TSpectrum2Transform.cxx:1939
 TSpectrum2Transform.cxx:1940
 TSpectrum2Transform.cxx:1941
 TSpectrum2Transform.cxx:1942
 TSpectrum2Transform.cxx:1943
 TSpectrum2Transform.cxx:1944
 TSpectrum2Transform.cxx:1945
 TSpectrum2Transform.cxx:1946
 TSpectrum2Transform.cxx:1947
 TSpectrum2Transform.cxx:1948
 TSpectrum2Transform.cxx:1949
 TSpectrum2Transform.cxx:1950
 TSpectrum2Transform.cxx:1951
 TSpectrum2Transform.cxx:1952
 TSpectrum2Transform.cxx:1953
 TSpectrum2Transform.cxx:1954
 TSpectrum2Transform.cxx:1955
 TSpectrum2Transform.cxx:1956
 TSpectrum2Transform.cxx:1957
 TSpectrum2Transform.cxx:1958
 TSpectrum2Transform.cxx:1959
 TSpectrum2Transform.cxx:1960
 TSpectrum2Transform.cxx:1961
 TSpectrum2Transform.cxx:1962
 TSpectrum2Transform.cxx:1963
 TSpectrum2Transform.cxx:1964
 TSpectrum2Transform.cxx:1965
 TSpectrum2Transform.cxx:1966
 TSpectrum2Transform.cxx:1967
 TSpectrum2Transform.cxx:1968
 TSpectrum2Transform.cxx:1969
 TSpectrum2Transform.cxx:1970
 TSpectrum2Transform.cxx:1971
 TSpectrum2Transform.cxx:1972
 TSpectrum2Transform.cxx:1973
 TSpectrum2Transform.cxx:1974
 TSpectrum2Transform.cxx:1975
 TSpectrum2Transform.cxx:1976
 TSpectrum2Transform.cxx:1977
 TSpectrum2Transform.cxx:1978
 TSpectrum2Transform.cxx:1979
 TSpectrum2Transform.cxx:1980
 TSpectrum2Transform.cxx:1981
 TSpectrum2Transform.cxx:1982
 TSpectrum2Transform.cxx:1983
 TSpectrum2Transform.cxx:1984
 TSpectrum2Transform.cxx:1985
 TSpectrum2Transform.cxx:1986
 TSpectrum2Transform.cxx:1987
 TSpectrum2Transform.cxx:1988
 TSpectrum2Transform.cxx:1989
 TSpectrum2Transform.cxx:1990
 TSpectrum2Transform.cxx:1991
 TSpectrum2Transform.cxx:1992
 TSpectrum2Transform.cxx:1993
 TSpectrum2Transform.cxx:1994
 TSpectrum2Transform.cxx:1995
 TSpectrum2Transform.cxx:1996
 TSpectrum2Transform.cxx:1997
 TSpectrum2Transform.cxx:1998
 TSpectrum2Transform.cxx:1999
 TSpectrum2Transform.cxx:2000
 TSpectrum2Transform.cxx:2001
 TSpectrum2Transform.cxx:2002
 TSpectrum2Transform.cxx:2003
 TSpectrum2Transform.cxx:2004
 TSpectrum2Transform.cxx:2005
 TSpectrum2Transform.cxx:2006
 TSpectrum2Transform.cxx:2007
 TSpectrum2Transform.cxx:2008
 TSpectrum2Transform.cxx:2009
 TSpectrum2Transform.cxx:2010
 TSpectrum2Transform.cxx:2011
 TSpectrum2Transform.cxx:2012
 TSpectrum2Transform.cxx:2013
 TSpectrum2Transform.cxx:2014
 TSpectrum2Transform.cxx:2015
 TSpectrum2Transform.cxx:2016
 TSpectrum2Transform.cxx:2017
 TSpectrum2Transform.cxx:2018
 TSpectrum2Transform.cxx:2019
 TSpectrum2Transform.cxx:2020
 TSpectrum2Transform.cxx:2021
 TSpectrum2Transform.cxx:2022
 TSpectrum2Transform.cxx:2023
 TSpectrum2Transform.cxx:2024
 TSpectrum2Transform.cxx:2025
 TSpectrum2Transform.cxx:2026
 TSpectrum2Transform.cxx:2027
 TSpectrum2Transform.cxx:2028
 TSpectrum2Transform.cxx:2029
 TSpectrum2Transform.cxx:2030
 TSpectrum2Transform.cxx:2031
 TSpectrum2Transform.cxx:2032
 TSpectrum2Transform.cxx:2033
 TSpectrum2Transform.cxx:2034
 TSpectrum2Transform.cxx:2035
 TSpectrum2Transform.cxx:2036
 TSpectrum2Transform.cxx:2037
 TSpectrum2Transform.cxx:2038
 TSpectrum2Transform.cxx:2039
 TSpectrum2Transform.cxx:2040
 TSpectrum2Transform.cxx:2041
 TSpectrum2Transform.cxx:2042
 TSpectrum2Transform.cxx:2043
 TSpectrum2Transform.cxx:2044
 TSpectrum2Transform.cxx:2045
 TSpectrum2Transform.cxx:2046
 TSpectrum2Transform.cxx:2047
 TSpectrum2Transform.cxx:2048
 TSpectrum2Transform.cxx:2049
 TSpectrum2Transform.cxx:2050
 TSpectrum2Transform.cxx:2051
 TSpectrum2Transform.cxx:2052
 TSpectrum2Transform.cxx:2053
 TSpectrum2Transform.cxx:2054
 TSpectrum2Transform.cxx:2055
 TSpectrum2Transform.cxx:2056
 TSpectrum2Transform.cxx:2057
 TSpectrum2Transform.cxx:2058
 TSpectrum2Transform.cxx:2059
 TSpectrum2Transform.cxx:2060
 TSpectrum2Transform.cxx:2061
 TSpectrum2Transform.cxx:2062
 TSpectrum2Transform.cxx:2063
 TSpectrum2Transform.cxx:2064
 TSpectrum2Transform.cxx:2065
 TSpectrum2Transform.cxx:2066
 TSpectrum2Transform.cxx:2067
 TSpectrum2Transform.cxx:2068
 TSpectrum2Transform.cxx:2069
 TSpectrum2Transform.cxx:2070
 TSpectrum2Transform.cxx:2071
 TSpectrum2Transform.cxx:2072
 TSpectrum2Transform.cxx:2073
 TSpectrum2Transform.cxx:2074
 TSpectrum2Transform.cxx:2075
 TSpectrum2Transform.cxx:2076
 TSpectrum2Transform.cxx:2077
 TSpectrum2Transform.cxx:2078
 TSpectrum2Transform.cxx:2079
 TSpectrum2Transform.cxx:2080
 TSpectrum2Transform.cxx:2081
 TSpectrum2Transform.cxx:2082
 TSpectrum2Transform.cxx:2083
 TSpectrum2Transform.cxx:2084
 TSpectrum2Transform.cxx:2085
 TSpectrum2Transform.cxx:2086
 TSpectrum2Transform.cxx:2087
 TSpectrum2Transform.cxx:2088
 TSpectrum2Transform.cxx:2089
 TSpectrum2Transform.cxx:2090
 TSpectrum2Transform.cxx:2091
 TSpectrum2Transform.cxx:2092
 TSpectrum2Transform.cxx:2093
 TSpectrum2Transform.cxx:2094
 TSpectrum2Transform.cxx:2095
 TSpectrum2Transform.cxx:2096
 TSpectrum2Transform.cxx:2097
 TSpectrum2Transform.cxx:2098
 TSpectrum2Transform.cxx:2099
 TSpectrum2Transform.cxx:2100
 TSpectrum2Transform.cxx:2101
 TSpectrum2Transform.cxx:2102
 TSpectrum2Transform.cxx:2103
 TSpectrum2Transform.cxx:2104
 TSpectrum2Transform.cxx:2105
 TSpectrum2Transform.cxx:2106
 TSpectrum2Transform.cxx:2107
 TSpectrum2Transform.cxx:2108
 TSpectrum2Transform.cxx:2109
 TSpectrum2Transform.cxx:2110
 TSpectrum2Transform.cxx:2111
 TSpectrum2Transform.cxx:2112
 TSpectrum2Transform.cxx:2113
 TSpectrum2Transform.cxx:2114
 TSpectrum2Transform.cxx:2115
 TSpectrum2Transform.cxx:2116
 TSpectrum2Transform.cxx:2117
 TSpectrum2Transform.cxx:2118
 TSpectrum2Transform.cxx:2119
 TSpectrum2Transform.cxx:2120
 TSpectrum2Transform.cxx:2121
 TSpectrum2Transform.cxx:2122
 TSpectrum2Transform.cxx:2123
 TSpectrum2Transform.cxx:2124
 TSpectrum2Transform.cxx:2125
 TSpectrum2Transform.cxx:2126
 TSpectrum2Transform.cxx:2127
 TSpectrum2Transform.cxx:2128
 TSpectrum2Transform.cxx:2129
 TSpectrum2Transform.cxx:2130
 TSpectrum2Transform.cxx:2131
 TSpectrum2Transform.cxx:2132
 TSpectrum2Transform.cxx:2133
 TSpectrum2Transform.cxx:2134
 TSpectrum2Transform.cxx:2135
 TSpectrum2Transform.cxx:2136
 TSpectrum2Transform.cxx:2137
 TSpectrum2Transform.cxx:2138
 TSpectrum2Transform.cxx:2139
 TSpectrum2Transform.cxx:2140
 TSpectrum2Transform.cxx:2141
 TSpectrum2Transform.cxx:2142
 TSpectrum2Transform.cxx:2143
 TSpectrum2Transform.cxx:2144
 TSpectrum2Transform.cxx:2145
 TSpectrum2Transform.cxx:2146
 TSpectrum2Transform.cxx:2147
 TSpectrum2Transform.cxx:2148
 TSpectrum2Transform.cxx:2149
 TSpectrum2Transform.cxx:2150
 TSpectrum2Transform.cxx:2151
 TSpectrum2Transform.cxx:2152
 TSpectrum2Transform.cxx:2153
 TSpectrum2Transform.cxx:2154
 TSpectrum2Transform.cxx:2155
 TSpectrum2Transform.cxx:2156
 TSpectrum2Transform.cxx:2157
 TSpectrum2Transform.cxx:2158
 TSpectrum2Transform.cxx:2159
 TSpectrum2Transform.cxx:2160
 TSpectrum2Transform.cxx:2161
 TSpectrum2Transform.cxx:2162
 TSpectrum2Transform.cxx:2163
 TSpectrum2Transform.cxx:2164
 TSpectrum2Transform.cxx:2165
 TSpectrum2Transform.cxx:2166
 TSpectrum2Transform.cxx:2167
 TSpectrum2Transform.cxx:2168
 TSpectrum2Transform.cxx:2169
 TSpectrum2Transform.cxx:2170
 TSpectrum2Transform.cxx:2171
 TSpectrum2Transform.cxx:2172
 TSpectrum2Transform.cxx:2173
 TSpectrum2Transform.cxx:2174
 TSpectrum2Transform.cxx:2175
 TSpectrum2Transform.cxx:2176
 TSpectrum2Transform.cxx:2177
 TSpectrum2Transform.cxx:2178
 TSpectrum2Transform.cxx:2179
 TSpectrum2Transform.cxx:2180
 TSpectrum2Transform.cxx:2181
 TSpectrum2Transform.cxx:2182
 TSpectrum2Transform.cxx:2183
 TSpectrum2Transform.cxx:2184
 TSpectrum2Transform.cxx:2185
 TSpectrum2Transform.cxx:2186
 TSpectrum2Transform.cxx:2187
 TSpectrum2Transform.cxx:2188
 TSpectrum2Transform.cxx:2189
 TSpectrum2Transform.cxx:2190
 TSpectrum2Transform.cxx:2191
 TSpectrum2Transform.cxx:2192
 TSpectrum2Transform.cxx:2193
 TSpectrum2Transform.cxx:2194
 TSpectrum2Transform.cxx:2195
 TSpectrum2Transform.cxx:2196
 TSpectrum2Transform.cxx:2197
 TSpectrum2Transform.cxx:2198
 TSpectrum2Transform.cxx:2199
 TSpectrum2Transform.cxx:2200
 TSpectrum2Transform.cxx:2201
 TSpectrum2Transform.cxx:2202
 TSpectrum2Transform.cxx:2203
 TSpectrum2Transform.cxx:2204
 TSpectrum2Transform.cxx:2205
 TSpectrum2Transform.cxx:2206
 TSpectrum2Transform.cxx:2207
 TSpectrum2Transform.cxx:2208
 TSpectrum2Transform.cxx:2209
 TSpectrum2Transform.cxx:2210
 TSpectrum2Transform.cxx:2211
 TSpectrum2Transform.cxx:2212
 TSpectrum2Transform.cxx:2213
 TSpectrum2Transform.cxx:2214
 TSpectrum2Transform.cxx:2215
 TSpectrum2Transform.cxx:2216
 TSpectrum2Transform.cxx:2217
 TSpectrum2Transform.cxx:2218
 TSpectrum2Transform.cxx:2219
 TSpectrum2Transform.cxx:2220
 TSpectrum2Transform.cxx:2221
 TSpectrum2Transform.cxx:2222
 TSpectrum2Transform.cxx:2223
 TSpectrum2Transform.cxx:2224
 TSpectrum2Transform.cxx:2225
 TSpectrum2Transform.cxx:2226
 TSpectrum2Transform.cxx:2227
 TSpectrum2Transform.cxx:2228
 TSpectrum2Transform.cxx:2229
 TSpectrum2Transform.cxx:2230
 TSpectrum2Transform.cxx:2231
 TSpectrum2Transform.cxx:2232
 TSpectrum2Transform.cxx:2233
 TSpectrum2Transform.cxx:2234
 TSpectrum2Transform.cxx:2235
 TSpectrum2Transform.cxx:2236
 TSpectrum2Transform.cxx:2237
 TSpectrum2Transform.cxx:2238
 TSpectrum2Transform.cxx:2239
 TSpectrum2Transform.cxx:2240
 TSpectrum2Transform.cxx:2241
 TSpectrum2Transform.cxx:2242
 TSpectrum2Transform.cxx:2243
 TSpectrum2Transform.cxx:2244
 TSpectrum2Transform.cxx:2245
 TSpectrum2Transform.cxx:2246
 TSpectrum2Transform.cxx:2247
 TSpectrum2Transform.cxx:2248
 TSpectrum2Transform.cxx:2249
 TSpectrum2Transform.cxx:2250
 TSpectrum2Transform.cxx:2251
 TSpectrum2Transform.cxx:2252
 TSpectrum2Transform.cxx:2253
 TSpectrum2Transform.cxx:2254
 TSpectrum2Transform.cxx:2255
 TSpectrum2Transform.cxx:2256
 TSpectrum2Transform.cxx:2257
 TSpectrum2Transform.cxx:2258
 TSpectrum2Transform.cxx:2259
 TSpectrum2Transform.cxx:2260
 TSpectrum2Transform.cxx:2261
 TSpectrum2Transform.cxx:2262
 TSpectrum2Transform.cxx:2263
 TSpectrum2Transform.cxx:2264
 TSpectrum2Transform.cxx:2265
 TSpectrum2Transform.cxx:2266
 TSpectrum2Transform.cxx:2267
 TSpectrum2Transform.cxx:2268
 TSpectrum2Transform.cxx:2269
 TSpectrum2Transform.cxx:2270
 TSpectrum2Transform.cxx:2271
 TSpectrum2Transform.cxx:2272
 TSpectrum2Transform.cxx:2273
 TSpectrum2Transform.cxx:2274
 TSpectrum2Transform.cxx:2275
 TSpectrum2Transform.cxx:2276
 TSpectrum2Transform.cxx:2277
 TSpectrum2Transform.cxx:2278
 TSpectrum2Transform.cxx:2279
 TSpectrum2Transform.cxx:2280
 TSpectrum2Transform.cxx:2281
 TSpectrum2Transform.cxx:2282
 TSpectrum2Transform.cxx:2283
 TSpectrum2Transform.cxx:2284
 TSpectrum2Transform.cxx:2285
 TSpectrum2Transform.cxx:2286
 TSpectrum2Transform.cxx:2287
 TSpectrum2Transform.cxx:2288
 TSpectrum2Transform.cxx:2289
 TSpectrum2Transform.cxx:2290
 TSpectrum2Transform.cxx:2291
 TSpectrum2Transform.cxx:2292
 TSpectrum2Transform.cxx:2293
 TSpectrum2Transform.cxx:2294
 TSpectrum2Transform.cxx:2295
 TSpectrum2Transform.cxx:2296
 TSpectrum2Transform.cxx:2297
 TSpectrum2Transform.cxx:2298
 TSpectrum2Transform.cxx:2299
 TSpectrum2Transform.cxx:2300
 TSpectrum2Transform.cxx:2301
 TSpectrum2Transform.cxx:2302
 TSpectrum2Transform.cxx:2303
 TSpectrum2Transform.cxx:2304
 TSpectrum2Transform.cxx:2305
 TSpectrum2Transform.cxx:2306
 TSpectrum2Transform.cxx:2307
 TSpectrum2Transform.cxx:2308
 TSpectrum2Transform.cxx:2309
 TSpectrum2Transform.cxx:2310
 TSpectrum2Transform.cxx:2311
 TSpectrum2Transform.cxx:2312
 TSpectrum2Transform.cxx:2313
 TSpectrum2Transform.cxx:2314
 TSpectrum2Transform.cxx:2315
 TSpectrum2Transform.cxx:2316
 TSpectrum2Transform.cxx:2317
 TSpectrum2Transform.cxx:2318
 TSpectrum2Transform.cxx:2319
 TSpectrum2Transform.cxx:2320
 TSpectrum2Transform.cxx:2321
 TSpectrum2Transform.cxx:2322
 TSpectrum2Transform.cxx:2323
 TSpectrum2Transform.cxx:2324
 TSpectrum2Transform.cxx:2325
 TSpectrum2Transform.cxx:2326
 TSpectrum2Transform.cxx:2327
 TSpectrum2Transform.cxx:2328
 TSpectrum2Transform.cxx:2329
 TSpectrum2Transform.cxx:2330
 TSpectrum2Transform.cxx:2331
 TSpectrum2Transform.cxx:2332
 TSpectrum2Transform.cxx:2333
 TSpectrum2Transform.cxx:2334
 TSpectrum2Transform.cxx:2335
 TSpectrum2Transform.cxx:2336
 TSpectrum2Transform.cxx:2337
 TSpectrum2Transform.cxx:2338
 TSpectrum2Transform.cxx:2339
 TSpectrum2Transform.cxx:2340
 TSpectrum2Transform.cxx:2341
 TSpectrum2Transform.cxx:2342
 TSpectrum2Transform.cxx:2343
 TSpectrum2Transform.cxx:2344
 TSpectrum2Transform.cxx:2345
 TSpectrum2Transform.cxx:2346
 TSpectrum2Transform.cxx:2347
 TSpectrum2Transform.cxx:2348
 TSpectrum2Transform.cxx:2349
 TSpectrum2Transform.cxx:2350
 TSpectrum2Transform.cxx:2351
 TSpectrum2Transform.cxx:2352
 TSpectrum2Transform.cxx:2353
 TSpectrum2Transform.cxx:2354
 TSpectrum2Transform.cxx:2355
 TSpectrum2Transform.cxx:2356
 TSpectrum2Transform.cxx:2357
 TSpectrum2Transform.cxx:2358
 TSpectrum2Transform.cxx:2359
 TSpectrum2Transform.cxx:2360
 TSpectrum2Transform.cxx:2361
 TSpectrum2Transform.cxx:2362
 TSpectrum2Transform.cxx:2363
 TSpectrum2Transform.cxx:2364
 TSpectrum2Transform.cxx:2365
 TSpectrum2Transform.cxx:2366
 TSpectrum2Transform.cxx:2367
 TSpectrum2Transform.cxx:2368
 TSpectrum2Transform.cxx:2369
 TSpectrum2Transform.cxx:2370
 TSpectrum2Transform.cxx:2371
 TSpectrum2Transform.cxx:2372
 TSpectrum2Transform.cxx:2373
 TSpectrum2Transform.cxx:2374
 TSpectrum2Transform.cxx:2375
 TSpectrum2Transform.cxx:2376
 TSpectrum2Transform.cxx:2377
 TSpectrum2Transform.cxx:2378
 TSpectrum2Transform.cxx:2379
 TSpectrum2Transform.cxx:2380
 TSpectrum2Transform.cxx:2381
 TSpectrum2Transform.cxx:2382
 TSpectrum2Transform.cxx:2383
 TSpectrum2Transform.cxx:2384
 TSpectrum2Transform.cxx:2385
 TSpectrum2Transform.cxx:2386
 TSpectrum2Transform.cxx:2387
 TSpectrum2Transform.cxx:2388
 TSpectrum2Transform.cxx:2389
 TSpectrum2Transform.cxx:2390
 TSpectrum2Transform.cxx:2391
 TSpectrum2Transform.cxx:2392
 TSpectrum2Transform.cxx:2393
 TSpectrum2Transform.cxx:2394
 TSpectrum2Transform.cxx:2395
 TSpectrum2Transform.cxx:2396
 TSpectrum2Transform.cxx:2397
 TSpectrum2Transform.cxx:2398
 TSpectrum2Transform.cxx:2399
 TSpectrum2Transform.cxx:2400
 TSpectrum2Transform.cxx:2401
 TSpectrum2Transform.cxx:2402
 TSpectrum2Transform.cxx:2403
 TSpectrum2Transform.cxx:2404
 TSpectrum2Transform.cxx:2405
 TSpectrum2Transform.cxx:2406
 TSpectrum2Transform.cxx:2407
 TSpectrum2Transform.cxx:2408
 TSpectrum2Transform.cxx:2409
 TSpectrum2Transform.cxx:2410
 TSpectrum2Transform.cxx:2411
 TSpectrum2Transform.cxx:2412
 TSpectrum2Transform.cxx:2413
 TSpectrum2Transform.cxx:2414
 TSpectrum2Transform.cxx:2415
 TSpectrum2Transform.cxx:2416
 TSpectrum2Transform.cxx:2417
 TSpectrum2Transform.cxx:2418
 TSpectrum2Transform.cxx:2419
 TSpectrum2Transform.cxx:2420
 TSpectrum2Transform.cxx:2421
 TSpectrum2Transform.cxx:2422
 TSpectrum2Transform.cxx:2423
 TSpectrum2Transform.cxx:2424
 TSpectrum2Transform.cxx:2425
 TSpectrum2Transform.cxx:2426
 TSpectrum2Transform.cxx:2427
 TSpectrum2Transform.cxx:2428
 TSpectrum2Transform.cxx:2429
 TSpectrum2Transform.cxx:2430
 TSpectrum2Transform.cxx:2431
 TSpectrum2Transform.cxx:2432
 TSpectrum2Transform.cxx:2433
 TSpectrum2Transform.cxx:2434
 TSpectrum2Transform.cxx:2435
 TSpectrum2Transform.cxx:2436
 TSpectrum2Transform.cxx:2437
 TSpectrum2Transform.cxx:2438
 TSpectrum2Transform.cxx:2439
 TSpectrum2Transform.cxx:2440
 TSpectrum2Transform.cxx:2441
 TSpectrum2Transform.cxx:2442
 TSpectrum2Transform.cxx:2443
 TSpectrum2Transform.cxx:2444
 TSpectrum2Transform.cxx:2445
 TSpectrum2Transform.cxx:2446
 TSpectrum2Transform.cxx:2447
 TSpectrum2Transform.cxx:2448
 TSpectrum2Transform.cxx:2449
 TSpectrum2Transform.cxx:2450
 TSpectrum2Transform.cxx:2451
 TSpectrum2Transform.cxx:2452
 TSpectrum2Transform.cxx:2453
 TSpectrum2Transform.cxx:2454
 TSpectrum2Transform.cxx:2455
 TSpectrum2Transform.cxx:2456
 TSpectrum2Transform.cxx:2457
 TSpectrum2Transform.cxx:2458
 TSpectrum2Transform.cxx:2459
 TSpectrum2Transform.cxx:2460
 TSpectrum2Transform.cxx:2461
 TSpectrum2Transform.cxx:2462
 TSpectrum2Transform.cxx:2463
 TSpectrum2Transform.cxx:2464
 TSpectrum2Transform.cxx:2465
 TSpectrum2Transform.cxx:2466
 TSpectrum2Transform.cxx:2467
 TSpectrum2Transform.cxx:2468
 TSpectrum2Transform.cxx:2469
 TSpectrum2Transform.cxx:2470
 TSpectrum2Transform.cxx:2471
 TSpectrum2Transform.cxx:2472
 TSpectrum2Transform.cxx:2473
 TSpectrum2Transform.cxx:2474
 TSpectrum2Transform.cxx:2475
 TSpectrum2Transform.cxx:2476
 TSpectrum2Transform.cxx:2477
 TSpectrum2Transform.cxx:2478
 TSpectrum2Transform.cxx:2479
 TSpectrum2Transform.cxx:2480
 TSpectrum2Transform.cxx:2481
 TSpectrum2Transform.cxx:2482
 TSpectrum2Transform.cxx:2483
 TSpectrum2Transform.cxx:2484
 TSpectrum2Transform.cxx:2485
 TSpectrum2Transform.cxx:2486
 TSpectrum2Transform.cxx:2487
 TSpectrum2Transform.cxx:2488
 TSpectrum2Transform.cxx:2489
 TSpectrum2Transform.cxx:2490
 TSpectrum2Transform.cxx:2491
 TSpectrum2Transform.cxx:2492
 TSpectrum2Transform.cxx:2493
 TSpectrum2Transform.cxx:2494
 TSpectrum2Transform.cxx:2495
 TSpectrum2Transform.cxx:2496
 TSpectrum2Transform.cxx:2497
 TSpectrum2Transform.cxx:2498
 TSpectrum2Transform.cxx:2499
 TSpectrum2Transform.cxx:2500
 TSpectrum2Transform.cxx:2501
 TSpectrum2Transform.cxx:2502
 TSpectrum2Transform.cxx:2503
 TSpectrum2Transform.cxx:2504
 TSpectrum2Transform.cxx:2505
 TSpectrum2Transform.cxx:2506
 TSpectrum2Transform.cxx:2507
 TSpectrum2Transform.cxx:2508
 TSpectrum2Transform.cxx:2509
 TSpectrum2Transform.cxx:2510
 TSpectrum2Transform.cxx:2511
 TSpectrum2Transform.cxx:2512
 TSpectrum2Transform.cxx:2513
 TSpectrum2Transform.cxx:2514
 TSpectrum2Transform.cxx:2515
 TSpectrum2Transform.cxx:2516
 TSpectrum2Transform.cxx:2517
 TSpectrum2Transform.cxx:2518
 TSpectrum2Transform.cxx:2519
 TSpectrum2Transform.cxx:2520
 TSpectrum2Transform.cxx:2521
 TSpectrum2Transform.cxx:2522
 TSpectrum2Transform.cxx:2523
 TSpectrum2Transform.cxx:2524
 TSpectrum2Transform.cxx:2525
 TSpectrum2Transform.cxx:2526
 TSpectrum2Transform.cxx:2527
 TSpectrum2Transform.cxx:2528
 TSpectrum2Transform.cxx:2529
 TSpectrum2Transform.cxx:2530
 TSpectrum2Transform.cxx:2531
 TSpectrum2Transform.cxx:2532
 TSpectrum2Transform.cxx:2533
 TSpectrum2Transform.cxx:2534
 TSpectrum2Transform.cxx:2535
 TSpectrum2Transform.cxx:2536
 TSpectrum2Transform.cxx:2537
 TSpectrum2Transform.cxx:2538
 TSpectrum2Transform.cxx:2539
 TSpectrum2Transform.cxx:2540
 TSpectrum2Transform.cxx:2541
 TSpectrum2Transform.cxx:2542
 TSpectrum2Transform.cxx:2543
 TSpectrum2Transform.cxx:2544
 TSpectrum2Transform.cxx:2545
 TSpectrum2Transform.cxx:2546
 TSpectrum2Transform.cxx:2547
 TSpectrum2Transform.cxx:2548
 TSpectrum2Transform.cxx:2549
 TSpectrum2Transform.cxx:2550
 TSpectrum2Transform.cxx:2551
 TSpectrum2Transform.cxx:2552
 TSpectrum2Transform.cxx:2553
 TSpectrum2Transform.cxx:2554
 TSpectrum2Transform.cxx:2555
 TSpectrum2Transform.cxx:2556
 TSpectrum2Transform.cxx:2557
 TSpectrum2Transform.cxx:2558
 TSpectrum2Transform.cxx:2559
 TSpectrum2Transform.cxx:2560
 TSpectrum2Transform.cxx:2561
 TSpectrum2Transform.cxx:2562
 TSpectrum2Transform.cxx:2563
 TSpectrum2Transform.cxx:2564
 TSpectrum2Transform.cxx:2565
 TSpectrum2Transform.cxx:2566
 TSpectrum2Transform.cxx:2567
 TSpectrum2Transform.cxx:2568
 TSpectrum2Transform.cxx:2569
 TSpectrum2Transform.cxx:2570
 TSpectrum2Transform.cxx:2571
 TSpectrum2Transform.cxx:2572
 TSpectrum2Transform.cxx:2573
 TSpectrum2Transform.cxx:2574
 TSpectrum2Transform.cxx:2575
 TSpectrum2Transform.cxx:2576
 TSpectrum2Transform.cxx:2577
 TSpectrum2Transform.cxx:2578
 TSpectrum2Transform.cxx:2579
 TSpectrum2Transform.cxx:2580
 TSpectrum2Transform.cxx:2581
 TSpectrum2Transform.cxx:2582
 TSpectrum2Transform.cxx:2583
 TSpectrum2Transform.cxx:2584
 TSpectrum2Transform.cxx:2585
 TSpectrum2Transform.cxx:2586
 TSpectrum2Transform.cxx:2587
 TSpectrum2Transform.cxx:2588
 TSpectrum2Transform.cxx:2589
 TSpectrum2Transform.cxx:2590
 TSpectrum2Transform.cxx:2591
 TSpectrum2Transform.cxx:2592
 TSpectrum2Transform.cxx:2593
 TSpectrum2Transform.cxx:2594
 TSpectrum2Transform.cxx:2595
 TSpectrum2Transform.cxx:2596
 TSpectrum2Transform.cxx:2597
 TSpectrum2Transform.cxx:2598
 TSpectrum2Transform.cxx:2599
 TSpectrum2Transform.cxx:2600
 TSpectrum2Transform.cxx:2601
 TSpectrum2Transform.cxx:2602
 TSpectrum2Transform.cxx:2603
 TSpectrum2Transform.cxx:2604
 TSpectrum2Transform.cxx:2605
 TSpectrum2Transform.cxx:2606
 TSpectrum2Transform.cxx:2607
 TSpectrum2Transform.cxx:2608
 TSpectrum2Transform.cxx:2609
 TSpectrum2Transform.cxx:2610
 TSpectrum2Transform.cxx:2611
 TSpectrum2Transform.cxx:2612
 TSpectrum2Transform.cxx:2613
 TSpectrum2Transform.cxx:2614
 TSpectrum2Transform.cxx:2615
 TSpectrum2Transform.cxx:2616
 TSpectrum2Transform.cxx:2617
 TSpectrum2Transform.cxx:2618
 TSpectrum2Transform.cxx:2619
 TSpectrum2Transform.cxx:2620
 TSpectrum2Transform.cxx:2621
 TSpectrum2Transform.cxx:2622
 TSpectrum2Transform.cxx:2623
 TSpectrum2Transform.cxx:2624
 TSpectrum2Transform.cxx:2625
 TSpectrum2Transform.cxx:2626
 TSpectrum2Transform.cxx:2627
 TSpectrum2Transform.cxx:2628
 TSpectrum2Transform.cxx:2629
 TSpectrum2Transform.cxx:2630
 TSpectrum2Transform.cxx:2631
 TSpectrum2Transform.cxx:2632
 TSpectrum2Transform.cxx:2633
 TSpectrum2Transform.cxx:2634
 TSpectrum2Transform.cxx:2635
 TSpectrum2Transform.cxx:2636
 TSpectrum2Transform.cxx:2637
 TSpectrum2Transform.cxx:2638
 TSpectrum2Transform.cxx:2639
 TSpectrum2Transform.cxx:2640
 TSpectrum2Transform.cxx:2641
 TSpectrum2Transform.cxx:2642
 TSpectrum2Transform.cxx:2643
 TSpectrum2Transform.cxx:2644
 TSpectrum2Transform.cxx:2645
 TSpectrum2Transform.cxx:2646
 TSpectrum2Transform.cxx:2647
 TSpectrum2Transform.cxx:2648
 TSpectrum2Transform.cxx:2649
 TSpectrum2Transform.cxx:2650
 TSpectrum2Transform.cxx:2651
 TSpectrum2Transform.cxx:2652
 TSpectrum2Transform.cxx:2653
 TSpectrum2Transform.cxx:2654
 TSpectrum2Transform.cxx:2655
 TSpectrum2Transform.cxx:2656
 TSpectrum2Transform.cxx:2657
 TSpectrum2Transform.cxx:2658
 TSpectrum2Transform.cxx:2659
 TSpectrum2Transform.cxx:2660
 TSpectrum2Transform.cxx:2661
 TSpectrum2Transform.cxx:2662
 TSpectrum2Transform.cxx:2663
 TSpectrum2Transform.cxx:2664
 TSpectrum2Transform.cxx:2665
 TSpectrum2Transform.cxx:2666
 TSpectrum2Transform.cxx:2667
 TSpectrum2Transform.cxx:2668
 TSpectrum2Transform.cxx:2669
 TSpectrum2Transform.cxx:2670
 TSpectrum2Transform.cxx:2671
 TSpectrum2Transform.cxx:2672
 TSpectrum2Transform.cxx:2673
 TSpectrum2Transform.cxx:2674
 TSpectrum2Transform.cxx:2675
 TSpectrum2Transform.cxx:2676
 TSpectrum2Transform.cxx:2677
 TSpectrum2Transform.cxx:2678
 TSpectrum2Transform.cxx:2679
 TSpectrum2Transform.cxx:2680
 TSpectrum2Transform.cxx:2681
 TSpectrum2Transform.cxx:2682
 TSpectrum2Transform.cxx:2683
 TSpectrum2Transform.cxx:2684
 TSpectrum2Transform.cxx:2685
 TSpectrum2Transform.cxx:2686
 TSpectrum2Transform.cxx:2687
 TSpectrum2Transform.cxx:2688
 TSpectrum2Transform.cxx:2689
 TSpectrum2Transform.cxx:2690
 TSpectrum2Transform.cxx:2691
 TSpectrum2Transform.cxx:2692
 TSpectrum2Transform.cxx:2693
 TSpectrum2Transform.cxx:2694
 TSpectrum2Transform.cxx:2695
 TSpectrum2Transform.cxx:2696
 TSpectrum2Transform.cxx:2697
 TSpectrum2Transform.cxx:2698
 TSpectrum2Transform.cxx:2699
 TSpectrum2Transform.cxx:2700
 TSpectrum2Transform.cxx:2701
 TSpectrum2Transform.cxx:2702
 TSpectrum2Transform.cxx:2703
 TSpectrum2Transform.cxx:2704
 TSpectrum2Transform.cxx:2705
 TSpectrum2Transform.cxx:2706
 TSpectrum2Transform.cxx:2707
 TSpectrum2Transform.cxx:2708
 TSpectrum2Transform.cxx:2709
 TSpectrum2Transform.cxx:2710
 TSpectrum2Transform.cxx:2711
 TSpectrum2Transform.cxx:2712
 TSpectrum2Transform.cxx:2713
 TSpectrum2Transform.cxx:2714
 TSpectrum2Transform.cxx:2715
 TSpectrum2Transform.cxx:2716
 TSpectrum2Transform.cxx:2717
 TSpectrum2Transform.cxx:2718
 TSpectrum2Transform.cxx:2719
 TSpectrum2Transform.cxx:2720
 TSpectrum2Transform.cxx:2721
 TSpectrum2Transform.cxx:2722
 TSpectrum2Transform.cxx:2723
 TSpectrum2Transform.cxx:2724
 TSpectrum2Transform.cxx:2725
 TSpectrum2Transform.cxx:2726
 TSpectrum2Transform.cxx:2727
 TSpectrum2Transform.cxx:2728
 TSpectrum2Transform.cxx:2729
 TSpectrum2Transform.cxx:2730
 TSpectrum2Transform.cxx:2731
 TSpectrum2Transform.cxx:2732
 TSpectrum2Transform.cxx:2733
 TSpectrum2Transform.cxx:2734
 TSpectrum2Transform.cxx:2735
 TSpectrum2Transform.cxx:2736
 TSpectrum2Transform.cxx:2737
 TSpectrum2Transform.cxx:2738
 TSpectrum2Transform.cxx:2739
 TSpectrum2Transform.cxx:2740
 TSpectrum2Transform.cxx:2741
 TSpectrum2Transform.cxx:2742
 TSpectrum2Transform.cxx:2743
 TSpectrum2Transform.cxx:2744
 TSpectrum2Transform.cxx:2745
 TSpectrum2Transform.cxx:2746
 TSpectrum2Transform.cxx:2747
 TSpectrum2Transform.cxx:2748
 TSpectrum2Transform.cxx:2749
 TSpectrum2Transform.cxx:2750
 TSpectrum2Transform.cxx:2751
 TSpectrum2Transform.cxx:2752
 TSpectrum2Transform.cxx:2753
 TSpectrum2Transform.cxx:2754
 TSpectrum2Transform.cxx:2755
 TSpectrum2Transform.cxx:2756
 TSpectrum2Transform.cxx:2757
 TSpectrum2Transform.cxx:2758
 TSpectrum2Transform.cxx:2759
 TSpectrum2Transform.cxx:2760
 TSpectrum2Transform.cxx:2761
 TSpectrum2Transform.cxx:2762
 TSpectrum2Transform.cxx:2763
 TSpectrum2Transform.cxx:2764
 TSpectrum2Transform.cxx:2765
 TSpectrum2Transform.cxx:2766
 TSpectrum2Transform.cxx:2767
 TSpectrum2Transform.cxx:2768
 TSpectrum2Transform.cxx:2769
 TSpectrum2Transform.cxx:2770
 TSpectrum2Transform.cxx:2771
 TSpectrum2Transform.cxx:2772
 TSpectrum2Transform.cxx:2773
 TSpectrum2Transform.cxx:2774
 TSpectrum2Transform.cxx:2775
 TSpectrum2Transform.cxx:2776
 TSpectrum2Transform.cxx:2777
 TSpectrum2Transform.cxx:2778
 TSpectrum2Transform.cxx:2779
 TSpectrum2Transform.cxx:2780
 TSpectrum2Transform.cxx:2781
 TSpectrum2Transform.cxx:2782
 TSpectrum2Transform.cxx:2783
 TSpectrum2Transform.cxx:2784
 TSpectrum2Transform.cxx:2785
 TSpectrum2Transform.cxx:2786
 TSpectrum2Transform.cxx:2787
 TSpectrum2Transform.cxx:2788
 TSpectrum2Transform.cxx:2789
 TSpectrum2Transform.cxx:2790
 TSpectrum2Transform.cxx:2791
 TSpectrum2Transform.cxx:2792
 TSpectrum2Transform.cxx:2793
 TSpectrum2Transform.cxx:2794
 TSpectrum2Transform.cxx:2795
 TSpectrum2Transform.cxx:2796
 TSpectrum2Transform.cxx:2797
 TSpectrum2Transform.cxx:2798
 TSpectrum2Transform.cxx:2799
 TSpectrum2Transform.cxx:2800
 TSpectrum2Transform.cxx:2801
 TSpectrum2Transform.cxx:2802
 TSpectrum2Transform.cxx:2803
 TSpectrum2Transform.cxx:2804
 TSpectrum2Transform.cxx:2805
 TSpectrum2Transform.cxx:2806
 TSpectrum2Transform.cxx:2807
 TSpectrum2Transform.cxx:2808
 TSpectrum2Transform.cxx:2809
 TSpectrum2Transform.cxx:2810
 TSpectrum2Transform.cxx:2811
 TSpectrum2Transform.cxx:2812
 TSpectrum2Transform.cxx:2813
 TSpectrum2Transform.cxx:2814
 TSpectrum2Transform.cxx:2815
 TSpectrum2Transform.cxx:2816
 TSpectrum2Transform.cxx:2817
 TSpectrum2Transform.cxx:2818
 TSpectrum2Transform.cxx:2819
 TSpectrum2Transform.cxx:2820
 TSpectrum2Transform.cxx:2821
 TSpectrum2Transform.cxx:2822
 TSpectrum2Transform.cxx:2823
 TSpectrum2Transform.cxx:2824
 TSpectrum2Transform.cxx:2825
 TSpectrum2Transform.cxx:2826
 TSpectrum2Transform.cxx:2827
 TSpectrum2Transform.cxx:2828
 TSpectrum2Transform.cxx:2829
 TSpectrum2Transform.cxx:2830
 TSpectrum2Transform.cxx:2831
 TSpectrum2Transform.cxx:2832
 TSpectrum2Transform.cxx:2833
 TSpectrum2Transform.cxx:2834
 TSpectrum2Transform.cxx:2835
 TSpectrum2Transform.cxx:2836
 TSpectrum2Transform.cxx:2837
 TSpectrum2Transform.cxx:2838
 TSpectrum2Transform.cxx:2839
 TSpectrum2Transform.cxx:2840
 TSpectrum2Transform.cxx:2841
 TSpectrum2Transform.cxx:2842
 TSpectrum2Transform.cxx:2843
 TSpectrum2Transform.cxx:2844
 TSpectrum2Transform.cxx:2845
 TSpectrum2Transform.cxx:2846
 TSpectrum2Transform.cxx:2847
 TSpectrum2Transform.cxx:2848
 TSpectrum2Transform.cxx:2849
 TSpectrum2Transform.cxx:2850
 TSpectrum2Transform.cxx:2851
 TSpectrum2Transform.cxx:2852
 TSpectrum2Transform.cxx:2853
 TSpectrum2Transform.cxx:2854
 TSpectrum2Transform.cxx:2855
 TSpectrum2Transform.cxx:2856
 TSpectrum2Transform.cxx:2857
 TSpectrum2Transform.cxx:2858
 TSpectrum2Transform.cxx:2859
 TSpectrum2Transform.cxx:2860
 TSpectrum2Transform.cxx:2861
 TSpectrum2Transform.cxx:2862
 TSpectrum2Transform.cxx:2863
 TSpectrum2Transform.cxx:2864
 TSpectrum2Transform.cxx:2865
 TSpectrum2Transform.cxx:2866
 TSpectrum2Transform.cxx:2867
 TSpectrum2Transform.cxx:2868
 TSpectrum2Transform.cxx:2869
 TSpectrum2Transform.cxx:2870
 TSpectrum2Transform.cxx:2871
 TSpectrum2Transform.cxx:2872
 TSpectrum2Transform.cxx:2873
 TSpectrum2Transform.cxx:2874
 TSpectrum2Transform.cxx:2875
 TSpectrum2Transform.cxx:2876
 TSpectrum2Transform.cxx:2877
 TSpectrum2Transform.cxx:2878
 TSpectrum2Transform.cxx:2879
 TSpectrum2Transform.cxx:2880
 TSpectrum2Transform.cxx:2881
 TSpectrum2Transform.cxx:2882
 TSpectrum2Transform.cxx:2883
 TSpectrum2Transform.cxx:2884
 TSpectrum2Transform.cxx:2885
 TSpectrum2Transform.cxx:2886
 TSpectrum2Transform.cxx:2887
 TSpectrum2Transform.cxx:2888
 TSpectrum2Transform.cxx:2889
 TSpectrum2Transform.cxx:2890
 TSpectrum2Transform.cxx:2891
 TSpectrum2Transform.cxx:2892
 TSpectrum2Transform.cxx:2893
 TSpectrum2Transform.cxx:2894
 TSpectrum2Transform.cxx:2895
 TSpectrum2Transform.cxx:2896
 TSpectrum2Transform.cxx:2897
 TSpectrum2Transform.cxx:2898
 TSpectrum2Transform.cxx:2899
 TSpectrum2Transform.cxx:2900
 TSpectrum2Transform.cxx:2901
 TSpectrum2Transform.cxx:2902
 TSpectrum2Transform.cxx:2903
 TSpectrum2Transform.cxx:2904
 TSpectrum2Transform.cxx:2905
 TSpectrum2Transform.cxx:2906
 TSpectrum2Transform.cxx:2907
 TSpectrum2Transform.cxx:2908
 TSpectrum2Transform.cxx:2909
 TSpectrum2Transform.cxx:2910
 TSpectrum2Transform.cxx:2911
 TSpectrum2Transform.cxx:2912
 TSpectrum2Transform.cxx:2913
 TSpectrum2Transform.cxx:2914
 TSpectrum2Transform.cxx:2915
 TSpectrum2Transform.cxx:2916
 TSpectrum2Transform.cxx:2917
 TSpectrum2Transform.cxx:2918
 TSpectrum2Transform.cxx:2919
 TSpectrum2Transform.cxx:2920
 TSpectrum2Transform.cxx:2921
 TSpectrum2Transform.cxx:2922
 TSpectrum2Transform.cxx:2923
 TSpectrum2Transform.cxx:2924
 TSpectrum2Transform.cxx:2925
 TSpectrum2Transform.cxx:2926
 TSpectrum2Transform.cxx:2927
 TSpectrum2Transform.cxx:2928
 TSpectrum2Transform.cxx:2929
 TSpectrum2Transform.cxx:2930
 TSpectrum2Transform.cxx:2931
 TSpectrum2Transform.cxx:2932
 TSpectrum2Transform.cxx:2933
 TSpectrum2Transform.cxx:2934
 TSpectrum2Transform.cxx:2935
 TSpectrum2Transform.cxx:2936
 TSpectrum2Transform.cxx:2937
 TSpectrum2Transform.cxx:2938
 TSpectrum2Transform.cxx:2939
 TSpectrum2Transform.cxx:2940
 TSpectrum2Transform.cxx:2941
 TSpectrum2Transform.cxx:2942
 TSpectrum2Transform.cxx:2943
 TSpectrum2Transform.cxx:2944
 TSpectrum2Transform.cxx:2945
 TSpectrum2Transform.cxx:2946
 TSpectrum2Transform.cxx:2947
 TSpectrum2Transform.cxx:2948
 TSpectrum2Transform.cxx:2949
 TSpectrum2Transform.cxx:2950
 TSpectrum2Transform.cxx:2951
 TSpectrum2Transform.cxx:2952
 TSpectrum2Transform.cxx:2953
 TSpectrum2Transform.cxx:2954
 TSpectrum2Transform.cxx:2955
 TSpectrum2Transform.cxx:2956
 TSpectrum2Transform.cxx:2957
 TSpectrum2Transform.cxx:2958
 TSpectrum2Transform.cxx:2959
 TSpectrum2Transform.cxx:2960
 TSpectrum2Transform.cxx:2961
 TSpectrum2Transform.cxx:2962
 TSpectrum2Transform.cxx:2963
 TSpectrum2Transform.cxx:2964
 TSpectrum2Transform.cxx:2965
 TSpectrum2Transform.cxx:2966
 TSpectrum2Transform.cxx:2967
 TSpectrum2Transform.cxx:2968
 TSpectrum2Transform.cxx:2969
 TSpectrum2Transform.cxx:2970
 TSpectrum2Transform.cxx:2971
 TSpectrum2Transform.cxx:2972
 TSpectrum2Transform.cxx:2973
 TSpectrum2Transform.cxx:2974
 TSpectrum2Transform.cxx:2975
 TSpectrum2Transform.cxx:2976
 TSpectrum2Transform.cxx:2977
 TSpectrum2Transform.cxx:2978
 TSpectrum2Transform.cxx:2979
 TSpectrum2Transform.cxx:2980
 TSpectrum2Transform.cxx:2981
 TSpectrum2Transform.cxx:2982
 TSpectrum2Transform.cxx:2983
 TSpectrum2Transform.cxx:2984
 TSpectrum2Transform.cxx:2985
 TSpectrum2Transform.cxx:2986
 TSpectrum2Transform.cxx:2987
 TSpectrum2Transform.cxx:2988
 TSpectrum2Transform.cxx:2989
 TSpectrum2Transform.cxx:2990
 TSpectrum2Transform.cxx:2991
 TSpectrum2Transform.cxx:2992
 TSpectrum2Transform.cxx:2993
 TSpectrum2Transform.cxx:2994
 TSpectrum2Transform.cxx:2995
 TSpectrum2Transform.cxx:2996
 TSpectrum2Transform.cxx:2997
 TSpectrum2Transform.cxx:2998
 TSpectrum2Transform.cxx:2999
 TSpectrum2Transform.cxx:3000
 TSpectrum2Transform.cxx:3001
 TSpectrum2Transform.cxx:3002
 TSpectrum2Transform.cxx:3003
 TSpectrum2Transform.cxx:3004
 TSpectrum2Transform.cxx:3005
 TSpectrum2Transform.cxx:3006
 TSpectrum2Transform.cxx:3007
 TSpectrum2Transform.cxx:3008
 TSpectrum2Transform.cxx:3009
 TSpectrum2Transform.cxx:3010
 TSpectrum2Transform.cxx:3011
 TSpectrum2Transform.cxx:3012
 TSpectrum2Transform.cxx:3013
 TSpectrum2Transform.cxx:3014
 TSpectrum2Transform.cxx:3015
 TSpectrum2Transform.cxx:3016
 TSpectrum2Transform.cxx:3017
 TSpectrum2Transform.cxx:3018
 TSpectrum2Transform.cxx:3019
 TSpectrum2Transform.cxx:3020
 TSpectrum2Transform.cxx:3021
 TSpectrum2Transform.cxx:3022
 TSpectrum2Transform.cxx:3023
 TSpectrum2Transform.cxx:3024
 TSpectrum2Transform.cxx:3025
 TSpectrum2Transform.cxx:3026
 TSpectrum2Transform.cxx:3027
 TSpectrum2Transform.cxx:3028
 TSpectrum2Transform.cxx:3029
 TSpectrum2Transform.cxx:3030
 TSpectrum2Transform.cxx:3031
 TSpectrum2Transform.cxx:3032
 TSpectrum2Transform.cxx:3033
 TSpectrum2Transform.cxx:3034
 TSpectrum2Transform.cxx:3035
 TSpectrum2Transform.cxx:3036
 TSpectrum2Transform.cxx:3037
 TSpectrum2Transform.cxx:3038
 TSpectrum2Transform.cxx:3039
 TSpectrum2Transform.cxx:3040
 TSpectrum2Transform.cxx:3041
 TSpectrum2Transform.cxx:3042
 TSpectrum2Transform.cxx:3043
 TSpectrum2Transform.cxx:3044
 TSpectrum2Transform.cxx:3045
 TSpectrum2Transform.cxx:3046
 TSpectrum2Transform.cxx:3047
 TSpectrum2Transform.cxx:3048
 TSpectrum2Transform.cxx:3049
 TSpectrum2Transform.cxx:3050
 TSpectrum2Transform.cxx:3051
 TSpectrum2Transform.cxx:3052
 TSpectrum2Transform.cxx:3053
 TSpectrum2Transform.cxx:3054
 TSpectrum2Transform.cxx:3055
 TSpectrum2Transform.cxx:3056
 TSpectrum2Transform.cxx:3057
 TSpectrum2Transform.cxx:3058
 TSpectrum2Transform.cxx:3059
 TSpectrum2Transform.cxx:3060
 TSpectrum2Transform.cxx:3061
 TSpectrum2Transform.cxx:3062
 TSpectrum2Transform.cxx:3063
 TSpectrum2Transform.cxx:3064
 TSpectrum2Transform.cxx:3065
 TSpectrum2Transform.cxx:3066
 TSpectrum2Transform.cxx:3067
 TSpectrum2Transform.cxx:3068
 TSpectrum2Transform.cxx:3069
 TSpectrum2Transform.cxx:3070
 TSpectrum2Transform.cxx:3071
 TSpectrum2Transform.cxx:3072
 TSpectrum2Transform.cxx:3073
 TSpectrum2Transform.cxx:3074
 TSpectrum2Transform.cxx:3075
 TSpectrum2Transform.cxx:3076
 TSpectrum2Transform.cxx:3077
 TSpectrum2Transform.cxx:3078
 TSpectrum2Transform.cxx:3079
 TSpectrum2Transform.cxx:3080
 TSpectrum2Transform.cxx:3081
 TSpectrum2Transform.cxx:3082
 TSpectrum2Transform.cxx:3083
 TSpectrum2Transform.cxx:3084
 TSpectrum2Transform.cxx:3085
 TSpectrum2Transform.cxx:3086
 TSpectrum2Transform.cxx:3087
 TSpectrum2Transform.cxx:3088
 TSpectrum2Transform.cxx:3089
 TSpectrum2Transform.cxx:3090
 TSpectrum2Transform.cxx:3091
 TSpectrum2Transform.cxx:3092
 TSpectrum2Transform.cxx:3093
 TSpectrum2Transform.cxx:3094
 TSpectrum2Transform.cxx:3095
 TSpectrum2Transform.cxx:3096
 TSpectrum2Transform.cxx:3097
 TSpectrum2Transform.cxx:3098
 TSpectrum2Transform.cxx:3099
 TSpectrum2Transform.cxx:3100
 TSpectrum2Transform.cxx:3101
 TSpectrum2Transform.cxx:3102
 TSpectrum2Transform.cxx:3103
 TSpectrum2Transform.cxx:3104
 TSpectrum2Transform.cxx:3105
 TSpectrum2Transform.cxx:3106
 TSpectrum2Transform.cxx:3107
 TSpectrum2Transform.cxx:3108
 TSpectrum2Transform.cxx:3109
 TSpectrum2Transform.cxx:3110
 TSpectrum2Transform.cxx:3111
 TSpectrum2Transform.cxx:3112
 TSpectrum2Transform.cxx:3113
 TSpectrum2Transform.cxx:3114
 TSpectrum2Transform.cxx:3115
 TSpectrum2Transform.cxx:3116
 TSpectrum2Transform.cxx:3117
 TSpectrum2Transform.cxx:3118
 TSpectrum2Transform.cxx:3119
 TSpectrum2Transform.cxx:3120
 TSpectrum2Transform.cxx:3121
 TSpectrum2Transform.cxx:3122
 TSpectrum2Transform.cxx:3123
 TSpectrum2Transform.cxx:3124
 TSpectrum2Transform.cxx:3125
 TSpectrum2Transform.cxx:3126
 TSpectrum2Transform.cxx:3127
 TSpectrum2Transform.cxx:3128
 TSpectrum2Transform.cxx:3129
 TSpectrum2Transform.cxx:3130
 TSpectrum2Transform.cxx:3131
 TSpectrum2Transform.cxx:3132
 TSpectrum2Transform.cxx:3133
 TSpectrum2Transform.cxx:3134
 TSpectrum2Transform.cxx:3135
 TSpectrum2Transform.cxx:3136
 TSpectrum2Transform.cxx:3137
 TSpectrum2Transform.cxx:3138
 TSpectrum2Transform.cxx:3139
 TSpectrum2Transform.cxx:3140
 TSpectrum2Transform.cxx:3141
 TSpectrum2Transform.cxx:3142
 TSpectrum2Transform.cxx:3143
 TSpectrum2Transform.cxx:3144
 TSpectrum2Transform.cxx:3145
 TSpectrum2Transform.cxx:3146
 TSpectrum2Transform.cxx:3147
 TSpectrum2Transform.cxx:3148
 TSpectrum2Transform.cxx:3149
 TSpectrum2Transform.cxx:3150
 TSpectrum2Transform.cxx:3151
 TSpectrum2Transform.cxx:3152
 TSpectrum2Transform.cxx:3153
 TSpectrum2Transform.cxx:3154
 TSpectrum2Transform.cxx:3155
 TSpectrum2Transform.cxx:3156
 TSpectrum2Transform.cxx:3157
 TSpectrum2Transform.cxx:3158
 TSpectrum2Transform.cxx:3159
 TSpectrum2Transform.cxx:3160
 TSpectrum2Transform.cxx:3161
 TSpectrum2Transform.cxx:3162
 TSpectrum2Transform.cxx:3163
 TSpectrum2Transform.cxx:3164
 TSpectrum2Transform.cxx:3165
 TSpectrum2Transform.cxx:3166
 TSpectrum2Transform.cxx:3167
 TSpectrum2Transform.cxx:3168
 TSpectrum2Transform.cxx:3169
 TSpectrum2Transform.cxx:3170
 TSpectrum2Transform.cxx:3171
 TSpectrum2Transform.cxx:3172
 TSpectrum2Transform.cxx:3173
 TSpectrum2Transform.cxx:3174
 TSpectrum2Transform.cxx:3175
 TSpectrum2Transform.cxx:3176
 TSpectrum2Transform.cxx:3177
 TSpectrum2Transform.cxx:3178
 TSpectrum2Transform.cxx:3179
 TSpectrum2Transform.cxx:3180
 TSpectrum2Transform.cxx:3181
 TSpectrum2Transform.cxx:3182
 TSpectrum2Transform.cxx:3183
 TSpectrum2Transform.cxx:3184
 TSpectrum2Transform.cxx:3185
 TSpectrum2Transform.cxx:3186
 TSpectrum2Transform.cxx:3187
 TSpectrum2Transform.cxx:3188
 TSpectrum2Transform.cxx:3189
 TSpectrum2Transform.cxx:3190
 TSpectrum2Transform.cxx:3191
 TSpectrum2Transform.cxx:3192
 TSpectrum2Transform.cxx:3193
 TSpectrum2Transform.cxx:3194
 TSpectrum2Transform.cxx:3195
 TSpectrum2Transform.cxx:3196
 TSpectrum2Transform.cxx:3197
 TSpectrum2Transform.cxx:3198
 TSpectrum2Transform.cxx:3199
 TSpectrum2Transform.cxx:3200
 TSpectrum2Transform.cxx:3201
 TSpectrum2Transform.cxx:3202
 TSpectrum2Transform.cxx:3203
 TSpectrum2Transform.cxx:3204
 TSpectrum2Transform.cxx:3205
 TSpectrum2Transform.cxx:3206
 TSpectrum2Transform.cxx:3207
 TSpectrum2Transform.cxx:3208
 TSpectrum2Transform.cxx:3209
 TSpectrum2Transform.cxx:3210
 TSpectrum2Transform.cxx:3211
 TSpectrum2Transform.cxx:3212
 TSpectrum2Transform.cxx:3213
 TSpectrum2Transform.cxx:3214
 TSpectrum2Transform.cxx:3215
 TSpectrum2Transform.cxx:3216
 TSpectrum2Transform.cxx:3217
 TSpectrum2Transform.cxx:3218
 TSpectrum2Transform.cxx:3219
 TSpectrum2Transform.cxx:3220
 TSpectrum2Transform.cxx:3221
 TSpectrum2Transform.cxx:3222
 TSpectrum2Transform.cxx:3223
 TSpectrum2Transform.cxx:3224
 TSpectrum2Transform.cxx:3225
 TSpectrum2Transform.cxx:3226
 TSpectrum2Transform.cxx:3227
 TSpectrum2Transform.cxx:3228
 TSpectrum2Transform.cxx:3229
 TSpectrum2Transform.cxx:3230
 TSpectrum2Transform.cxx:3231