RootSpectrumPlayer.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Olivier Stezowski & Christian Finck        *
 *   stezow(AT)ipnl.in2p3.fr, cfinck(AT)ires.in2p3.fr                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <Riostream.h>

#include <vector>

#ifndef Gw_Peak1D
#include "Peak1D.h"
#endif

#ifndef Gw_RootSpectrumPlayer
#include "RootSpectrumPlayer.h"
#endif

#ifndef ROOT_TCanvas
#include "TCanvas.h"
#endif

#ifndef ROOT_TH1
#include "TH1.h"
#endif

#ifndef ROOT_TH2
#include "TH2.h"
#endif

#ifndef ROOT_TList
#include "TList.h"
#endif

#ifndef ROOT_TObjArray
#include "TObjArray.h"
#endif

#ifndef ROOT_TPad
#include "TPad.h"
#endif

#ifndef ROOT_TString
#include "TString.h"
#endif

#ifndef ROOT_TSpectrum
#include "TSpectrum.h"
#endif

#ifndef ROOT_TVector2
#include "TVector2.h"
#endif

using namespace Gw;

//__________________________________________________________
RootSpectrumPlayer::RootSpectrumPlayer() 
    : BaseSpectrumPlayer(),
      fMaxPeak(TParameter<Int_t>("MaxPosition", 100)),
      fSigma(TParameter<Double_t>("Sigma", 2.0)),
      fThreshold(TParameter<Double_t>("Threshold", 0.05)),
      fNbIter(TParameter<Int_t>("NbIter", 20)),
      fEngine1D(0x0)
{ 
    //Default Constructor
    fEngine1D = new TSpectrum(fMaxPeak.GetVal(),fSigma.GetVal());
    fLog.GetProcessName() = "RootSpectrumPlayerfLog";

}

//__________________________________________________________
RootSpectrumPlayer::~RootSpectrumPlayer()
{
    // default destructor
    if ( fEngine1D )
    { delete fEngine1D; fEngine1D = 0x0; }
}

//__________________________________________________________
void RootSpectrumPlayer::Print(Option_t* opt) const
{
    // print out
    BaseSpectrumPlayer::Print(opt);
}

//__________________________________________________________
Bool_t RootSpectrumPlayer::SetParameter(const char* name, Double_t value)
{
    Bool_t ok = BaseSpectrumPlayer::SetParameter(name,value);
    if ( !ok ) {
        // set search parameter
        if (strncmp(name, "threshold", strlen(name)) == 0)
        {
            ok = true;
            fThreshold = TParameter<Double_t>(name, value);
        }
        if (strncmp(name, "sigma", strlen(name)) == 0)
        {
            ok = true;
            fSigma = TParameter<Double_t>(name, value);
            if(fEngine1D) delete fEngine1D;
            fEngine1D = new TSpectrum(fMaxPeak.GetVal(),fSigma.GetVal());
        }
    }
    if ( !ok ) {
        fLog.SetProcessMethod("SetParameter(const char*, Double_t )");
        fLog << error << "Unkown parameter: " << name << dolog;
    }
    return ok;
}

//__________________________________________________________
Bool_t RootSpectrumPlayer::SetParameter(const char* name, Int_t value)
{
    Bool_t ok = BaseSpectrumPlayer::SetParameter(name,value);
    if ( !ok ) {
        if (strncmp(name, "nbiter", strlen(name)) == 0)
        {
            ok = true;
            fNbIter = TParameter<Int_t>(name, value);
        }
        if (strncmp(name, "maxpeak", strlen(name)) == 0)
        {
            ok = true;
            fMaxPeak = TParameter<Int_t>(name, value);
            if(fEngine1D) delete fEngine1D;
            fEngine1D = new TSpectrum(fMaxPeak.GetVal(),fSigma.GetVal());
        }
    }
    if ( !ok ) {
        fLog.SetProcessMethod("SetParameter(const char*, Int_t )");
        fLog << error << "Unkown parameter: " << name << dolog;
    }
    return ok;
}

//__________________________________________________________
TParameter<Int_t> RootSpectrumPlayer::GetIntParameter(TString Name)
{
    if(Name == "nbiter") return fNbIter;
    else if(Name == "maxpeak") return fMaxPeak;
    else
    {
        fLog.SetProcessMethod("GetIntParameter(TString)");
        fLog << error << "Unkown parameter: " << Name << dolog;
        return TParameter<Int_t>();
    }
}

//__________________________________________________________
TParameter<Double_t> RootSpectrumPlayer::GetDoubleParameter(TString Name)
{
    if(Name == "threshold") return fThreshold;
    else if(Name == "sigma") return fSigma;
    else
    {
        fLog.SetProcessMethod("GetDoubleParameter(TString)");
        fLog << error << "Unkown parameter: " << Name << dolog;
        return TParameter<Double_t>();
    }
}

//__________________________________________________________
Int_t RootSpectrumPlayer::FindPeaks(TH1 *histo, Option_t* o)
{
    // find peaks with TSpectrum->Search ... should be better in a futur implementation to use SearchHighRes
    Int_t    result    = 0;

    //  Int_t    bin       = 0;
    Double_t posx      = 0.;
    //  Double_t posy      = 0.;

    // if Contains +, add to the list
    TString opt = o;
    if ( !opt.Contains("+") )
        GetPeakList()->Clear();

    Option_t* optPeak;
    if ( opt.Contains("bg") )
        optPeak = "bg";
    else
        optPeak = "";

    // activated search for 1D spectrum
    if ( histo->GetDimension() == 1 ) {

        TString opt;
        opt  = o;
        opt += " goff";
        result  = fEngine1D->Search(histo, fSigma.GetVal(), opt.Data(), fThreshold.GetVal());
        /*TH1* bg = */fEngine1D->Background(histo, fNbIter.GetVal());

        for(Int_t i = 0; i < fEngine1D->GetNPeaks(); ++i) {
            posx = fEngine1D->GetPositionX()[i];
            //      bin  = bg->FindBin(posx);
            //      posy = bg->GetBinContent(bin);
            fCreator->CreatePeak(posx, optPeak);
        }
        TVirtualPad::Pad()->Update();
    }

    if ( histo->GetDimension() == 2) {
        fLog.SetProcessMethod("FindPeaks(TH1*, Option_t* )");
        fLog << error << "Dimension not handled " << histo->GetDimension() << dolog;
        return 0;
    }

    return result;
}

//__________________________________________________________
TH1 *RootSpectrumPlayer::Background(const TH1 *histo, Option_t* opt)
{
    TH1 *result = 0x0;

    // activated search for 1D spectrum
    if ( histo->GetDimension() == 1 ) {
        result =
                fEngine1D->Background(histo,fNbIter.GetVal(),opt);

        TString bgname = histo->GetName();
        bgname += "_BG";
        //      bgname += fNbIter.GetVal();

        result->SetName(bgname.Data());
    }
    if ( histo->GetDimension() == 2) {
        fLog.SetProcessMethod("Background(TH1*, Option_t* )");
        fLog << error << "Dimension not handled " << histo->GetDimension() << dolog;
    }

    return result;
}

ClassImp(RootSpectrumPlayer)