ROOT logo
// @(#)root/spectrum:$Id$
// Author: Miroslav Morhac   27/05/99

#include "TSpectrum.h"
#include "TPolyMarker.h"
#include "TVirtualPad.h"
#include "TList.h"
#include "TH1.h"
#include "TMath.h"


//______________________________________________________________________________
/* Begin_Html
<center><h2>Advanced Spectra Processing</h2></center>
This class contains advanced spectra processing functions for:
<ul>
<li> One-dimensional background estimation
<li> One-dimensional smoothing
<li> One-dimensional deconvolution
<li> One-dimensional peak search
</ul>
<p>
Author:
<br>
<br> Miroslav Morhac
<br> Institute of Physics
<br> Slovak Academy of Sciences
<br> Dubravska cesta 9, 842 28 BRATISLAVA
<br> SLOVAKIA
<br> email:fyzimiro@savba.sk,    fax:+421 7 54772479
<br>
<br>

The original code in C has been repackaged as a C++ class by R.Brun.
<p>
The algorithms in this class have been published in the following references:
<ol>
<li> M.Morhac et al.: Background elimination methods for
multidimensional coincidence gamma-ray spectra. Nuclear
Instruments and Methods in Physics Research A 401 (1997) 113-132.
<li> M.Morhac et al.: Efficient one- and two-dimensional Gold
deconvolution and its application to gamma-ray spectra
decomposition. Nuclear Instruments and Methods in Physics
Research A 401 (1997) 385-408.
<li> M.Morhac et al.: Identification of peaks in multidimensional
coincidence gamma-ray spectra. Nuclear Instruments and Methods in
Research Physics A  443(2000), 108-125.
</ol>
These NIM papers are also available as doc or ps files from:
<ul>
<li> <A href="ftp://root.cern.ch/root/Spectrum.doc">Spectrum.doc</A><br>
<li> <A href="ftp://root.cern.ch/root/SpectrumDec.ps.gz">SpectrumDec.ps.gz</A><br>
<li> <A href="ftp://root.cern.ch/root/SpectrumSrc.ps.gz">SpectrumSrc.ps.gz</A><br>
<li> <A href="ftp://root.cern.ch/root/SpectrumBck.ps.gz">SpectrumBck.ps.gz</A><br>
</ul>
End_Html */

Int_t TSpectrum::fgIterations    = 3;
Int_t TSpectrum::fgAverageWindow = 3;

#define PEAK_WINDOW 1024
ClassImp(TSpectrum)


//______________________________________________________________________________
TSpectrum::TSpectrum() :TNamed("Spectrum", "Miroslav Morhac peak finder")
{
   /* Begin_Html
   Constructor.
   End_Html */

   Int_t n = 100;
   fMaxPeaks  = n;
   fPosition   = new Float_t[n];
   fPositionX  = new Float_t[n];
   fPositionY  = new Float_t[n];
   fResolution = 1;
   fHistogram  = 0;
   fNPeaks     = 0;
}


//______________________________________________________________________________
TSpectrum::TSpectrum(Int_t maxpositions, Float_t resolution)
          :TNamed("Spectrum", "Miroslav Morhac peak finder")
{
   /* Begin_Html
   <ul>
   <li> maxpositions: maximum number of peaks
   <li> resolution: determines resolution of the neighboring peaks
                   default value is 1 correspond to 3 sigma distance
                   between peaks. Higher values allow higher resolution
                   (smaller distance between peaks.
                   May be set later through SetResolution.
   </ul>
   End_Html */

   Int_t n = maxpositions;
   if (n <= 0) n = 1;
   fMaxPeaks  = n;
   fPosition  = new Float_t[n];
   fPositionX = new Float_t[n];
   fPositionY = new Float_t[n];
   fHistogram = 0;
   fNPeaks    = 0;
   SetResolution(resolution);
}


//______________________________________________________________________________
TSpectrum::~TSpectrum()
{
   /* Begin_Html
   Destructor.
   End_Html */

   delete [] fPosition;
   delete [] fPositionX;
   delete [] fPositionY;
   delete    fHistogram;
}


//______________________________________________________________________________
void TSpectrum::SetAverageWindow(Int_t w)
{
   /* Begin_Html
   Static function: Set average window of searched peaks
   (see TSpectrum::SearchHighRes).
   End_Html */

   fgAverageWindow = w;
}


//______________________________________________________________________________
void TSpectrum::SetDeconIterations(Int_t n)
{
   /* Begin_Html
   Static function: Set max number of decon iterations in deconvolution
   operation (see TSpectrum::SearchHighRes).
   End_Html */

   fgIterations = n;
}


//______________________________________________________________________________
TH1 *TSpectrum::Background(const TH1 * h, int numberIterations,
                           Option_t * option)
{
   /* Begin_Html
   <b>One-dimensional background estimation function.</b>
   <p>
   This function calculates the background spectrum in the input histogram h.
   The background is returned as a histogram.
   <p>
   Function parameters:
   <ul>
   <li> h: input 1-d histogram
   <li> numberIterations, (default value = 20)
      Increasing numberIterations make the result smoother and lower.
   <li> option: may contain one of the following options:
      <ul>
      <li> to set the direction parameter
      "BackIncreasingWindow". By default the direction is BackDecreasingWindow
      <li> filterOrder-order of clipping filter,  (default "BackOrder2")
                  -possible values= "BackOrder4"
                                    "BackOrder6"
                                    "BackOrder8"
      <li> "nosmoothing"- if selected, the background is not smoothed
           By default the background is smoothed.
      <li> smoothWindow-width of smoothing window, (default is "BackSmoothing3")
                  -possible values= "BackSmoothing5"
                                    "BackSmoothing7"
                                    "BackSmoothing9"
                                    "BackSmoothing11"
                                    "BackSmoothing13"
                                    "BackSmoothing15"
      <li> "Compton" if selected the estimation of Compton edge
                  will be included.
      <li> "same" : if this option is specified, the resulting background
                 histogram is superimposed on the picture in the current pad.
      </ul>
   </ul>
   NOTE that the background is only evaluated in the current range of h.
   ie, if h has a bin range (set via h->GetXaxis()->SetRange(binmin,binmax),
   the returned histogram will be created with the same number of bins
   as the input histogram h, but only bins from binmin to binmax will be filled
   with the estimated background.
   End_Html */

   if (h == 0) return 0;
   Int_t dimension = h->GetDimension();
   if (dimension > 1) {
      Error("Search", "Only implemented for 1-d histograms");
      return 0;
   }
   TString opt = option;
   opt.ToLower();

   //set options
   Int_t direction = kBackDecreasingWindow;
   if (opt.Contains("backincreasingwindow")) direction = kBackIncreasingWindow;
   Int_t filterOrder = kBackOrder2;
   if (opt.Contains("backorder4")) filterOrder = kBackOrder4;
   if (opt.Contains("backorder6")) filterOrder = kBackOrder6;
   if (opt.Contains("backorder8")) filterOrder = kBackOrder8;
   Bool_t smoothing = kTRUE;
   if (opt.Contains("nosmoothing")) smoothing = kFALSE;
   Int_t smoothWindow = kBackSmoothing3;
   if (opt.Contains("backsmoothing5"))  smoothWindow = kBackSmoothing5;
   if (opt.Contains("backsmoothing7"))  smoothWindow = kBackSmoothing7;
   if (opt.Contains("backsmoothing9"))  smoothWindow = kBackSmoothing9;
   if (opt.Contains("backsmoothing11")) smoothWindow = kBackSmoothing11;
   if (opt.Contains("backsmoothing13")) smoothWindow = kBackSmoothing13;
   if (opt.Contains("backsmoothing15")) smoothWindow = kBackSmoothing15;
   Bool_t compton = kFALSE;
   if (opt.Contains("compton")) compton = kTRUE;

   Int_t first = h->GetXaxis()->GetFirst();
   Int_t last  = h->GetXaxis()->GetLast();
   Int_t size = last-first+1;
   Int_t i;
   Float_t * source = new float[size];
   for (i = 0; i < size; i++) source[i] = h->GetBinContent(i + first);

   //find background (source is input and in output contains the background
   Background(source,size,numberIterations, direction, filterOrder,smoothing,
              smoothWindow,compton);

   //create output histogram containing backgound
   //only bins in the range of the input histogram are filled
   Int_t nch = strlen(h->GetName());
   char *hbname = new char[nch+20];
   snprintf(hbname,nch+20,"%s_background",h->GetName());
   TH1 *hb = (TH1*)h->Clone(hbname);
   hb->Reset();
   hb->GetListOfFunctions()->Delete();
   hb->SetLineColor(2);
   for (i=0; i< size; i++) hb->SetBinContent(i+first,source[i]);
   hb->SetEntries(size);

   //if option "same is specified, draw the result in the pad
   if (opt.Contains("same")) {
      if (gPad) delete gPad->GetPrimitive(hbname);
      hb->Draw("same");
   }
   delete [] source;
   delete [] hbname;
   return hb;
}


//______________________________________________________________________________
void TSpectrum::Print(Option_t *) const
{
   /* Begin_Html
   Print the array of positions.
   End_Html */

   printf("\nNumber of positions = %d\n",fNPeaks);
   for (Int_t i=0;i<fNPeaks;i++) {
      printf(" x[%d] = %g, y[%d] = %g\n",i,fPositionX[i],i,fPositionY[i]);
   }
}


//______________________________________________________________________________
Int_t TSpectrum::Search(const TH1 * hin, Double_t sigma, Option_t * option,
                        Double_t threshold)
{
   /* Begin_Html
   <b>One-dimensional peak search function</b>
   <p>
   This function searches for peaks in source spectrum in hin
   The number of found peaks and their positions are written into
   the members fNpeaks and fPositionX.
   The search is performed in the current histogram range.
   <p>
   Function parameters:
   <ul>
   <li> hin:       pointer to the histogram of source spectrum
   <li> sigma:   sigma of searched peaks, for details we refer to manual
   <li> threshold: (default=0.05)  peaks with amplitude less than
       threshold*highest_peak are discarded.  0<threshold<1
   </ul>
   By default, the background is removed before deconvolution.
   Specify the option "nobackground" to not remove the background.
   <p>
   By default the "Markov" chain algorithm is used.
   Specify the option "noMarkov" to disable this algorithm
   Note that by default the source spectrum is replaced by a new spectrum
   <p>
   By default a polymarker object is created and added to the list of
   functions of the histogram. The histogram is drawn with the specified
   option and the polymarker object drawn on top of the histogram.
   The polymarker coordinates correspond to the npeaks peaks found in
   the histogram.
   <p>
   A pointer to the polymarker object can be retrieved later via:
   <pre>
    TList *functions = hin->GetListOfFunctions();
    TPolyMarker *pm = (TPolyMarker*)functions->FindObject("TPolyMarker");
   </pre>
   Specify the option "goff" to disable the storage and drawing of the
   polymarker.
    <p>
   To disable the final drawing of the histogram with the search results (in case
   you want to draw it yourself) specify "nodraw" in the options parameter.
   End_Html */

   if (hin == 0) return 0;
   Int_t dimension = hin->GetDimension();
   if (dimension > 2) {
      Error("Search", "Only implemented for 1-d and 2-d histograms");
      return 0;
   }
   if (threshold <=0 || threshold >= 1) {
      Warning("Search","threshold must 0<threshold<1, threshol=0.05 assumed");
      threshold = 0.05;
   }
   TString opt = option;
   opt.ToLower();
   Bool_t background = kTRUE;
   if (opt.Contains("nobackground")) {
      background = kFALSE;
      opt.ReplaceAll("nobackground","");
   }
   Bool_t markov = kTRUE;
   if (opt.Contains("nomarkov")) {
      markov = kFALSE;
      opt.ReplaceAll("nomarkov","");
   }
   Bool_t draw = kTRUE;
   if (opt.Contains("nodraw")) {
      draw = kFALSE;
      opt.ReplaceAll("nodraw","");
   }
   if (dimension == 1) {
      Int_t first = hin->GetXaxis()->GetFirst();
      Int_t last  = hin->GetXaxis()->GetLast();
      Int_t size = last-first+1;
      Int_t i, bin, npeaks;
      Float_t * source = new float[size];
      Float_t * dest   = new float[size];
      for (i = 0; i < size; i++) source[i] = hin->GetBinContent(i + first);
      if (sigma < 1) {
         sigma = size/fMaxPeaks;
         if (sigma < 1) sigma = 1;
         if (sigma > 8) sigma = 8;
      }
      npeaks = SearchHighRes(source, dest, size, sigma, 100*threshold,
                             background, fgIterations, markov, fgAverageWindow);

      for (i = 0; i < npeaks; i++) {
         bin = first + Int_t(fPositionX[i] + 0.5);
         fPositionX[i] = hin->GetBinCenter(bin);
         fPositionY[i] = hin->GetBinContent(bin);
      }
      delete [] source;
      delete [] dest;

      if (opt.Contains("goff"))
         return npeaks;
      if (!npeaks) return 0;
      TPolyMarker * pm =
         (TPolyMarker*)hin->GetListOfFunctions()->FindObject("TPolyMarker");
      if (pm) {
         hin->GetListOfFunctions()->Remove(pm);
         delete pm;
      }
      pm = new TPolyMarker(npeaks, fPositionX, fPositionY);
      hin->GetListOfFunctions()->Add(pm);
      pm->SetMarkerStyle(23);
      pm->SetMarkerColor(kRed);
      pm->SetMarkerSize(1.3);
      opt.ReplaceAll(" ","");
      opt.ReplaceAll(",","");
      if (draw)
         ((TH1*)hin)->Draw(opt.Data());
      return npeaks;
   }
   return 0;
}


//______________________________________________________________________________
void TSpectrum::SetResolution(Float_t resolution)
{
   /* Begin_Html
  resolution: determines resolution of the neighboring peaks
              default value is 1 correspond to 3 sigma distance
              between peaks. Higher values allow higher resolution
              (smaller distance between peaks.
              May be set later through SetResolution.
   End_Html */

   if (resolution > 1)
      fResolution = resolution;
   else
      fResolution = 1;
}


//______________________________________________________________________________
const char *TSpectrum::Background(float *spectrum, int ssize,
                                          int numberIterations,
                                          int direction, int filterOrder,
                                          bool smoothing,int smoothWindow,
                                          bool compton)
{
/* Begin_Html
This function calculates background spectrum from source spectrum.
The result is placed in the vector pointed by spe1945ctrum pointer.
The goal is to separate the useful information (peaks) from useless
information (background).

<ul>
<li> method is based on Sensitive Nonlinear Iterative Peak (SNIP) clipping
     algorithm.
<li> new value in the channel "i" is calculated
</ul>

<img width=486 height=72 src="gif/TSpectrum_Background.gif">

where p = 1, 2, ..., numberIterations. In fact it represents second order
difference filter (-1,2,-1).

One can also change the
direction of the change of the clipping window, the order of the clipping
filter, to include smoothing, to set width of smoothing window and to include
the estimation of Compton edges. On successful completion it returns 0. On
error it returns pointer to the string describing error.

<h4>Parameters:</h4>
<ul>
<li> spectrum: pointer to the vector of source spectrum
<li> ssize: length of the spectrum vector
<li> numberIterations: maximal width of clipping window,
<li> direction:  direction of change of clipping window.
     Possible values: kBackIncreasingWindow, kBackDecreasingWindow
<li> filterOrder: order of clipping filter.
     Possible values: kBackOrder2, kBackOrder4, kBackOrder6, kBackOrder8
<li> smoothing: logical variable whether the smoothing operation in the
     estimation of background will be included.
     Possible values: kFALSE, kTRUE
<li> smoothWindow: width of smoothing window.
     Possible values: kBackSmoothing3, kBackSmoothing5, kBackSmoothing7,
     kBackSmoothing9, kBackSmoothing11, kBackSmoothing13, kBackSmoothing15.
<li> compton: logical variable whether the estimation of Compton edge will be
     included. Possible values: kFALSE, kTRUE.
</ul>


<h4>References:</h4>
<ol>
<li> C. G Ryan et al.: SNIP, a statistics-sensitive background treatment for the
quantitative analysis of PIXE spectra in geoscience applications. NIM, B34
(1988), 396-402.

<li> M. Morhá&#269;, J. Kliman, V. Matoušek, M. Veselský, I. Turzo:
Background elimination methods for multidimensional gamma-ray spectra. NIM,
A401 (1997) 113-132.

<li> D. D. Burgess, R. J. Tervo: Background estimation for gamma-ray
spectroscopy. NIM 214 (1983), 431-434.
</ol>

Example 1 script Background_incr.c:
<p>
<img width=601 height=407 src="gif/TSpectrum_Background_incr.jpg">
<p>
Figure 1 Example of the estimation of background for number of iterations=6.
Original spectrum is shown in black color, estimated background in red color.
<p>
Script:
<pre>
// Example to illustrate the background estimator (class TSpectrum).
// To execute this example, do
// root > .x Background_incr.C

#include <TSpectrum>

void Background_incr() {
   Int_t i;
   Double_t nbins = 256;
   Double_t xmin  = 0;
   Double_t xmax  = (Double_t)nbins;
   Float_t * source = new float[nbins];
   TH1F *back = new TH1F("back","",nbins,xmin,xmax);
   TH1F *d = new TH1F("d","",nbins,xmin,xmax);
   TFile *f = new TFile("spectra\\TSpectrum.root");
   back=(TH1F*) f->Get("back1;1");
   TCanvas *Background = gROOT->GetListOfCanvases()->FindObject("Background");
   if (!Background) Background =
     new TCanvas("Background",
                 "Estimation of background with increasing window",
                 10,10,1000,700);
   back->Draw("L");
   TSpectrum *s = new TSpectrum();
   for (i = 0; i < nbins; i++) source[i]=back->GetBinContent(i + 1);
   s->Background(source,nbins,6,kBackIncreasingWindow,kBackOrder2,kFALSE,
                 kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d->SetBinContent(i + 1,source[i]);
   d->SetLineColor(kRed);
   d->Draw("SAME L");
}
</pre>

Example 2 script Background_decr.c:
<p>
In Figure 1. one can notice that at the edges of the peaks the estimated
background goes under the peaks. An alternative approach is to decrease the
clipping window from a given value numberIterations to the value of one, which
is presented in this example.
<p>
<img width=601 height=407 src="gif/TSpectrum_Background_decr.jpg">
<p>
Figure 2 Example of the estimation of background for numberIterations=6 using
decreasing clipping window algorithm. Original spectrum is shown in black
color, estimated background in red color.
<p>
Script:

<pre>
// Example to illustrate the background estimator (class TSpectrum).
// To execute this example, do
// root > .x Background_decr.C

#include <TSpectrum>

void Background_decr() {
   Int_t i;
   Double_t nbins = 256;
   Double_t xmin  = 0;
   Double_t xmax  = (Double_t)nbins;
   Float_t * source = new float[nbins];
   TH1F *back = new TH1F("back","",nbins,xmin,xmax);
   TH1F *d = new TH1F("d","",nbins,xmin,xmax);
   TFile *f = new TFile("spectra\\TSpectrum.root");
   back=(TH1F*) f->Get("back1;1");
   TCanvas *Background = gROOT->GetListOfCanvases()->FindObject("Background");
   if (!Background) Background =
     new TCanvas("Background","Estimation of background with decreasing window",
                 10,10,1000,700);
   back->Draw("L");
   TSpectrum *s = new TSpectrum();
   for (i = 0; i < nbins; i++) source[i]=back->GetBinContent(i + 1);
   s->Background(source,nbins,6,kBackDecreasingWindow,kBackOrder2,kFALSE,
                 kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d->SetBinContent(i + 1,source[i]);
   d->SetLineColor(kRed);
   d->Draw("SAME L");
}
</pre>

Example 3 script Background_width.c:
<p>
The question is how to choose the width of the clipping window, i.e.,
numberIterations parameter. The influence of this parameter on the estimated
background is illustrated in Figure 3.
<p>
<img width=601 height=407 src="gif/TSpectrum_Background_width.jpg">
<p>
Figure 3 Example of the influence of clipping window width on the estimated
background for numberIterations=4 (red line), 6 (blue line) 8 (green line) using
decreasing clipping window algorithm.

<p>
in general one should set this parameter so that the value
2*numberIterations+1 was greater than the widths of preserved objects (peaks).

<p>
Script:

<pre>
// Example to illustrate the influence of the clipping window width on the
// estimated background. To execute this example, do:
// root > .x Background_width.C

#include <TSpectrum>

void Background_width() {
   Int_t i;
   Double_t nbins = 256;
   Double_t xmin  = 0;
   Double_t xmax  = (Double_t)nbins;
   Float_t * source = new float[nbins];
   TH1F *h = new TH1F("h","",nbins,xmin,xmax);
   TH1F *d1 = new TH1F("d1","",nbins,xmin,xmax);
   TH1F *d2 = new TH1F("d2","",nbins,xmin,xmax);
   TH1F *d3 = new TH1F("d3","",nbins,xmin,xmax);
   TFile *f = new TFile("spectra\\TSpectrum.root");
   h=(TH1F*) f->Get("back1;1");
   TCanvas *background = gROOT->GetListOfCanvases()->FindObject("background");
   if (!background) background = new TCanvas("background",
   "Influence of clipping window width on the estimated background",
   10,10,1000,700);
   h->Draw("L");
   TSpectrum *s = new TSpectrum();
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,4,kBackDecreasingWindow,kBackOrder2,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d1->SetBinContent(i + 1,source[i]);
   d1->SetLineColor(kRed);
   d1->Draw("SAME L");
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,6,kBackDecreasingWindow,kBackOrder2,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d2->SetBinContent(i + 1,source[i]);
   d2->SetLineColor(kBlue);
   d2->Draw("SAME L");
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,8,kBackDecreasingWindow,kBackOrder2,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d3->SetBinContent(i + 1,source[i]);
   d3->SetLineColor(kGreen);
   d3->Draw("SAME L");
}
</pre>

Example 4 script Background_width2.c:
<p>
another example for very complex spectrum is given in Figure 4.
<p>
<img width=601 height=407 src="gif/TSpectrum_Background_width2.jpg">
<p>
Figure 4 Example of the influence of clipping window width on the estimated
background for numberIterations=10 (red line), 20 (blue line), 30 (green line)
and 40 (magenta line) using decreasing clipping window algorithm.

<p>
Script:

<pre>
// Example to illustrate the influence of the clipping window width on the
// estimated background. To execute this example, do:
// root > .x Background_width2.C

#include <TSpectrum>

void Background_width2() {
   Int_t i;
   Double_t nbins = 4096;
   Double_t xmin  = 0;
   Double_t xmax  = (Double_t)4096;
   Float_t * source = new float[nbins];
   TH1F *h = new TH1F("h","",nbins,xmin,xmax);
   TH1F *d1 = new TH1F("d1","",nbins,xmin,xmax);
   TH1F *d2 = new TH1F("d2","",nbins,xmin,xmax);
   TH1F *d3 = new TH1F("d3","",nbins,xmin,xmax);
   TH1F *d4 = new TH1F("d4","",nbins,xmin,xmax);
   TFile *f = new TFile("spectra\\TSpectrum.root");
   h=(TH1F*) f->Get("back2;1");
   TCanvas *background = gROOT->GetListOfCanvases()->FindObject("background");
   if (!background) background = new TCanvas("background",
   "Influence of clipping window width on the estimated background",
   10,10,1000,700);
   h->SetAxisRange(0,1000);
   h->SetMaximum(20000);
   h->Draw("L");
   TSpectrum *s = new TSpectrum();
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,10,kBackDecreasingWindow,kBackOrder2,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d1->SetBinContent(i + 1,source[i]);
   d1->SetLineColor(kRed);
   d1->Draw("SAME L");
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,20,kBackDecreasingWindow,kBackOrder2,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d2->SetBinContent(i + 1,source[i]);
   d2->SetLineColor(kBlue);
   d2->Draw("SAME L");
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,30,kBackDecreasingWindow,kBackOrder2,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d3->SetBinContent(i + 1,source[i]);
   d3->SetLineColor(kGreen);
   d3->Draw("SAME L");
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,10,kBackDecreasingWindow,kBackOrder2,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d4->SetBinContent(i + 1,source[i]);
   d4->SetLineColor(kMagenta);
   d4->Draw("SAME L");
}
</pre>

Example 5 script Background_order.c:
<p>
Second order difference filter removes linear (quasi-linear) background and
preserves symmetrical peaks. However if the shape of the background is more
complex one can employ higher-order clipping filters (see example in Figure 5)
<p>
<img width=601 height=407 src="gif/TSpectrum_Background_order.jpg">
<p>
Figure 5 Example of the influence of clipping filter difference order on the
estimated background for fNnumberIterations=40, 2-nd order red line, 4-th order
blue line, 6-th order green line and 8-th order magenta line, and using
decreasing clipping window algorithm.
<p>
Script:
<pre>
// Example to illustrate the influence of the clipping filter difference order
// on the estimated background. To execute this example, do
// root > .x Background_order.C

#include <TSpectrum>

void Background_order() {
   Int_t i;
   Double_t nbins = 4096;
   Double_t xmin  = 0;
   Double_t xmax  = (Double_t)4096;
   Float_t * source = new float[nbins];
   TH1F *h = new TH1F("h","",nbins,xmin,xmax);
   TH1F *d1 = new TH1F("d1","",nbins,xmin,xmax);
   TH1F *d2 = new TH1F("d2","",nbins,xmin,xmax);
   TH1F *d3 = new TH1F("d3","",nbins,xmin,xmax);
   TH1F *d4 = new TH1F("d4","",nbins,xmin,xmax);
   TFile *f = new TFile("spectra\\TSpectrum.root");
   h=(TH1F*) f->Get("back2;1");
   TCanvas *background = gROOT->GetListOfCanvases()->FindObject("background");
   if (!background) background = new TCanvas("background",
   "Influence of clipping filter difference order on the estimated background",
   10,10,1000,700);
   h->SetAxisRange(1220,1460);
   h->SetMaximum(11000);
   h->Draw("L");
   TSpectrum *s = new TSpectrum();
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,40,kBackDecreasingWindow,kBackOrder2,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d1->SetBinContent(i + 1,source[i]);
   d1->SetLineColor(kRed);
   d1->Draw("SAME L");
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,40,kBackDecreasingWindow,kBackOrder4,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d2->SetBinContent(i + 1,source[i]);
   d2->SetLineColor(kBlue);
   d2->Draw("SAME L");
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,40,kBackDecreasingWindow,kBackOrder6,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d3->SetBinContent(i + 1,source[i]);
   d3->SetLineColor(kGreen);
   d3->Draw("SAME L");
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,40,kBackDecreasingWindow,kBackOrder8,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d4->SetBinContent(i + 1,source[i]);
   d4->SetLineColor(kMagenta);
   d4->Draw("SAME L");
}
</pre>

Example 6 script Background_smooth.c:
<p>
The estimate of the background can be influenced by noise present in the
spectrum.  We proposed the algorithm of the background estimate with
simultaneous smoothing.  In the original algorithm without smoothing, the
estimated background snatches the lower spikes in the noise. Consequently,
the areas of peaks are biased by this error.
<p>
<img width=554 height=104 src="gif/TSpectrum_Background_smooth1.jpg">
<p>
Figure 7 Principle of background estimation algorithm with simultaneous
smoothing.
<p>
<img width=601 height=407 src="gif/TSpectrum_Background_smooth2.jpg">
<p>
Figure 8 Illustration of non-smoothing (red line) and smoothing algorithm of
background estimation (blue line).

<p>

Script:

<pre>
// Example to illustrate the background estimator (class TSpectrum) including
// Compton edges. To execute this example, do:
// root > .x Background_smooth.C

#include <TSpectrum>

void Background_smooth() {
   Int_t i;
   Double_t nbins = 4096;
   Double_t xmin  = 0;
   Double_t xmax  = (Double_t)nbins;
   Float_t * source = new float[nbins];
   TH1F *h = new TH1F("h","",nbins,xmin,xmax);
   TH1F *d1 = new TH1F("d1","",nbins,xmin,xmax);
   TH1F *d2 = new TH1F("d2","",nbins,xmin,xmax);
   TFile *f = new TFile("spectra\\TSpectrum.root");
   h=(TH1F*) f->Get("back4;1");
   TCanvas *background = gROOT->GetListOfCanvases()->FindObject("background");
   if (!background) background = new TCanvas("background",
   "Estimation of background with noise",10,10,1000,700);
   h->SetAxisRange(3460,3830);
   h->Draw("L");
   TSpectrum *s = new TSpectrum();
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,6,kBackDecreasingWindow,kBackOrder2,kFALSE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d1->SetBinContent(i + 1,source[i]);
   d1->SetLineColor(kRed);
   d1->Draw("SAME L");
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,6,kBackDecreasingWindow,kBackOrder2,kTRUE,
   kBackSmoothing3,kFALSE);
   for (i = 0; i < nbins; i++) d2->SetBinContent(i + 1,source[i]);
   d2->SetLineColor(kBlue);
   d2->Draw("SAME L");
}
</pre>

Example 8 script Background_compton.c:
<p>
Sometimes it is necessary to include also the Compton edges into the estimate of
the background. In Figure 8 we present the example of the synthetic spectrum
with Compton edges. The background was estimated using the 8-th order filter
with the estimation of the Compton edges using decreasing
clipping window algorithm (numberIterations=10) with smoothing
(smoothingWindow=5).
<p>
<img width=601 height=407 src="gif/TSpectrum_Background_compton.jpg">
<p>
Figure 8 Example of the estimate of the background with Compton edges (red
line) for numberIterations=10, 8-th order difference filter, using decreasing
clipping window algorithm and smoothing (smoothingWindow=5).
<p>
Script:

<pre>
// Example to illustrate the background estimator (class TSpectrum) including
// Compton edges. To execute this example, do:
// root > .x Background_compton.C

#include <TSpectrum>

void Background_compton() {
   Int_t i;
   Double_t nbins = 512;
   Double_t xmin  = 0;
   Double_t xmax  = (Double_t)nbins;
   Float_t * source = new float[nbins];
   TH1F *h = new TH1F("h","",nbins,xmin,xmax);
   TH1F *d1 = new TH1F("d1","",nbins,xmin,xmax);
   TFile *f = new TFile("spectra\\TSpectrum.root");
   h=(TH1F*) f->Get("back3;1");
   TCanvas *background = gROOT->GetListOfCanvases()->FindObject("background");
   if (!background) background = new TCanvas("background",
   "Estimation of background with Compton edges under peaks",10,10,1000,700);
   h->Draw("L");
   TSpectrum *s = new TSpectrum();
   for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
   s->Background(source,nbins,10,kBackDecreasingWindow,kBackOrder8,kTRUE,
   kBackSmoothing5,,kTRUE);
   for (i = 0; i < nbins; i++) d1->SetBinContent(i + 1,source[i]);
   d1->SetLineColor(kRed);
   d1->Draw("SAME L");
}
</pre>

End_Html */

   int i, j, w, bw, b1, b2, priz;
   float a, b, c, d, e, yb1, yb2, ai, av, men, b4, c4, d4, e4, b6, c6, d6, e6, f6, g6, b8, c8, d8, e8, f8, g8, h8, i8;
   if (ssize <= 0)
      return "Wrong Parameters";
   if (numberIterations < 1)
      return "Width of Clipping Window Must Be Positive";
   if (ssize < 2 * numberIterations + 1)
      return "Too Large Clipping Window";
   if (smoothing == kTRUE && smoothWindow != kBackSmoothing3 && smoothWindow != kBackSmoothing5 && smoothWindow != kBackSmoothing7 && smoothWindow != kBackSmoothing9 && smoothWindow != kBackSmoothing11 && smoothWindow != kBackSmoothing13 && smoothWindow != kBackSmoothing15)
      return "Incorrect width of smoothing window";
   float *working_space = new float[2 * ssize];
   for (i = 0; i < ssize; i++){
      working_space[i] = spectrum[i];
      working_space[i + ssize] = spectrum[i];
   }
   bw=(smoothWindow-1)/2;
   if (direction == kBackIncreasingWindow)
      i = 1;
   else if(direction == kBackDecreasingWindow)
      i = numberIterations;
   if (filterOrder == kBackOrder2) {
      do{
         for (j = i; j < ssize - i; j++) {
            if (smoothing == kFALSE){
               a = working_space[ssize + j];
               b = (working_space[ssize + j - i] + working_space[ssize + j + i]) / 2.0;
               if (b < a)
                  a = b;
               working_space[j] = a;
            }

            else if (smoothing == kTRUE){
               a = working_space[ssize + j];
               av = 0;
               men = 0;
               for (w = j - bw; w <= j + bw; w++){
                  if ( w >= 0 && w < ssize){
                     av += working_space[ssize + w];
                     men +=1;
                  }
               }
               av = av / men;
               b = 0;
               men = 0;
               for (w = j - i - bw; w <= j - i + bw; w++){
                  if ( w >= 0 && w < ssize){
                     b += working_space[ssize + w];
                     men +=1;
                  }
               }
               b = b / men;
               c = 0;
               men = 0;
               for (w = j + i - bw; w <= j + i + bw; w++){
                  if ( w >= 0 && w < ssize){
                     c += working_space[ssize + w];
                     men +=1;
                  }
               }
               c = c / men;
               b = (b + c) / 2;
               if (b < a)
                  av = b;
               working_space[j]=av;
            }
         }
         for (j = i; j < ssize - i; j++)
            working_space[ssize + j] = working_space[j];
         if (direction == kBackIncreasingWindow)
            i+=1;
         else if(direction == kBackDecreasingWindow)
            i-=1;
      }while((direction == kBackIncreasingWindow && i <= numberIterations) || (direction == kBackDecreasingWindow && i >= 1));
   }

   else if (filterOrder == kBackOrder4) {
      do{
         for (j = i; j < ssize - i; j++) {
            if (smoothing == kFALSE){
               a = working_space[ssize + j];
               b = (working_space[ssize + j - i] + working_space[ssize + j + i]) / 2.0;
               c = 0;
               ai = i / 2;
               c -= working_space[ssize + j - (int) (2 * ai)] / 6;
               c += 4 * working_space[ssize + j - (int) ai] / 6;
               c += 4 * working_space[ssize + j + (int) ai] / 6;
               c -= working_space[ssize + j + (int) (2 * ai)] / 6;
               if (b < c)
                  b = c;
               if (b < a)
                  a = b;
               working_space[j] = a;
            }

            else if (smoothing == kTRUE){
               a = working_space[ssize + j];
               av = 0;
               men = 0;
               for (w = j - bw; w <= j + bw; w++){
                  if ( w >= 0 && w < ssize){
                     av += working_space[ssize + w];
                     men +=1;
                  }
               }
               av = av / men;
               b = 0;
               men = 0;
               for (w = j - i - bw; w <= j - i + bw; w++){
                  if ( w >= 0 && w < ssize){
                     b += working_space[ssize + w];
                     men +=1;
                  }
               }
               b = b / men;
               c = 0;
               men = 0;
               for (w = j + i - bw; w <= j + i + bw; w++){
                  if ( w >= 0 && w < ssize){
                     c += working_space[ssize + w];
                     men +=1;
                  }
               }
               c = c / men;
               b = (b + c) / 2;
               ai = i / 2;
               b4 = 0, men = 0;
               for (w = j - (int)(2 * ai) - bw; w <= j - (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     b4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               b4 = b4 / men;
               c4 = 0, men = 0;
               for (w = j - (int)ai - bw; w <= j - (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     c4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               c4 = c4 / men;
               d4 = 0, men = 0;
               for (w = j + (int)ai - bw; w <= j + (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     d4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               d4 = d4 / men;
               e4 = 0, men = 0;
               for (w = j + (int)(2 * ai) - bw; w <= j + (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     e4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               e4 = e4 / men;
               b4 = (-b4 + 4 * c4 + 4 * d4 - e4) / 6;
               if (b < b4)
                  b = b4;
               if (b < a)
                  av = b;
               working_space[j]=av;
            }
         }
         for (j = i; j < ssize - i; j++)
            working_space[ssize + j] = working_space[j];
         if (direction == kBackIncreasingWindow)
            i+=1;
         else if(direction == kBackDecreasingWindow)
            i-=1;
      }while((direction == kBackIncreasingWindow && i <= numberIterations) || (direction == kBackDecreasingWindow && i >= 1));
   }

   else if (filterOrder == kBackOrder6) {
      do{
         for (j = i; j < ssize - i; j++) {
            if (smoothing == kFALSE){
               a = working_space[ssize + j];
               b = (working_space[ssize + j - i] + working_space[ssize + j + i]) / 2.0;
               c = 0;
               ai = i / 2;
               c -= working_space[ssize + j - (int) (2 * ai)] / 6;
               c += 4 * working_space[ssize + j - (int) ai] / 6;
               c += 4 * working_space[ssize + j + (int) ai] / 6;
               c -= working_space[ssize + j + (int) (2 * ai)] / 6;
               d = 0;
               ai = i / 3;
               d += working_space[ssize + j - (int) (3 * ai)] / 20;
               d -= 6 * working_space[ssize + j - (int) (2 * ai)] / 20;
               d += 15 * working_space[ssize + j - (int) ai] / 20;
               d += 15 * working_space[ssize + j + (int) ai] / 20;
               d -= 6 * working_space[ssize + j + (int) (2 * ai)] / 20;
               d += working_space[ssize + j + (int) (3 * ai)] / 20;
               if (b < d)
                  b = d;
               if (b < c)
                  b = c;
               if (b < a)
                  a = b;
               working_space[j] = a;
            }

            else if (smoothing == kTRUE){
               a = working_space[ssize + j];
               av = 0;
               men = 0;
               for (w = j - bw; w <= j + bw; w++){
                  if ( w >= 0 && w < ssize){
                     av += working_space[ssize + w];
                     men +=1;
                  }
               }
               av = av / men;
               b = 0;
               men = 0;
               for (w = j - i - bw; w <= j - i + bw; w++){
                  if ( w >= 0 && w < ssize){
                     b += working_space[ssize + w];
                     men +=1;
                  }
               }
               b = b / men;
               c = 0;
               men = 0;
               for (w = j + i - bw; w <= j + i + bw; w++){
                  if ( w >= 0 && w < ssize){
                     c += working_space[ssize + w];
                     men +=1;
                  }
               }
               c = c / men;
               b = (b + c) / 2;
               ai = i / 2;
               b4 = 0, men = 0;
               for (w = j - (int)(2 * ai) - bw; w <= j - (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     b4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               b4 = b4 / men;
               c4 = 0, men = 0;
               for (w = j - (int)ai - bw; w <= j - (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     c4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               c4 = c4 / men;
               d4 = 0, men = 0;
               for (w = j + (int)ai - bw; w <= j + (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     d4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               d4 = d4 / men;
               e4 = 0, men = 0;
               for (w = j + (int)(2 * ai) - bw; w <= j + (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     e4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               e4 = e4 / men;
               b4 = (-b4 + 4 * c4 + 4 * d4 - e4) / 6;
               ai = i / 3;
               b6 = 0, men = 0;
               for (w = j - (int)(3 * ai) - bw; w <= j - (int)(3 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     b6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               b6 = b6 / men;
               c6 = 0, men = 0;
               for (w = j - (int)(2 * ai) - bw; w <= j - (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     c6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               c6 = c6 / men;
               d6 = 0, men = 0;
               for (w = j - (int)ai - bw; w <= j - (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     d6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               d6 = d6 / men;
               e6 = 0, men = 0;
               for (w = j + (int)ai - bw; w <= j + (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     e6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               e6 = e6 / men;
               f6 = 0, men = 0;
               for (w = j + (int)(2 * ai) - bw; w <= j + (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     f6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               f6 = f6 / men;
               g6 = 0, men = 0;
               for (w = j + (int)(3 * ai) - bw; w <= j + (int)(3 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     g6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               g6 = g6 / men;
               b6 = (b6 - 6 * c6 + 15 * d6 + 15 * e6 - 6 * f6 + g6) / 20;
               if (b < b6)
                  b = b6;
               if (b < b4)
                  b = b4;
               if (b < a)
                  av = b;
               working_space[j]=av;
            }
         }
         for (j = i; j < ssize - i; j++)
            working_space[ssize + j] = working_space[j];
         if (direction == kBackIncreasingWindow)
            i+=1;
         else if(direction == kBackDecreasingWindow)
            i-=1;
      }while((direction == kBackIncreasingWindow && i <= numberIterations) || (direction == kBackDecreasingWindow && i >= 1));
   }

   else if (filterOrder == kBackOrder8) {
      do{
         for (j = i; j < ssize - i; j++) {
            if (smoothing == kFALSE){
               a = working_space[ssize + j];
               b = (working_space[ssize + j - i] + working_space[ssize + j + i]) / 2.0;
               c = 0;
               ai = i / 2;
               c -= working_space[ssize + j - (int) (2 * ai)] / 6;
               c += 4 * working_space[ssize + j - (int) ai] / 6;
               c += 4 * working_space[ssize + j + (int) ai] / 6;
               c -= working_space[ssize + j + (int) (2 * ai)] / 6;
               d = 0;
               ai = i / 3;
               d += working_space[ssize + j - (int) (3 * ai)] / 20;
               d -= 6 * working_space[ssize + j - (int) (2 * ai)] / 20;
               d += 15 * working_space[ssize + j - (int) ai] / 20;
               d += 15 * working_space[ssize + j + (int) ai] / 20;
               d -= 6 * working_space[ssize + j + (int) (2 * ai)] / 20;
               d += working_space[ssize + j + (int) (3 * ai)] / 20;
               e = 0;
               ai = i / 4;
               e -= working_space[ssize + j - (int) (4 * ai)] / 70;
               e += 8 * working_space[ssize + j - (int) (3 * ai)] / 70;
               e -= 28 * working_space[ssize + j - (int) (2 * ai)] / 70;
               e += 56 * working_space[ssize + j - (int) ai] / 70;
               e += 56 * working_space[ssize + j + (int) ai] / 70;
               e -= 28 * working_space[ssize + j + (int) (2 * ai)] / 70;
               e += 8 * working_space[ssize + j + (int) (3 * ai)] / 70;
               e -= working_space[ssize + j + (int) (4 * ai)] / 70;
               if (b < e)
                  b = e;
               if (b < d)
                  b = d;
               if (b < c)
                  b = c;
               if (b < a)
                  a = b;
               working_space[j] = a;
            }

            else if (smoothing == kTRUE){
               a = working_space[ssize + j];
               av = 0;
               men = 0;
               for (w = j - bw; w <= j + bw; w++){
                  if ( w >= 0 && w < ssize){
                     av += working_space[ssize + w];
                     men +=1;
                  }
               }
               av = av / men;
               b = 0;
               men = 0;
               for (w = j - i - bw; w <= j - i + bw; w++){
                  if ( w >= 0 && w < ssize){
                     b += working_space[ssize + w];
                     men +=1;
                  }
               }
               b = b / men;
               c = 0;
               men = 0;
               for (w = j + i - bw; w <= j + i + bw; w++){
                  if ( w >= 0 && w < ssize){
                     c += working_space[ssize + w];
                     men +=1;
                  }
               }
               c = c / men;
               b = (b + c) / 2;
               ai = i / 2;
               b4 = 0, men = 0;
               for (w = j - (int)(2 * ai) - bw; w <= j - (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     b4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               b4 = b4 / men;
               c4 = 0, men = 0;
               for (w = j - (int)ai - bw; w <= j - (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     c4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               c4 = c4 / men;
               d4 = 0, men = 0;
               for (w = j + (int)ai - bw; w <= j + (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     d4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               d4 = d4 / men;
               e4 = 0, men = 0;
               for (w = j + (int)(2 * ai) - bw; w <= j + (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     e4 += working_space[ssize + w];
                     men +=1;
                  }
               }
               e4 = e4 / men;
               b4 = (-b4 + 4 * c4 + 4 * d4 - e4) / 6;
               ai = i / 3;
               b6 = 0, men = 0;
               for (w = j - (int)(3 * ai) - bw; w <= j - (int)(3 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     b6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               b6 = b6 / men;
               c6 = 0, men = 0;
               for (w = j - (int)(2 * ai) - bw; w <= j - (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     c6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               c6 = c6 / men;
               d6 = 0, men = 0;
               for (w = j - (int)ai - bw; w <= j - (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     d6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               d6 = d6 / men;
               e6 = 0, men = 0;
               for (w = j + (int)ai - bw; w <= j + (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     e6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               e6 = e6 / men;
               f6 = 0, men = 0;
               for (w = j + (int)(2 * ai) - bw; w <= j + (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     f6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               f6 = f6 / men;
               g6 = 0, men = 0;
               for (w = j + (int)(3 * ai) - bw; w <= j + (int)(3 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     g6 += working_space[ssize + w];
                     men +=1;
                  }
               }
               g6 = g6 / men;
               b6 = (b6 - 6 * c6 + 15 * d6 + 15 * e6 - 6 * f6 + g6) / 20;
               ai = i / 4;
               b8 = 0, men = 0;
               for (w = j - (int)(4 * ai) - bw; w <= j - (int)(4 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     b8 += working_space[ssize + w];
                     men +=1;
                  }
               }
               b8 = b8 / men;
               c8 = 0, men = 0;
               for (w = j - (int)(3 * ai) - bw; w <= j - (int)(3 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     c8 += working_space[ssize + w];
                     men +=1;
                  }
               }
               c8 = c8 / men;
               d8 = 0, men = 0;
               for (w = j - (int)(2 * ai) - bw; w <= j - (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     d8 += working_space[ssize + w];
                     men +=1;
                  }
               }
               d8 = d8 / men;
               e8 = 0, men = 0;
               for (w = j - (int)ai - bw; w <= j - (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     e8 += working_space[ssize + w];
                     men +=1;
                  }
               }
               e8 = e8 / men;
               f8 = 0, men = 0;
               for (w = j + (int)ai - bw; w <= j + (int)ai + bw; w++){
                  if (w >= 0 && w < ssize){
                     f8 += working_space[ssize + w];
                     men +=1;
                  }
               }
               f8 = f8 / men;
               g8 = 0, men = 0;
               for (w = j + (int)(2 * ai) - bw; w <= j + (int)(2 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     g8 += working_space[ssize + w];
                     men +=1;
                  }
               }
               g8 = g8 / men;
               h8 = 0, men = 0;
               for (w = j + (int)(3 * ai) - bw; w <= j + (int)(3 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     h8 += working_space[ssize + w];
                     men +=1;
                  }
               }
               h8 = h8 / men;
               i8 = 0, men = 0;
               for (w = j + (int)(4 * ai) - bw; w <= j + (int)(4 * ai) + bw; w++){
                  if (w >= 0 && w < ssize){
                     i8 += working_space[ssize + w];
                     men +=1;
                  }
               }
               i8 = i8 / men;
               b8 = ( -b8 + 8 * c8 - 28 * d8 + 56 * e8 - 56 * f8 - 28 * g8 + 8 * h8 - i8)/70;
               if (b < b8)
                  b = b8;
               if (b < b6)
                  b = b6;
               if (b < b4)
                  b = b4;
               if (b < a)
                  av = b;
               working_space[j]=av;
            }
         }
         for (j = i; j < ssize - i; j++)
            working_space[ssize + j] = working_space[j];
         if (direction == kBackIncreasingWindow)
            i += 1;
         else if(direction == kBackDecreasingWindow)
            i -= 1;
      }while((direction == kBackIncreasingWindow && i <= numberIterations) || (direction == kBackDecreasingWindow && i >= 1));
   }

   if (compton == kTRUE) {
      for (i = 0, b2 = 0; i < ssize; i++){
         b1 = b2;
         a = working_space[i], b = spectrum[i];
         j = i;
         if (TMath::Abs(a - b) >= 1) {
            b1 = i - 1;
            if (b1 < 0)
               b1 = 0;
            yb1 = working_space[b1];
            for (b2 = b1 + 1, c = 0, priz = 0; priz == 0 && b2 < ssize; b2++){
               a = working_space[b2], b = spectrum[b2];
               c = c + b - yb1;
               if (TMath::Abs(a - b) < 1) {
                  priz = 1;
                  yb2 = b;
               }
            }
            if (b2 == ssize)
               b2 -= 1;
            yb2 = working_space[b2];
            if (yb1 <= yb2){
               for (j = b1, c = 0; j <= b2; j++){
                  b = spectrum[j];
                  c = c + b - yb1;
               }
               if (c > 1){
                  c = (yb2 - yb1) / c;
                  for (j = b1, d = 0; j <= b2 && j < ssize; j++){
                     b = spectrum[j];
                     d = d + b - yb1;
                     a = c * d + yb1;
                     working_space[ssize + j] = a;
                  }
               }
            }

            else{
               for (j = b2, c = 0; j >= b1; j--){
                  b = spectrum[j];
                  c = c + b - yb2;
               }
               if (c > 1){
                  c = (yb1 - yb2) / c;
                  for (j = b2, d = 0;j >= b1 && j >= 0; j--){
                     b = spectrum[j];
                     d = d + b - yb2;
                     a = c * d + yb2;
                     working_space[ssize + j] = a;
                  }
               }
            }
            i=b2;
         }
      }
   }

   for (j = 0; j < ssize; j++)
      spectrum[j] = working_space[ssize + j];
   delete[]working_space;
   return 0;
}


//______________________________________________________________________________
const char* TSpectrum::SmoothMarkov(float *source, int ssize, int averWindow)
{
   /* Begin_Html
   <b>One-dimensional markov spectrum smoothing function</b>
   <p>
   This function calculates smoothed spectrum from source spectrum based on
   Markov chain method. The result is placed in the array pointed by source
   pointer. On successful completion it returns 0. On error it returns pointer
   to the string describing error.
   <p>
   Function parameters:
   <ul>
   <li> source: pointer to the array of source spectrum
   <li> ssize: length of source array
   <li> averWindow: width of averaging smoothing window
   </ul>
   The goal of this function is the suppression of the statistical fluctuations.
   The algorithm is based on discrete Markov chain, which has very simple
   invariant distribution:
   <img width=551 height=63 src="gif/TSpectrum_Smoothing1.gif">
   <p>
   <img width=28 height=36 src="gif/TSpectrum_Smoothing2.gif"> being defined
   from the normalization condition
   <img width=70 height=52 src="gif/TSpectrum_Smoothing3.gif">.
   n is the length of the smoothed spectrum and
   <img width=258 height=60 src="gif/TSpectrum_Smoothing4.gif">
   <p>
   Reference:
   <ol>
   <li> Z.K. Silagadze, A new algorithm for automatic photopeak searches.
   NIM A 376 (1996), 451.
   </ol>
   <p>
   Example 14 - script Smoothing.c
   <p>
   <img width=296 height=182 src="gif/TSpectrum_Smoothing1.jpg">
   Fig. 23 Original noisy spectrum
   <p>
   <img width=296 height=182 src="gif/TSpectrum_Smoothing2.jpg">
   Fig. 24 Smoothed spectrum m=3
   <p>
   <img width=299 height=184 src="gif/TSpectrum_Smoothing3.jpg">
   Fig. 25 Smoothed spectrum
   <p>
   <img width=299 height=184 src="gif/TSpectrum_Smoothing4.jpg">
   Fig.26 Smoothed spectrum m=10
   <p>
   Script:
   <pre>
   // Example to illustrate smoothing using Markov algorithm (class TSpectrum).
   // To execute this example, do
   // root > .x Smoothing.C

   void Smoothing() {
      Int_t i;
      Double_t nbins = 1024;
      Double_t xmin  = 0;
      Double_t xmax  = (Double_t)nbins;
      Float_t * source = new float[nbins];
      TH1F *h = new TH1F("h","Smoothed spectrum for m=3",nbins,xmin,xmax);
      TFile *f = new TFile("spectra\\TSpectrum.root");
      h=(TH1F*) f->Get("smooth1;1");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      TCanvas *Smooth1 = gROOT->GetListOfCanvases()->FindObject("Smooth1");
      if (!Smooth1) Smooth1 = new TCanvas("Smooth1","Smooth1",10,10,1000,700);
      TSpectrum *s = new TSpectrum();
      s->SmoothMarkov(source,1024,3);  //3, 7, 10
      for (i = 0; i < nbins; i++) h->SetBinContent(i + 1,source[i]);
      h->SetAxisRange(330,880);
      h->Draw("L");
   }
   </pre>
   End_Html */

   int xmin, xmax, i, l;
   float a, b, maxch;
   float nom, nip, nim, sp, sm, area = 0;
   if(averWindow <= 0)
      return "Averaging Window must be positive";
   float *working_space = new float[ssize];
   xmin = 0,xmax = ssize - 1;
   for(i = 0, maxch = 0; i < ssize; i++){
      working_space[i]=0;
      if(maxch < source[i])
         maxch = source[i];

      area += source[i];
   }
   if(maxch == 0) {
      delete [] working_space;
      return 0 ;
   }

   nom = 1;
   working_space[xmin] = 1;
   for(i = xmin; i < xmax; i++){
      nip = source[i] / maxch;
      nim = source[i + 1] / maxch;
      sp = 0,sm = 0;
      for(l = 1; l <= averWindow; l++){
         if((i + l) > xmax)
            a = source[xmax] / maxch;

         else
            a = source[i + l] / maxch;
         b = a - nip;
         if(a + nip <= 0)
            a = 1;

         else
            a = TMath::Sqrt(a + nip);
         b = b / a;
         b = TMath::Exp(b);
         sp = sp + b;
         if((i - l + 1) < xmin)
            a = source[xmin] / maxch;

         else
            a = source[i - l + 1] / maxch;
         b = a - nim;
         if(a + nim <= 0)
            a = 1;
         else
            a = TMath::Sqrt(a + nim);
         b = b / a;
         b = TMath::Exp(b);
         sm = sm + b;
      }
      a = sp / sm;
      a = working_space[i + 1] = working_space[i] * a;
      nom = nom + a;
   }
   for(i = xmin; i <= xmax; i++){
      working_space[i] = working_space[i] / nom;
   }
   for(i = 0; i < ssize; i++)
      source[i] = working_space[i] * area;
   delete[]working_space;
   return 0;
}


//______________________________________________________________________________
const char *TSpectrum::Deconvolution(float *source, const float *response,
                                      int ssize, int numberIterations,
                                      int numberRepetitions, double boost )
{
   /* Begin_Html
   <b>One-dimensional deconvolution function</b>
   <p>
   This function calculates deconvolution from source spectrum according to
   response spectrum using Gold deconvolution algorithm. The result is placed
   in the vector pointed by source pointer. On successful completion it
   returns 0. On error it returns pointer to the string describing error. If
   desired after every numberIterations one can apply boosting operation
   (exponential function with exponent given by boost coefficient) and repeat
   it numberRepetitions times.
   <p>
   Function parameters:
   <ul>
   <li>source:  pointer to the vector of source spectrum
   <li>response:     pointer to the vector of response spectrum
   <li>ssize:    length of source and response spectra
   numberIterations, for details we refer to the reference given below
   numberRepetitions, for repeated boosted deconvolution
   boost, boosting coefficient
   </ul>
   The goal of this function is the improvement of the resolution in spectra,
   decomposition of multiplets. The mathematical formulation of
   the convolution system is:
   <p>
   <img width=585 height=84 src="gif/TSpectrum_Deconvolution1.gif">
   <p>
   where h(i) is the impulse response function, x, y are input and output
   vectors, respectively, N is the length of x and h vectors. In matrix form
   we have:
   <p>
   <img width=597 height=360 src="gif/TSpectrum_Deconvolution2.gif">
   <p>
   Let us assume that we know the response and the output vector (spectrum) of
   the above given system. The deconvolution represents solution of the
   overdetermined system of linear equations, i.e., the calculation of the
   vector <b>x</b>. From numerical stability point of view the operation of
   deconvolution is extremely critical (ill-posed problem) as well as time
   consuming operation. The Gold deconvolution algorithm proves to work very
   well, other methods (Fourier, VanCittert etc) oscillate. It is suitable to
   process positive definite data (e.g. histograms).
   <p>
   <b>Gold deconvolution algorithm:</b>
   <p>
   <img width=551 height=233 src="gif/TSpectrum_Deconvolution3.gif">
   <p>
   Where L is given number of iterations (numberIterations parameter).
   <p>
   <b>Boosted deconvolution:</b>
   <ol>
   <li> Set the initial solution:
        End_Html Begin_Latex x^{(0)} = [1,1,...,1]^{T} End_Latex Begin_Html
   <li> Set required number of repetitions R and iterations L.
   <li> Set r = 1.
   <li>Using Gold deconvolution algorithm for k=1,2,...,L find
       End_Html Begin_Latex x^{(L)} End_Latex Begin_Html
   <li> If r = R stop calculation, else
      <ol>
      <li> Apply boosting operation, i.e., set
           End_Html Begin_Latex x^{(0)}(i) = [x^{(L)}(i)]^{p} End_Latex Begin_Html
           i=0,1,...N-1 and p is boosting coefficient &gt;0.
      <li> r = r + 1
      <li> continue in 4.
      </ol>
   </ol>
   <p>
   <b>References:</b>
   <ol>
   <li> Gold R., ANL-6984, Argonne National Laboratories, Argonne Ill, 1964.
   <li> Coote G.E., Iterative smoothing and deconvolution of one- and two-dimensional
        elemental distribution data, NIM B 130 (1997) 118.
   <li> M. Morhá&#269;, J. Kliman, V.  Matoušek, M. Veselský,
        I. Turzo: Efficient one- and two-dimensional Gold deconvolution and
        its application to gamma-ray spectra decomposition. NIM, A401 (1997) 385-408.
   <li> Morhá&#269; M., Matoušek V., Kliman J., Efficient algorithm of multidimensional
        deconvolution and its application to nuclear data processing, Digital Signal
        Processing 13 (2003) 144.
   </ol>
   <p>
   <i>Example 8 - script Deconvolution.c :</i>
   <p>
   response function (usually peak) should be shifted left to the first
   non-zero channel (bin) (see Figure 9)
   <p>
   <img width=600 height=340 src="gif/TSpectrum_Deconvolution1.jpg">
   <p>
   Figure 9 Response spectrum.
   <p>
   <img width=946 height=407 src="gif/TSpectrum_Deconvolution2.jpg">
   <p>
   Figure 10 Principle how the response matrix is composed inside of the
   Deconvolution function.
   <img width=601 height=407 src="gif/TSpectrum_Deconvolution3.jpg">
   <p>
   Figure 11 Example of Gold deconvolution. The original source spectrum is
   drawn with black color, the spectrum after the deconvolution (10000
   iterations) with red color.
   <p>
   Script:
   <p>
   <pre>
   // Example to illustrate deconvolution function (class TSpectrum).
   // To execute this example, do
   // root > .x Deconvolution.C

   #include <TSpectrum>

   void Deconvolution() {
      Int_t i;
      Double_t nbins = 256;
      Double_t xmin  = 0;
      Double_t xmax  = (Double_t)nbins;
      Float_t * source = new float[nbins];
      Float_t * response = new float[nbins];
      TH1F *h = new TH1F("h","Deconvolution",nbins,xmin,xmax);
      TH1F *d = new TH1F("d","",nbins,xmin,xmax);
      TFile *f = new TFile("spectra\\TSpectrum.root");
      h=(TH1F*) f->Get("decon1;1");
      TFile *fr = new TFile("spectra\\TSpectrum.root");
      d=(TH1F*) fr->Get("decon_response;1");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      for (i = 0; i < nbins; i++) response[i]=d->GetBinContent(i + 1);
      TCanvas *Decon1 = gROOT->GetListOfCanvases()->FindObject("Decon1");
      if (!Decon1) Decon1 = new TCanvas("Decon1","Decon1",10,10,1000,700);
      h->Draw("L");
      TSpectrum *s = new TSpectrum();
      s->Deconvolution(source,response,256,1000,1,1);
      for (i = 0; i < nbins; i++) d->SetBinContent(i + 1,source[i]);
      d->SetLineColor(kRed);
      d->Draw("SAME L");
   }
   </pre>
   <p>
   <b>Examples of Gold deconvolution method:</b>
   <p>
   First let us study the influence of the number of iterations on the
   deconvolved spectrum (Figure 12).
   <p>
   <img width=602 height=409 src="gif/TSpectrum_Deconvolution_wide1.jpg">
   <p>
   Figure 12 Study of Gold deconvolution algorithm.The original source spectrum
   is drawn with black color, spectrum after 100 iterations with red color,
   spectrum after 1000 iterations with blue color, spectrum after 10000
   iterations with green color and spectrum after 100000 iterations with
   magenta color.
   <p>
   For relatively narrow peaks in the above given example the Gold
   deconvolution method is able to decompose overlapping peaks practically to
   delta - functions. In the next example we have chosen a synthetic data
   (spectrum, 256 channels) consisting of 5 very closely positioned, relatively
   wide peaks (sigma =5), with added noise (Figure 13). Thin lines represent
   pure Gaussians (see Table 1); thick line is a resulting spectrum with
   additive noise (10% of the amplitude of small peaks).
   <p>
   <img width=600 height=367 src="gif/TSpectrum_Deconvolution_wide2.jpg">
   <p>
   Figure 13 Testing example of synthetic spectrum composed of 5 Gaussians with
   added noise.
   <p>
   <table border=solid><tr>
   <td> Peak # </td><td> Position </td><td> Height </td><td> Area   </td>
   </tr><tr>
   <td> 1      </td><td> 50       </td><td> 500    </td><td> 10159  </td>
   </tr><tr>
   <td> 2      </td><td> 70       </td><td> 3000   </td><td> 60957  </td>
   </tr><tr>
   <td> 3      </td><td> 80       </td><td> 1000   </td><td> 20319  </td>
   </tr><tr>
   <td> 4      </td><td> 100      </td><td> 5000   </td><td> 101596 </td>
   </tr><tr>
   <td> 5      </td><td> 110      </td><td> 500    </td><td> 10159  </td>
   </tr></table>
   <p>
   Table 1 Positions, heights and areas of peaks in the spectrum shown in
   Figure 13.
   <p>
   In ideal case, we should obtain the result given in Figure 14. The areas of
   the Gaussian components of the spectrum are concentrated completely to
   delta-functions. When solving the overdetermined system of linear equations
   with data from Figure 13 in the sense of minimum least squares criterion
   without any regularization we obtain the result with large oscillations
   (Figure 15). From mathematical point of view, it is the optimal solution in
   the unconstrained space of independent variables. From physical point of
   view we are interested only in a meaningful solution. Therefore, we have to
   employ regularization techniques (e.g. Gold deconvolution) and/or to
   confine the space of allowed solutions to subspace of positive solutions.
   <p>
   <img width=589 height=189 src="gif/TSpectrum_Deconvolution_wide3.jpg">
   <p>
   Figure 14 The same spectrum like in Figure 13, outlined bars show the
   contents of present components (peaks).
   <img width=585 height=183 src="gif/TSpectrum_Deconvolution_wide4.jpg">
   <p>
   Figure 15 Least squares solution of the system of linear equations without
   regularization.
   <p>
   <i>Example 9 - script Deconvolution_wide.c</i>
   <p>
   When we employ Gold deconvolution algorithm we obtain the result given in
   Fig. 16. One can observe that the resulting spectrum is smooth. On the
   other hand the method is not able to decompose completely the peaks in the
   spectrum.
   <p>
   <img width=601 height=407 src="gif/TSpectrum_Deconvolution_wide5.jpg">
   Figure 16 Example of Gold deconvolution for closely positioned wide peaks.
   The original source spectrum is drawn with black color, the spectrum after
   the deconvolution (10000 iterations) with red color.
   <p>
   Script:
   <p>
   <pre>
   // Example to illustrate deconvolution function (class TSpectrum).
   // To execute this example, do
   // root > .x Deconvolution_wide.C

   #include <TSpectrum>

   void Deconvolution_wide() {
      Int_t i;
      Double_t nbins = 256;
      Double_t xmin  = 0;
      Double_t xmax  = (Double_t)nbins;
      Float_t * source = new float[nbins];
      Float_t * response = new float[nbins];
      TH1F *h = new TH1F("h","Deconvolution",nbins,xmin,xmax);
      TH1F *d = new TH1F("d","",nbins,xmin,xmax);
      TFile *f = new TFile("spectra\\TSpectrum.root");
      h=(TH1F*) f->Get("decon3;1");
      TFile *fr = new TFile("spectra\\TSpectrum.root");
      d=(TH1F*) fr->Get("decon_response_wide;1");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      for (i = 0; i < nbins; i++) response[i]=d->GetBinContent(i + 1);
      TCanvas *Decon1 = gROOT->GetListOfCanvases()->FindObject("Decon1");
      if (!Decon1) Decon1 = new TCanvas("Decon1",
      "Deconvolution of closely positioned overlapping peaks using Gold deconvolution method",10,10,1000,700);
      h->SetMaximum(30000);
      h->Draw("L");
      TSpectrum *s = new TSpectrum();
      s->Deconvolution(source,response,256,10000,1,1);
      for (i = 0; i < nbins; i++) d->SetBinContent(i + 1,source[i]);
      d->SetLineColor(kRed);
      d->Draw("SAME L");
   }
   </pre>
   <p>
   <i>Example 10 - script Deconvolution_wide_boost.c :</i>
   <p>
   Further let us employ boosting operation into deconvolution (Fig. 17).
   <p>
   <img width=601 height=407 src="gif/TSpectrum_Deconvolution_wide6.jpg">
   <p>
   Figure 17 The original source spectrum is drawn with black color, the
   spectrum after the deconvolution with red color. Number of iterations = 200,
   number of repetitions = 50 and boosting coefficient = 1.2.
   <p>
   <table border=solid><tr>
   <td> Peak # </td> <td> Original/Estimated (max) position </td> <td> Original/Estimated area </td>
   </tr> <tr>
   <td> 1 </td> <td> 50/49 </td> <td> 10159/10419 </td>
   </tr> <tr>
   <td> 2 </td> <td> 70/70 </td> <td> 60957/58933 </td>
   </tr> <tr>
   <td> 3 </td> <td> 80/79 </td> <td> 20319/19935 </td>
   </tr> <tr>
   <td> 4 </td> <td> 100/100 </td> <td> 101596/105413 </td>
   </tr> <tr>
   <td> 5 </td> <td> 110/117 </td> <td> 10159/6676 </td>
   </tr> </table>
   <p>
   Table 2 Results of the estimation of peaks in spectrum shown in Figure 17.
   <p>
   One can observe that peaks are decomposed practically to delta functions.
   Number of peaks is correct, positions of big peaks as well as their areas
   are relatively well estimated. However there is a considerable error in
   the estimation of the position of small right hand peak.
   <p>
   Script:
   <p>
   <pre>
   // Example to illustrate deconvolution function (class TSpectrum).
   // To execute this example, do
   // root > .x Deconvolution_wide_boost.C

   #include <TSpectrum>

   void Deconvolution_wide_boost() {
      Int_t i;
      Double_t nbins = 256;
      Double_t xmin  = 0;
      Double_t xmax  = (Double_t)nbins;
      Float_t * source = new float[nbins];
      Float_t * response = new float[nbins];
      TH1F *h = new TH1F("h","Deconvolution",nbins,xmin,xmax);
      TH1F *d = new TH1F("d","",nbins,xmin,xmax);
      TFile *f = new TFile("spectra\\TSpectrum.root");
      h=(TH1F*) f->Get("decon3;1");
      TFile *fr = new TFile("spectra\\TSpectrum.root");
      d=(TH1F*) fr->Get("decon_response_wide;1");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      for (i = 0; i < nbins; i++) response[i]=d->GetBinContent(i + 1);
      TCanvas *Decon1 = gROOT->GetListOfCanvases()->FindObject("Decon1");
      if (!Decon1) Decon1 = new TCanvas("Decon1",
      "Deconvolution of closely positioned overlapping peaks using boosted Gold deconvolution method",10,10,1000,700);
      h->SetMaximum(110000);
      h->Draw("L");
      TSpectrum *s = new TSpectrum();
      s->Deconvolution(source,response,256,200,50,1.2);
      for (i = 0; i < nbins; i++) d->SetBinContent(i + 1,source[i]);
      d->SetLineColor(kRed);
      d->Draw("SAME L");
   }
   </pre>
   End_Html */

   if (ssize <= 0)
      return "Wrong Parameters";

   if (numberRepetitions <= 0)
      return "Wrong Parameters";

       //   working_space-pointer to the working vector
       //   (its size must be 4*ssize of source spectrum)
   double *working_space = new double[4 * ssize];
   int i, j, k, lindex, posit, lh_gold, l, repet;
   double lda, ldb, ldc, area, maximum;
   area = 0;
   lh_gold = -1;
   posit = 0;
   maximum = 0;

//read response vector
   for (i = 0; i < ssize; i++) {
      lda = response[i];
      if (lda != 0)
         lh_gold = i + 1;
      working_space[i] = lda;
      area += lda;
      if (lda > maximum) {
         maximum = lda;
         posit = i;
      }
   }
   if (lh_gold == -1) {
      delete [] working_space;
      return "ZERO RESPONSE VECTOR";
   }

//read source vector
   for (i = 0; i < ssize; i++)
      working_space[2 * ssize + i] = source[i];

// create matrix at*a and vector at*y
   for (i = 0; i < ssize; i++){
      lda = 0;
      for (j = 0; j < ssize; j++){
         ldb = working_space[j];
         k = i + j;
         if (k < ssize){
            ldc = working_space[k];
            lda = lda + ldb * ldc;
         }
      }
      working_space[ssize + i] = lda;
      lda = 0;
      for (k = 0; k < ssize; k++){
         l = k - i;
         if (l >= 0){
            ldb = working_space[l];
            ldc = working_space[2 * ssize + k];
            lda = lda + ldb * ldc;
         }
      }
      working_space[3 * ssize + i]=lda;
   }

// move vector at*y
   for (i = 0; i < ssize; i++){
      working_space[2 * ssize + i] = working_space[3 * ssize + i];
   }

//initialization of resulting vector
   for (i = 0; i < ssize; i++)
      working_space[i] = 1;

       //**START OF ITERATIONS**
   for (repet = 0; repet < numberRepetitions; repet++) {
      if (repet != 0) {
         for (i = 0; i < ssize; i++)
            working_space[i] = TMath::Power(working_space[i], boost);
      }
      for (lindex = 0; lindex < numberIterations; lindex++) {
         for (i = 0; i < ssize; i++) {
            if (working_space[2 * ssize + i] > 0.000001
                 && working_space[i] > 0.000001) {
               lda = 0;
               for (j = 0; j < lh_gold; j++) {
                  ldb = working_space[j + ssize];
                  if (j != 0){
                     k = i + j;
                     ldc = 0;
                     if (k < ssize)
                        ldc = working_space[k];
                     k = i - j;
                     if (k >= 0)
                        ldc += working_space[k];
                  }

                  else
                     ldc = working_space[i];
                  lda = lda + ldb * ldc;
               }
               ldb = working_space[2 * ssize + i];
               if (lda != 0)
                  lda = ldb / lda;

               else
                  lda = 0;
               ldb = working_space[i];
               lda = lda * ldb;
               working_space[3 * ssize + i] = lda;
            }
         }
         for (i = 0; i < ssize; i++)
            working_space[i] = working_space[3 * ssize + i];
      }
   }

//shift resulting spectrum
   for (i = 0; i < ssize; i++) {
      lda = working_space[i];
      j = i + posit;
      j = j % ssize;
      working_space[ssize + j] = lda;
   }

//write back resulting spectrum
   for (i = 0; i < ssize; i++)
      source[i] = area * working_space[ssize + i];
   delete[]working_space;
   return 0;
}


//______________________________________________________________________________
const char *TSpectrum::DeconvolutionRL(float *source, const float *response,
                                      int ssize, int numberIterations,
                                      int numberRepetitions, double boost )
{
   /* Begin_Html
   <b>One-dimensional deconvolution function.</b>
   <p>
   This function calculates deconvolution from source spectrum according to
   response spectrum using Richardson-Lucy deconvolution algorithm. The result
   is placed in the vector pointed by source pointer. On successful completion
   it returns 0. On error it returns pointer to the string describing error.
   If desired after every numberIterations one can apply boosting operation
   (exponential function with exponent given by boost coefficient) and repeat
   it numberRepetitions times (see Gold deconvolution).
   <p>
   Function parameters:
   <ul>
   <li> source:  pointer to the vector of source spectrum
   <li> response:     pointer to the vector of response spectrum
   <li> ssize:    length of source and response spectra
   numberIterations, for details we refer to the reference given above
   numberRepetitions, for repeated boosted deconvolution
   boost, boosting coefficient
   </ul>
   <p>
   <b>Richardson-Lucy deconvolution algorithm:</b>
   <p>
   For discrete systems it has the form:
   <p>
   <img width=438 height=98 src="gif/TSpectrum_DeconvolutionRL1.gif">
   <p>
   <img width=124 height=39 src="gif/TSpectrum_DeconvolutionRL2.gif">
   <p>
   for positive input data and response matrix this iterative method forces
   the deconvoluted spectra to be non-negative. The Richardson-Lucy
   iteration converges to the maximum likelihood solution for Poisson statistics
   in the data.
   <p>
   <b>References:</b>
   <ol>
   <li> Abreu M.C. et al., A four-dimensional deconvolution method to correct NA38
   experimental data, NIM A 405 (1998) 139.
   <li> Lucy L.B., A.J. 79 (1974) 745.
   <li> Richardson W.H., J. Opt. Soc. Am. 62 (1972) 55.
   </ol>
   <p>
   <b>Examples of Richardson-Lucy deconvolution method:</b>
   <p>
   <i>Example 11 - script DeconvolutionRL_wide.c :</i>
   <p>
   When we employ Richardson-Lucy deconvolution algorithm to our data from
   Fig. 13 we obtain the result given in Fig. 18. One can observe improvements
   as compared to the result achieved by Gold deconvolution. Neverthless it is
   unable to decompose the multiplet.
   <p>
   <img width=601 height=407 src="gif/TSpectrum_DeconvolutionRL_wide1.jpg">
   Figure 18 Example of Richardson-Lucy deconvolution for closely positioned
   wide peaks. The original source spectrum is drawn with black color, the
   spectrum after the deconvolution (10000 iterations) with red color.
   <p>
   Script:
   <p>
   <pre>
   // Example to illustrate deconvolution function (class TSpectrum).
   // To execute this example, do
   // root > .x DeconvolutionRL_wide.C

   #include <TSpectrum>

   void DeconvolutionRL_wide() {
      Int_t i;
      Double_t nbins = 256;
      Double_t xmin  = 0;
      Double_t xmax  = (Double_t)nbins;
      Float_t * source = new float[nbins];
      Float_t * response = new float[nbins];
      TH1F *h = new TH1F("h","Deconvolution",nbins,xmin,xmax);
      TH1F *d = new TH1F("d","",nbins,xmin,xmax);
      TFile *f = new TFile("spectra\\TSpectrum.root");
      h=(TH1F*) f->Get("decon3;1");
      TFile *fr = new TFile("spectra\\TSpectrum.root");
      d=(TH1F*) fr->Get("decon_response_wide;1");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      for (i = 0; i < nbins; i++) response[i]=d->GetBinContent(i + 1);
      TCanvas *Decon1 = gROOT->GetListOfCanvases()->FindObject("Decon1");
      if (!Decon1) Decon1 = new TCanvas("Decon1",
      "Deconvolution of closely positioned overlapping peaks using Richardson-Lucy deconvolution method",
      10,10,1000,700);
      h->SetMaximum(30000);
      h->Draw("L");
      TSpectrum *s = new TSpectrum();
      s->DeconvolutionRL(source,response,256,10000,1,1);
      for (i = 0; i < nbins; i++) d->SetBinContent(i + 1,source[i]);
      d->SetLineColor(kRed);
      d->Draw("SAME L");
   }
   </pre>
   <p>
   <i>Example 12 - script DeconvolutionRL_wide_boost.c :</i>
   <p>
   Further let us employ boosting operation into deconvolution (Fig. 19).
   <img width=601 height=407 src="gif/TSpectrum_DeconvolutionRL_wide2.jpg">
   <p>
   Figure 19 The original source spectrum is drawn with black color, the
   spectrum after the deconvolution with red color. Number of iterations = 200,
   number of repetitions = 50 and boosting coefficient = 1.2.
   <p>
   <table border=solid>
   <tr><td> Peak # </td><td> Original/Estimated (max) position </td><td> Original/Estimated area </td></tr>
   <tr><td> 1 </td><td> 50/51 </td><td> 10159/11426 </td></tr>
   <tr><td> 2 </td><td> 70/71 </td><td> 60957/65003 </td></tr>
   <tr><td> 3 </td><td> 80/81 </td><td> 20319/12813 </td></tr>
   <tr><td> 4 </td><td> 100/100 </td><td> 101596/101851 </td></tr>
   <tr><td> 5 </td><td> 110/111 </td><td> 10159/8920 </td></tr>
   </table>
   <p>
   Table 3 Results of the estimation of peaks in spectrum shown in Figure 19.
   <p>
   One can observe improvements in the estimation of peak positions as compared
   to the results achieved by Gold deconvolution.
   <p>
   Script:
   <pre>
   // Example to illustrate deconvolution function (class TSpectrum).
   // To execute this example, do
   // root > .x DeconvolutionRL_wide_boost.C

   #include <TSpectrum>

   void DeconvolutionRL_wide_boost() {
      Int_t i;
      Double_t nbins = 256;
      Double_t xmin  = 0;
      Double_t xmax  = (Double_t)nbins;
      Float_t * source = new float[nbins];
      Float_t * response = new float[nbins];
      TH1F *h = new TH1F("h","Deconvolution",nbins,xmin,xmax);
      TH1F *d = new TH1F("d","",nbins,xmin,xmax);
      TFile *f = new TFile("spectra\\TSpectrum.root");
      h=(TH1F*) f->Get("decon3;1");
      TFile *fr = new TFile("spectra\\TSpectrum.root");
      d=(TH1F*) fr->Get("decon_response_wide;1");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      for (i = 0; i < nbins; i++) response[i]=d->GetBinContent(i + 1);
      TCanvas *Decon1 = gROOT->GetListOfCanvases()->FindObject("Decon1");
      if (!Decon1) Decon1 = new TCanvas("Decon1",
      "Deconvolution of closely positioned overlapping peaks using boosted Richardson-Lucy deconvolution method",
      10,10,1000,700);
      h->SetMaximum(110000);
      h->Draw("L");
      TSpectrum *s = new TSpectrum();
      s->DeconvolutionRL(source,response,256,200,50,1.2);
      for (i = 0; i < nbins; i++) d->SetBinContent(i + 1,source[i]);
      d->SetLineColor(kRed);
      d->Draw("SAME L");
   }
   </pre>
   End_Html */

   if (ssize <= 0)
      return "Wrong Parameters";

   if (numberRepetitions <= 0)
      return "Wrong Parameters";

       //   working_space-pointer to the working vector
       //   (its size must be 4*ssize of source spectrum)
   double *working_space = new double[4 * ssize];
   int i, j, k, lindex, posit, lh_gold, repet, kmin, kmax;
   double lda, ldb, ldc, maximum;
   lh_gold = -1;
   posit = 0;
   maximum = 0;

//read response vector
   for (i = 0; i < ssize; i++) {
      lda = response[i];
      if (lda != 0)
         lh_gold = i + 1;
      working_space[ssize + i] = lda;
      if (lda > maximum) {
         maximum = lda;
         posit = i;
      }
   }
   if (lh_gold == -1) {
      delete [] working_space;
      return "ZERO RESPONSE VECTOR";
   }

//read source vector
   for (i = 0; i < ssize; i++)
      working_space[2 * ssize + i] = source[i];

//initialization of resulting vector
   for (i = 0; i < ssize; i++){
      if (i <= ssize - lh_gold)
         working_space[i] = 1;

      else
         working_space[i] = 0;

   }
       //**START OF ITERATIONS**
   for (repet = 0; repet < numberRepetitions; repet++) {
      if (repet != 0) {
         for (i = 0; i < ssize; i++)
            working_space[i] = TMath::Power(working_space[i], boost);
      }
      for (lindex = 0; lindex < numberIterations; lindex++) {
         for (i = 0; i <= ssize - lh_gold; i++){
            lda = 0;
            if (working_space[i] > 0){//x[i]
               for (j = i; j < i + lh_gold; j++){
                  ldb = working_space[2 * ssize + j];//y[j]
                  if (j < ssize){
                     if (ldb > 0){//y[j]
                        kmax = j;
                        if (kmax > lh_gold - 1)
                           kmax = lh_gold - 1;
                        kmin = j + lh_gold - ssize;
                        if (kmin < 0)
                           kmin = 0;
                        ldc = 0;
                        for (k = kmax; k >= kmin; k--){
                           ldc += working_space[ssize + k] * working_space[j - k];//h[k]*x[j-k]
                        }
                        if (ldc > 0)
                           ldb = ldb / ldc;

                        else
                           ldb = 0;
                     }
                     ldb = ldb * working_space[ssize + j - i];//y[j]*h[j-i]/suma(h[j][k]x[k])
                  }
                  lda += ldb;
               }
               lda = lda * working_space[i];
            }
            working_space[3 * ssize + i] = lda;
         }
         for (i = 0; i < ssize; i++)
            working_space[i] = working_space[3 * ssize + i];
      }
   }

//shift resulting spectrum
   for (i = 0; i < ssize; i++) {
      lda = working_space[i];
      j = i + posit;
      j = j % ssize;
      working_space[ssize + j] = lda;
   }

//write back resulting spectrum
   for (i = 0; i < ssize; i++)
      source[i] = working_space[ssize + i];
   delete[]working_space;
   return 0;
}


//______________________________________________________________________________
const char *TSpectrum::Unfolding(float *source,
                                 const float **respMatrix,
                                 int ssizex, int ssizey,
                                 int numberIterations,
                                 int numberRepetitions, double boost)
{
   /* Begin_Html
   <b>One-dimensional unfolding function</b>
   <p>
   This function unfolds source spectrum according to response matrix columns.
   The result is placed in the vector pointed by source pointer.
   The coefficients of the resulting vector represent contents of the columns
   (weights) in the input vector. On successful completion it returns 0. On
   error it returns pointer to the string describing error. If desired after
   every numberIterations one can apply boosting operation (exponential
   function with exponent given by boost coefficient) and repeat it
   numberRepetitions times. For details we refer to [1].
   <p>
   Function parameters:
   <ul>
   <li> source: pointer to the vector of source spectrum
   <li> respMatrix: pointer to the matrix of response spectra
   <li> ssizex: length of source spectrum and # of columns of the response
        matrix. ssizex must be >= ssizey.
   <li> ssizey: length of destination spectrum and # of rows of the response
        matrix.
   <li> numberIterations: number of iterations
   <li> numberRepetitions: number of repetitions for boosted deconvolution.
        It must be greater or equal to one.
   <li> boost: boosting coefficient, applies only if numberRepetitions is
        greater than one.
   </ul>
   <p>
   <b>Unfolding:</b>
   <p>
   The goal is the decomposition of spectrum to a given set of component
   spectra.
   <p>
   The mathematical formulation of the discrete linear system is:
   <p>
   <img width=588 height=89 src="gif/TSpectrum_Unfolding1.gif">
   <p>
   <img width=597 height=228 src="gif/TSpectrum_Unfolding2.gif">
   <p>
   <b>References:</b>
   <ol>
   <li> Jandel M., Morhá&#269; M., Kliman J., Krupa L., Matoušek
   V., Hamilton J. H., Ramaya A. V.:
   Decomposition of continuum gamma-ray spectra using synthetized response matrix.
   NIM A 516 (2004), 172-183.
   </ol>
   <p>
   <b>Example of unfolding:</b>
   <p>
   <i>Example 13 - script Unfolding.c:</i>
   <p>
   <img width=442 height=648 src="gif/TSpectrum_Unfolding3.gif">
   <p>
   Fig. 20 Response matrix composed of neutron spectra of pure
   chemical elements.
   <img width=604 height=372 src="gif/TSpectrum_Unfolding2.jpg">
   <p>
   Fig. 21 Source neutron spectrum to be decomposed
   <P>
   <img width=600 height=360 src="gif/TSpectrum_Unfolding3.jpg">
   <p>
   Fig. 22 Spectrum after decomposition, contains 10 coefficients, which
   correspond to contents of chemical components (dominant 8-th and 10-th
   components, i.e. O, Si)
   <p>
   Script:
   <pre>
   // Example to illustrate unfolding function (class TSpectrum).
   // To execute this example, do
   // root > .x Unfolding.C

   #include <TSpectrum>

   void Unfolding() {
      Int_t i, j;
      Int_t nbinsx = 2048;
      Int_t nbinsy = 10;
      Double_t xmin  = 0;
      Double_t xmax  = (Double_t)nbinsx;
      Double_t ymin  = 0;
      Double_t ymax  = (Double_t)nbinsy;
      Float_t * source = new float[nbinsx];
      Float_t ** response = new float *[nbinsy];
      for (i=0;i<nbinsy;i++) response[i]=new float[nbinsx];
      TH1F *h = new TH1F("h","",nbinsx,xmin,xmax);
      TH1F *d = new TH1F("d","Decomposition - unfolding",nbinsx,xmin,xmax);
      TH2F *decon_unf_resp = new TH2F("decon_unf_resp","Root File",nbinsy,ymin,ymax,nbinsx,xmin,xmax);
      TFile *f = new TFile("spectra\\TSpectrum.root");
      h=(TH1F*) f->Get("decon_unf_in;1");
      TFile *fr = new TFile("spectra\\TSpectrum.root");
      decon_unf_resp = (TH2F*) fr->Get("decon_unf_resp;1");
      for (i = 0; i < nbinsx; i++) source[i] = h->GetBinContent(i + 1);
      for (i = 0; i < nbinsy; i++){
         for (j = 0; j< nbinsx; j++){
            response[i][j] = decon_unf_resp->GetBinContent(i + 1, j + 1);
         }
      }
      TCanvas *Decon1 = gROOT->GetListOfCanvases()->FindObject("Decon1");
      if (!Decon1) Decon1 = new TCanvas("Decon1","Decon1",10,10,1000,700);
      h->Draw("L");
      TSpectrum *s = new TSpectrum();
      s->Unfolding(source,response,nbinsx,nbinsy,1000,1,1);
      for (i = 0; i < nbinsy; i++) d->SetBinContent(i + 1,source[i]);
      d->SetLineColor(kRed);
      d->SetAxisRange(0,nbinsy);
      d->Draw("");
   }
   </pre>
   End_Html */

   int i, j, k, lindex, lhx = 0, repet;
   double lda, ldb, ldc, area;
   if (ssizex <= 0 || ssizey <= 0)
      return "Wrong Parameters";
   if (ssizex < ssizey)
      return "Sizex must be greater than sizey)";
   if (numberIterations <= 0)
      return "Number of iterations must be positive";
   double *working_space =
       new double[ssizex * ssizey + 2 * ssizey * ssizey + 4 * ssizex];

/*read response matrix*/
   for (j = 0; j < ssizey && lhx != -1; j++) {
      area = 0;
      lhx = -1;
      for (i = 0; i < ssizex; i++) {
         lda = respMatrix[j][i];
         if (lda != 0) {
            lhx = i + 1;
         }
         working_space[j * ssizex + i] = lda;
         area = area + lda;
      }
      if (lhx != -1) {
         for (i = 0; i < ssizex; i++)
            working_space[j * ssizex + i] /= area;
      }
   }
   if (lhx == -1) {
      delete [] working_space;
      return ("ZERO COLUMN IN RESPONSE MATRIX");
   }

/*read source vector*/
   for (i = 0; i < ssizex; i++)
      working_space[ssizex * ssizey + 2 * ssizey * ssizey + 2 * ssizex + i] =
          source[i];

/*create matrix at*a + at*y */
   for (i = 0; i < ssizey; i++) {
      for (j = 0; j < ssizey; j++) {
         lda = 0;
         for (k = 0; k < ssizex; k++) {
            ldb = working_space[ssizex * i + k];
            ldc = working_space[ssizex * j + k];
            lda = lda + ldb * ldc;
         }
         working_space[ssizex * ssizey + ssizey * i + j] = lda;
      }
      lda = 0;
      for (k = 0; k < ssizex; k++) {
         ldb = working_space[ssizex * i + k];
         ldc =
             working_space[ssizex * ssizey + 2 * ssizey * ssizey + 2 * ssizex +
                           k];
         lda = lda + ldb * ldc;
      }
      working_space[ssizex * ssizey + 2 * ssizey * ssizey + 3 * ssizex + i] =
          lda;
   }

/*move vector at*y*/
   for (i = 0; i < ssizey; i++)
      working_space[ssizex * ssizey + 2 * ssizey * ssizey + 2 * ssizex + i] =
          working_space[ssizex * ssizey + 2 * ssizey * ssizey + 3 * ssizex + i];

/*create matrix at*a*at*a + vector at*a*at*y */
   for (i = 0; i < ssizey; i++) {
      for (j = 0; j < ssizey; j++) {
         lda = 0;
         for (k = 0; k < ssizey; k++) {
            ldb = working_space[ssizex * ssizey + ssizey * i + k];
            ldc = working_space[ssizex * ssizey + ssizey * j + k];
            lda = lda + ldb * ldc;
         }
         working_space[ssizex * ssizey + ssizey * ssizey + ssizey * i + j] =
             lda;
      }
      lda = 0;
      for (k = 0; k < ssizey; k++) {
         ldb = working_space[ssizex * ssizey + ssizey * i + k];
         ldc =
             working_space[ssizex * ssizey + 2 * ssizey * ssizey + 2 * ssizex +
                           k];
         lda = lda + ldb * ldc;
      }
      working_space[ssizex * ssizey + 2 * ssizey * ssizey + 3 * ssizex + i] =
          lda;
   }

/*move at*a*at*y*/
   for (i = 0; i < ssizey; i++)
      working_space[ssizex * ssizey + 2 * ssizey * ssizey + 2 * ssizex + i] =
          working_space[ssizex * ssizey + 2 * ssizey * ssizey + 3 * ssizex + i];

/*initialization in resulting vector */
   for (i = 0; i < ssizey; i++)
      working_space[ssizex * ssizey + 2 * ssizey * ssizey + i] = 1;

        /***START OF ITERATIONS***/
   for (repet = 0; repet < numberRepetitions; repet++) {
      if (repet != 0) {
         for (i = 0; i < ssizey; i++)
            working_space[ssizex * ssizey + 2 * ssizey * ssizey + i] = TMath::Power(working_space[ssizex * ssizey + 2 * ssizey * ssizey + i], boost);
      }
      for (lindex = 0; lindex < numberIterations; lindex++) {
         for (i = 0; i < ssizey; i++) {
            lda = 0;
            for (j = 0; j < ssizey; j++) {
               ldb =
                   working_space[ssizex * ssizey + ssizey * ssizey + ssizey * i + j];
               ldc = working_space[ssizex * ssizey + 2 * ssizey * ssizey + j];
               lda = lda + ldb * ldc;
            }
            ldb =
                working_space[ssizex * ssizey + 2 * ssizey * ssizey + 2 * ssizex + i];
            if (lda != 0) {
               lda = ldb / lda;
            }

            else
               lda = 0;
            ldb = working_space[ssizex * ssizey + 2 * ssizey * ssizey + i];
            lda = lda * ldb;
            working_space[ssizex * ssizey + 2 * ssizey * ssizey + 3 * ssizex + i] = lda;
         }
         for (i = 0; i < ssizey; i++)
            working_space[ssizex * ssizey + 2 * ssizey * ssizey + i] =
                working_space[ssizex * ssizey + 2 * ssizey * ssizey + 3 * ssizex + i];
      }
   }

/*write back resulting spectrum*/
   for (i = 0; i < ssizex; i++) {
      if (i < ssizey)
         source[i] = working_space[ssizex * ssizey + 2 * ssizey * ssizey + i];

      else
         source[i] = 0;
   }
   delete[]working_space;
   return 0;
}


//______________________________________________________________________________
Int_t TSpectrum::SearchHighRes(float *source,float *destVector, int ssize,
                                     float sigma, double threshold,
                                     bool backgroundRemove,int deconIterations,
                                     bool markov, int averWindow)
{
   /* Begin_Html
   <b>One-dimensional high-resolution peak search function</b>
   <p>
   This function searches for peaks in source spectrum. It is based on
   deconvolution method. First the background is removed (if desired), then
   Markov smoothed spectrum is calculated (if desired), then the response
   function is generated according to given sigma and deconvolution is
   carried out. The order of peaks is arranged according to their heights in
   the spectrum after background elimination. The highest peak is the first in
   the list. On success it returns number of found peaks.
   <p>
   <b>Function parameters:</b>
   <ul>
   <li> source: pointer to the vector of source spectrum.
   <li> destVector: pointer to the vector of resulting deconvolved spectrum.
   <li> ssize: length of source spectrum.
   <li> sigma: sigma of searched peaks, for details we refer to manual.
   <li> threshold: threshold value in % for selected peaks, peaks with
        amplitude less than threshold*highest_peak/100
        are ignored, see manual.
   <li> backgroundRemove: logical variable, set if the removal of
        background before deconvolution is desired.
   <li> deconIterations-number of iterations in deconvolution operation.
   <li> markov: logical variable, if it is true, first the source spectrum
        is replaced by new spectrum calculated using Markov
        chains method.
   <li> averWindow: averanging window of searched peaks, for details
        we refer to manual (applies only for Markov method).
   </ul>
   <p>
   <b>Peaks searching:</b>
   <p>
   The goal of this function is to identify automatically the peaks in spectrum
   with the presence of the continuous background and statistical
   fluctuations - noise.
   <p>
   The common problems connected with correct peak identification are:
   <ul>
   <li> non-sensitivity to noise, i.e., only statistically
     relevant peaks should be identified.
   <li> non-sensitivity of the algorithm to continuous
     background.
   <li> ability to identify peaks close to the edges of the
     spectrum region. Usually peak finders fail to detect them.
   <li> resolution, decomposition of doublets and multiplets.
     The algorithm should be able to recognize close positioned peaks.
   <li> ability to identify peaks with different sigma.
   </ul>
   <img width=600 height=375 src="gif/TSpectrum_Searching1.jpg">
   <p>
   Fig. 27 An example of one-dimensional synthetic spectrum with found peaks
   denoted by markers.
   <p>
   <b>References:</b>
   <ol>
   <li> M.A. Mariscotti: A method for identification of peaks in the presence of
   background and its application to spectrum analysis. NIM 50 (1967),
   309-320.
   <li> M. Morhá&#269;, J. Kliman, V.  Matoušek, M. Veselský,
   I. Turzo.:Identification of peaks in
   multidimensional coincidence gamma-ray spectra. NIM, A443 (2000) 108-125.
   <li> Z.K. Silagadze, A new algorithm for automatic photopeak searches. NIM
   A 376 (1996), 451.
   </ol>
   <p>
   <b>Examples of peak searching method:</b>
   <p>
   The SearchHighRes function provides users with the possibility to vary the
   input parameters and with the access to the output deconvolved data in the
   destination spectrum. Based on the output data one can tune the parameters.
   <p>
   Example 15 - script SearchHR1.c:
   <img width=600 height=321 src="gif/TSpectrum_Searching1.jpg">
   <p>
   Fig. 28 One-dimensional spectrum with found peaks denoted by markers, 3
   iterations steps in the deconvolution.
   <p>
   <img width=600 height=323 src="gif/TSpectrum_Searching2.jpg">
   Fig. 29 One-dimensional spectrum with found peaks denoted by markers, 8
   iterations steps in the deconvolution.
   <p>
   Script:
   <pre>
   // Example to illustrate high resolution peak searching function (class TSpectrum).
   // To execute this example, do
   // root > .x SearchHR1.C

   #include <TSpectrum>

   void SearchHR1() {
      Float_t fPositionX[100];
      Float_t fPositionY[100];
      Int_t fNPeaks = 0;
      Int_t i,nfound,bin;
      Double_t nbins = 1024,a;
      Double_t xmin  = 0;
      Double_t xmax  = (Double_t)nbins;
      Float_t * source = new float[nbins];
      Float_t * dest = new float[nbins];
      TH1F *h = new TH1F("h","High resolution peak searching, number of iterations = 3",nbins,xmin,xmax);
      TH1F *d = new TH1F("d","",nbins,xmin,xmax);
      TFile *f = new TFile("spectra\\TSpectrum.root");
      h=(TH1F*) f->Get("search2;1");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      TCanvas *Search = gROOT->GetListOfCanvases()->FindObject("Search");
      if (!Search) Search = new TCanvas("Search","Search",10,10,1000,700);
      h->SetMaximum(4000);
      h->Draw("L");
      TSpectrum *s = new TSpectrum();
      nfound = s->SearchHighRes(source, dest, nbins, 8, 2, kTRUE, 3, kTRUE, 3);
      Float_t *xpeaks = s->GetPositionX();
      for (i = 0; i < nfound; i++) {
         a=xpeaks[i];
         bin = 1 + Int_t(a + 0.5);
         fPositionX[i] = h->GetBinCenter(bin);
         fPositionY[i] = h->GetBinContent(bin);
      }
      TPolyMarker * pm = (TPolyMarker*)h->GetListOfFunctions()->FindObject("TPolyMarker");
      if (pm) {
         h->GetListOfFunctions()->Remove(pm);
         delete pm;
      }
      pm = new TPolyMarker(nfound, fPositionX, fPositionY);
      h->GetListOfFunctions()->Add(pm);
      pm->SetMarkerStyle(23);
      pm->SetMarkerColor(kRed);
      pm->SetMarkerSize(1.3);
      for (i = 0; i < nbins; i++) d->SetBinContent(i + 1,dest[i]);
      d->SetLineColor(kRed);
      d->Draw("SAME");
      printf("Found %d candidate peaks\n",nfound);
      for(i=0;i<nfound;i++)
         printf("posx= %d, posy= %d\n",fPositionX[i], fPositionY[i]);
      }
   </pre>
   <p>
   Example 16 - script SearchHR3.c:
   <p>
   <table border=solid>
   <tr><td> Peak # </td><td> Position </td><td> Sigma </td></tr>
   <tr><td> 1      </td><td> 118      </td><td> 26    </td></tr>
   <tr><td> 2      </td><td> 162      </td><td> 41    </td></tr>
   <tr><td> 3      </td><td> 310      </td><td> 4     </td></tr>
   <tr><td> 4      </td><td> 330      </td><td> 8     </td></tr>
   <tr><td> 5      </td><td> 482      </td><td> 22    </td></tr>
   <tr><td> 6      </td><td> 491      </td><td> 26    </td></tr>
   <tr><td> 7      </td><td> 740      </td><td> 21    </td></tr>
   <tr><td> 8      </td><td> 852      </td><td> 15    </td></tr>
   <tr><td> 9      </td><td> 954      </td><td> 12    </td></tr>
   <tr><td> 10     </td><td> 989      </td><td> 13    </td></tr>
   </table>
   <p>
   Table 4 Positions and sigma of peaks in the following examples.
   <p>
   <img width=600 height=328 src="gif/TSpectrum_Searching3.jpg">
   <p>
   Fig. 30 Influence of number of iterations (3-red, 10-blue, 100- green,
   1000-magenta), sigma=8, smoothing width=3.
   <p>
   <img width=600 height=321 src="gif/TSpectrum_Searching4.jpg">
   <p>
   Fig. 31 Influence of sigma (3-red, 8-blue, 20- green, 43-magenta),
   num. iter.=10, sm. width=3.
   <p>
   <img width=600 height=323 src="gif/TSpectrum_Searching5.jpg"></p>
   <p>
   Fig. 32 Influence smoothing width (0-red, 3-blue, 7- green, 20-magenta), num.
   iter.=10, sigma=8.
   <p>
   Script:
   <pre>
   // Example to illustrate the influence of number of iterations in deconvolution in high resolution peak searching function (class TSpectrum).
   // To execute this example, do
   // root > .x SearchHR3.C

   #include <TSpectrum>

   void SearchHR3() {
      Float_t fPositionX[100];
      Float_t fPositionY[100];
      Int_t fNPeaks = 0;
      Int_t i,nfound,bin;
      Double_t nbins = 1024,a;
      Double_t xmin  = 0;
      Double_t xmax  = (Double_t)nbins;
      Float_t * source = new float[nbins];
      Float_t * dest = new float[nbins];
      TH1F *h = new TH1F("h","Influence of # of iterations in deconvolution in peak searching",nbins,xmin,xmax);
      TH1F *d1 = new TH1F("d1","",nbins,xmin,xmax);
      TH1F *d2 = new TH1F("d2","",nbins,xmin,xmax);
      TH1F *d3 = new TH1F("d3","",nbins,xmin,xmax);
      TH1F *d4 = new TH1F("d4","",nbins,xmin,xmax);
      TFile *f = new TFile("spectra\\TSpectrum.root");
      h=(TH1F*) f->Get("search3;1");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      TCanvas *Search = gROOT->GetListOfCanvases()->FindObject("Search");
      if (!Search) Search = new TCanvas("Search","Search",10,10,1000,700);
      h->SetMaximum(1300);
      h->Draw("L");
      TSpectrum *s = new TSpectrum();
      nfound = s->SearchHighRes(source, dest, nbins, 8, 2, kTRUE, 3, kTRUE, 3);
      Float_t *xpeaks = s->GetPositionX();
      for (i = 0; i < nfound; i++) {
         a=xpeaks[i];
         bin = 1 + Int_t(a + 0.5);
         fPositionX[i] = h->GetBinCenter(bin);
         fPositionY[i] = h->GetBinContent(bin);
      }
      TPolyMarker * pm = (TPolyMarker*)h->GetListOfFunctions()->FindObject("TPolyMarker");
      if (pm) {
         h->GetListOfFunctions()->Remove(pm);
         delete pm;
      }
      pm = new TPolyMarker(nfound, fPositionX, fPositionY);
      h->GetListOfFunctions()->Add(pm);
      pm->SetMarkerStyle(23);
      pm->SetMarkerColor(kRed);
      pm->SetMarkerSize(1.3);
      for (i = 0; i < nbins; i++) d1->SetBinContent(i + 1,dest[i]);
      h->Draw("");
      d1->SetLineColor(kRed);
      d1->Draw("SAME");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      s->SearchHighRes(source, dest, nbins, 8, 2, kTRUE, 10, kTRUE, 3);
      for (i = 0; i < nbins; i++) d2->SetBinContent(i + 1,dest[i]);
      d2->SetLineColor(kBlue);
      d2->Draw("SAME");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      s->SearchHighRes(source, dest, nbins, 8, 2, kTRUE, 100, kTRUE, 3);
      for (i = 0; i < nbins; i++) d3->SetBinContent(i + 1,dest[i]);
      d3->SetLineColor(kGreen);
      d3->Draw("SAME");
      for (i = 0; i < nbins; i++) source[i]=h->GetBinContent(i + 1);
      s->SearchHighRes(source, dest, nbins, 8, 2, kTRUE, 1000, kTRUE, 3);
      for (i = 0; i < nbins; i++) d4->SetBinContent(i + 1,dest[i]);
      d4->SetLineColor(kMagenta);
      d4->Draw("SAME");
      printf("Found %d candidate peaks\n",nfound);
   }
   </pre>
   End_Html */

   int i, j, numberIterations = (int)(7 * sigma + 0.5);
   double a, b, c;
   int k, lindex, posit, imin, imax, jmin, jmax, lh_gold, priz;
   double lda, ldb, ldc, area, maximum, maximum_decon;
   int xmin, xmax, l, peak_index = 0, size_ext = ssize + 2 * numberIterations, shift = numberIterations, bw = 2, w;
   double maxch;
   double nom, nip, nim, sp, sm, plocha = 0;
   double m0low=0,m1low=0,m2low=0,l0low=0,l1low=0,detlow,av,men;
   if (sigma < 1) {
      Error("SearchHighRes", "Invalid sigma, must be greater than or equal to 1");
      return 0;
   }

   if(threshold<=0 || threshold>=100){
      Error("SearchHighRes", "Invalid threshold, must be positive and less than 100");
      return 0;
   }

   j = (int) (5.0 * sigma + 0.5);
   if (j >= PEAK_WINDOW / 2) {
      Error("SearchHighRes", "Too large sigma");
      return 0;
   }

   if (markov == true) {
      if (averWindow <= 0) {
         Error("SearchHighRes", "Averanging window must be positive");
         return 0;
      }
   }

   if(backgroundRemove == true){
      if(ssize < 2 * numberIterations + 1){
         Error("SearchHighRes", "Too large clipping window");
         return 0;
      }
   }

   k = int(2 * sigma+0.5);
   if(k >= 2){
      for(i = 0;i < k;i++){
         a = i,b = source[i];
         m0low += 1,m1low += a,m2low += a * a,l0low += b,l1low += a * b;
      }
      detlow = m0low * m2low - m1low * m1low;
      if(detlow != 0)
         l1low = (-l0low * m1low + l1low * m0low) / detlow;

      else
         l1low = 0;
      if(l1low > 0)
         l1low=0;
   }

   else{
      l1low = 0;
   }

   i = (int)(7 * sigma + 0.5);
   i = 2 * i;
   double *working_space = new double [7 * (ssize + i)];
   for (j=0;j<7 * (ssize + i);j++) working_space[j] = 0;
   for(i = 0; i < size_ext; i++){
      if(i < shift){
         a = i - shift;
         working_space[i + size_ext] = source[0] + l1low * a;
         if(working_space[i + size_ext] < 0)
            working_space[i + size_ext]=0;
      }

      else if(i >= ssize + shift){
         a = i - (ssize - 1 + shift);
         working_space[i + size_ext] = source[ssize - 1];
         if(working_space[i + size_ext] < 0)
            working_space[i + size_ext]=0;
      }

      else
         working_space[i + size_ext] = source[i - shift];
   }

   if(backgroundRemove == true){
      for(i = 1; i <= numberIterations; i++){
         for(j = i; j < size_ext - i; j++){
            if(markov == false){
               a = working_space[size_ext + j];
               b = (working_space[size_ext + j - i] + working_space[size_ext + j + i]) / 2.0;
               if(b < a)
                  a = b;

               working_space[j]=a;
            }

            else{
               a = working_space[size_ext + j];
               av = 0;
               men = 0;
               for (w = j - bw; w <= j + bw; w++){
                  if ( w >= 0 && w < size_ext){
                     av += working_space[size_ext + w];
                     men +=1;
                  }
               }
               av = av / men;
               b = 0;
               men = 0;
               for (w = j - i - bw; w <= j - i + bw; w++){
                  if ( w >= 0 && w < size_ext){
                     b += working_space[size_ext + w];
                     men +=1;
                  }
               }
               b = b / men;
               c = 0;
               men = 0;
               for (w = j + i - bw; w <= j + i + bw; w++){
                  if ( w >= 0 && w < size_ext){
                     c += working_space[size_ext + w];
                     men +=1;
                  }
               }
               c = c / men;
               b = (b + c) / 2;
               if (b < a)
                  av = b;
               working_space[j]=av;
            }
         }
         for(j = i; j < size_ext - i; j++)
            working_space[size_ext + j] = working_space[j];
      }
      for(j = 0;j < size_ext; j++){
         if(j < shift){
                  a = j - shift;
                  b = source[0] + l1low * a;
                  if (b < 0) b = 0;
            working_space[size_ext + j] = b - working_space[size_ext + j];
         }

         else if(j >= ssize + shift){
                  a = j - (ssize - 1 + shift);
                  b = source[ssize - 1];
                  if (b < 0) b = 0;
            working_space[size_ext + j] = b - working_space[size_ext + j];
         }

         else{
            working_space[size_ext + j] = source[j - shift] - working_space[size_ext + j];
         }
      }
      for(j = 0;j < size_ext; j++){
         if(working_space[size_ext + j] < 0) working_space[size_ext + j] = 0;
      }
   }

   for(i = 0; i < size_ext; i++){
      working_space[i + 6*size_ext] = working_space[i + size_ext];
   }

   if(markov == true){
      for(j = 0; j < size_ext; j++)
         working_space[2 * size_ext + j] = working_space[size_ext + j];
      xmin = 0,xmax = size_ext - 1;
      for(i = 0, maxch = 0; i < size_ext; i++){
         working_space[i] = 0;
         if(maxch < working_space[2 * size_ext + i])
            maxch = working_space[2 * size_ext + i];
         plocha += working_space[2 * size_ext + i];
      }
      if(maxch == 0) {
         delete [] working_space;
         return 0;
      }

      nom = 1;
      working_space[xmin] = 1;
      for(i = xmin; i < xmax; i++){
         nip = working_space[2 * size_ext + i] / maxch;
         nim = working_space[2 * size_ext + i + 1] / maxch;
         sp = 0,sm = 0;
         for(l = 1; l <= averWindow; l++){
            if((i + l) > xmax)
               a = working_space[2 * size_ext + xmax] / maxch;

            else
               a = working_space[2 * size_ext + i + l] / maxch;

            b = a - nip;
            if(a + nip <= 0)
               a=1;

            else
               a = TMath::Sqrt(a + nip);

            b = b / a;
            b = TMath::Exp(b);
            sp = sp + b;
            if((i - l + 1) < xmin)
               a = working_space[2 * size_ext + xmin] / maxch;

            else
               a = working_space[2 * size_ext + i - l + 1] / maxch;

            b = a - nim;
            if(a + nim <= 0)
               a = 1;

            else
               a = TMath::Sqrt(a + nim);

            b = b / a;
            b = TMath::Exp(b);
            sm = sm + b;
         }
         a = sp / sm;
         a = working_space[i + 1] = working_space[i] * a;
         nom = nom + a;
      }
      for(i = xmin; i <= xmax; i++){
         working_space[i] = working_space[i] / nom;
      }
      for(j = 0; j < size_ext; j++)
         working_space[size_ext + j] = working_space[j] * plocha;
      for(j = 0; j < size_ext; j++){
         working_space[2 * size_ext + j] = working_space[size_ext + j];
      }
      if(backgroundRemove == true){
         for(i = 1; i <= numberIterations; i++){
            for(j = i; j < size_ext - i; j++){
               a = working_space[size_ext + j];
               b = (working_space[size_ext + j - i] + working_space[size_ext + j + i]) / 2.0;
               if(b < a)
                  a = b;
               working_space[j] = a;
            }
            for(j = i; j < size_ext - i; j++)
               working_space[size_ext + j] = working_space[j];
         }
         for(j = 0; j < size_ext; j++){
            working_space[size_ext + j] = working_space[2 * size_ext + j] - working_space[size_ext + j];
         }
      }
   }
//deconvolution starts
   area = 0;
   lh_gold = -1;
   posit = 0;
   maximum = 0;
//generate response vector
   for(i = 0; i < size_ext; i++){
      lda = (double)i - 3 * sigma;
      lda = lda * lda / (2 * sigma * sigma);
      j = (int)(1000 * TMath::Exp(-lda));
      lda = j;
      if(lda != 0)
         lh_gold = i + 1;

      working_space[i] = lda;
      area = area + lda;
      if(lda > maximum){
         maximum = lda;
         posit = i;
      }
   }
//read source vector
   for(i = 0; i < size_ext; i++)
      working_space[2 * size_ext + i] = TMath::Abs(working_space[size_ext + i]);
//create matrix at*a(vector b)
   i = lh_gold - 1;
   if(i > size_ext)
      i = size_ext;

   imin = -i,imax = i;
   for(i = imin; i <= imax; i++){
      lda = 0;
      jmin = 0;
      if(i < 0)
         jmin = -i;
      jmax = lh_gold - 1 - i;
      if(jmax > (lh_gold - 1))
         jmax = lh_gold - 1;

      for(j = jmin;j <= jmax; j++){
         ldb = working_space[j];
         ldc = working_space[i + j];
         lda = lda + ldb * ldc;
      }
      working_space[size_ext + i - imin] = lda;
   }
//create vector p
   i = lh_gold - 1;
   imin = -i,imax = size_ext + i - 1;
   for(i = imin; i <= imax; i++){
      lda = 0;
      for(j = 0; j <= (lh_gold - 1); j++){
         ldb = working_space[j];
         k = i + j;
         if(k >= 0 && k < size_ext){
            ldc = working_space[2 * size_ext + k];
            lda = lda + ldb * ldc;
         }

      }
      working_space[4 * size_ext + i - imin] = lda;
   }
//move vector p
   for(i = imin; i <= imax; i++)
      working_space[2 * size_ext + i - imin] = working_space[4 * size_ext + i - imin];
//initialization of resulting vector
   for(i = 0; i < size_ext; i++)
      working_space[i] = 1;
//START OF ITERATIONS
   for(lindex = 0; lindex < deconIterations; lindex++){
      for(i = 0; i < size_ext; i++){
         if(TMath::Abs(working_space[2 * size_ext + i]) > 0.00001 && TMath::Abs(working_space[i]) > 0.00001){
            lda=0;
            jmin = lh_gold - 1;
            if(jmin > i)
               jmin = i;

            jmin = -jmin;
            jmax = lh_gold - 1;
            if(jmax > (size_ext - 1 - i))
               jmax=size_ext-1-i;

            for(j = jmin; j <= jmax; j++){
               ldb = working_space[j + lh_gold - 1 + size_ext];
               ldc = working_space[i + j];
               lda = lda + ldb * ldc;
            }
            ldb = working_space[2 * size_ext + i];
            if(lda != 0)
               lda = ldb / lda;

            else
               lda = 0;

            ldb = working_space[i];
            lda = lda * ldb;
            working_space[3 * size_ext + i] = lda;
         }
      }
      for(i = 0; i < size_ext; i++){
         working_space[i] = working_space[3 * size_ext + i];
      }
   }
//shift resulting spectrum
   for(i=0;i<size_ext;i++){
      lda = working_space[i];
      j = i + posit;
      j = j % size_ext;
      working_space[size_ext + j] = lda;
   }
//write back resulting spectrum
   maximum = 0, maximum_decon = 0;
   j = lh_gold - 1;
   for(i = 0; i < size_ext - j; i++){
      if(i >= shift && i < ssize + shift){
         working_space[i] = area * working_space[size_ext + i + j];
         if(maximum_decon < working_space[i])
            maximum_decon = working_space[i];
         if(maximum < working_space[6 * size_ext + i])
            maximum = working_space[6 * size_ext + i];
      }

      else
         working_space[i] = 0;
   }
   lda=1;
   if(lda>threshold)
      lda=threshold;
   lda=lda/100;

//searching for peaks in deconvolved spectrum
   for(i = 1; i < size_ext - 1; i++){
      if(working_space[i] > working_space[i - 1] && working_space[i] > working_space[i + 1]){
         if(i >= shift && i < ssize + shift){
            if(working_space[i] > lda*maximum_decon && working_space[6 * size_ext + i] > threshold * maximum / 100.0){
               for(j = i - 1, a = 0, b = 0; j <= i + 1; j++){
                  a += (double)(j - shift) * working_space[j];
                  b += working_space[j];
               }
               a = a / b;
               if(a < 0)
                  a = 0;

               if(a >= ssize)
                  a = ssize - 1;
               if(peak_index == 0){
                  fPositionX[0] = a;
                  peak_index = 1;
               }

               else{
                  for(j = 0, priz = 0; j < peak_index && priz == 0; j++){
                     if(working_space[6 * size_ext + shift + (int)a] > working_space[6 * size_ext + shift + (int)fPositionX[j]])
                        priz = 1;
                  }
                  if(priz == 0){
                     if(j < fMaxPeaks){
                        fPositionX[j] = a;
                     }
                  }

                  else{
                     for(k = peak_index; k >= j; k--){
                        if(k < fMaxPeaks){
                           fPositionX[k] = fPositionX[k - 1];
                        }
                     }
                     fPositionX[j - 1] = a;
                  }
                  if(peak_index < fMaxPeaks)
                     peak_index += 1;
               }
            }
         }
      }
   }

   for(i = 0; i < ssize; i++) destVector[i] = working_space[i + shift];
   delete [] working_space;
   fNPeaks = peak_index;
   if(peak_index == fMaxPeaks)
      Warning("SearchHighRes", "Peak buffer full");
   return fNPeaks;
}


//______________________________________________________________________________
Int_t TSpectrum::Search1HighRes(float *source,float *destVector, int ssize,
                                     float sigma, double threshold,
                                     bool backgroundRemove,int deconIterations,
                                     bool markov, int averWindow)
{
   /* Begin_Html
   Old name of SearcHighRes introduced for back compatibility.
   This function will be removed after the June 2006 release
   End_Html */

   return SearchHighRes(source,destVector,ssize,sigma,threshold,backgroundRemove,
                        deconIterations,markov,averWindow);
}


//______________________________________________________________________________
Int_t TSpectrum::StaticSearch(const TH1 *hist, Double_t sigma, Option_t *option, Double_t threshold)
{
   /* Begin_Html
   Static function, interface to TSpectrum::Search.
   End_Html */

   TSpectrum s;
   return s.Search(hist,sigma,option,threshold);
}


//______________________________________________________________________________
TH1 *TSpectrum::StaticBackground(const TH1 *hist,Int_t niter, Option_t *option)
{
   /* Begin_Html
   Static function, interface to TSpectrum::Background.
   End_Html */

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