GSPlayerTUI.cpp

Go to the documentation of this file.

#include <iostream>

#include "TSpectrum.h"
#include "TH1.h"
#include "TCanvas.h"
#include "KeySymbols.h"
#include "TContextMenu.h"
#include "TClass.h"

#include "BashColor.h"
#include "TParameter.h"
#include "InnerNDB.h"
#include "PadManager.h"
#include "TMath.h"
#include "TGraphErrors.h"
#include "TList.h"
#include "TROOT.h"
#include "Peak1D.h"
#include "PeakCreator.h"

#include "GSPlayerTUI.h"

using namespace std;
using namespace Gw;


GSPlayerTUI::GSPlayerTUI(Bool_t verbose) :
    TTask("GSPlayerTUI","GSPlayerTUI"),
    fBashColor(new BashColor()),
    fVerbose(verbose),
    fNumberIterations(20),
    fDirection(TSpectrum::kBackDecreasingWindow),
    fStrDirection("BackDecreasingWindow"),
    fFilterOrder(TSpectrum::kBackOrder8),
    fStrFilterOrder("BackOrder8"),
    fSmoothing(true),
    fSmoothingWindow(TSpectrum::kBackSmoothing5),
    fStrSmoothingWindow("BackSmoothing5"),
    fCompton(true),
    fRootSP(new RootSpectrumPlayer()),
    fDataBase(new InnerNDB(verbose)),
    fCurrentHist(0x0),
    fSubtractHist(0x0),
    fBackgroundHist(0x0),
    fActiveBGAdjustment(false),
    fActiveIt(false),
    fActiveFilt(false),
    fActivSmooth(false),
    fIsConnected(false),
    fConnectBSP(false),
    fFWHMFormula("AGATA_FWHM"),
    fContextMenu(0x0)
{
    SetFWHMFormula(fFWHMFormula);
    fRootSP->SetHelpsPrintActive(false);
    fRootSP->GetPeakCreator()->SetHelpsPrintActive(false);
}


GSPlayerTUI::GSPlayerTUI(const char* name, const char *title, Bool_t verbose) :
    TTask(name,title),
    fBashColor(new BashColor()),
    fVerbose(verbose),
    fNumberIterations(20),
    fDirection(TSpectrum::kBackDecreasingWindow),
    fStrDirection("BackDecreasingWindow"),
    fFilterOrder(TSpectrum::kBackOrder8),
    fStrFilterOrder("BackOrder8"),
    fSmoothing(true),
    fSmoothingWindow(TSpectrum::kBackSmoothing5),
    fStrSmoothingWindow("BackSmoothing5"),
    fCompton(true),
    fRootSP(new RootSpectrumPlayer()),
    fDataBase(new InnerNDB(verbose)),
    fCurrentHist(0x0),
    fSubtractHist(0x0),
    fBackgroundHist(0x0),
    fActiveBGAdjustment(false),
    fActiveIt(false),
    fActiveFilt(false),
    fActivSmooth(false),
    fIsConnected(false),
    fConnectBSP(true),
    fFWHMFormula("AGATA_FWHM"),
    fContextMenu(0x0)
{
    SetFWHMFormula(fFWHMFormula);
    fRootSP->SetHelpsPrintActive(false);
    fRootSP->GetPeakCreator()->SetHelpsPrintActive(false);
    fRootSP->GetPeakCreator()->Collect();
}


GSPlayerTUI::~GSPlayerTUI()
{
    if(fRootSP) delete fRootSP;
    if(fDataBase) delete fDataBase;
    if(fBashColor) delete fBashColor;
    if(fSubtractHist) delete fSubtractHist;
    if(fBackgroundHist)delete fBackgroundHist;
}


void GSPlayerTUI::Exec(const char */*option*/)
{
}


void GSPlayerTUI::DefineBackground(int NumberIterations, int Direction,int FilterOrder,bool Smoothing,int smoothingWindow,bool Compton)
{
    if(NumberIterations==-1)
    {
        NumberIterations = fNumberIterations;
        Direction = fDirection;
        FilterOrder = fFilterOrder;
        Smoothing = fSmoothing;
        smoothingWindow = fSmoothingWindow;
        Compton = fCompton;
    }

    fNumberIterations = NumberIterations;

    if(Direction == 0)
    {
        fDirection = TSpectrum::kBackIncreasingWindow;
        fStrDirection = "BackIncreasingWindow";
    }
    else if(Direction == 1)
    {
        fDirection = TSpectrum::kBackDecreasingWindow;
        fStrDirection = "BackDecreasingWindow";
    }
    else
    {
        fBashColor->SetWarningOut();
        cout<<"Direction not valid, possible values :"<<endl;
        cout<<" 0 ==> BackIncreasingWindow"<<endl;
        cout<<" 1 ==> BackDecreasingWindow"<<endl;
        cout<<" Default value is taken : BackDecreasingWindow"<<endl;
        fDirection = TSpectrum::kBackDecreasingWindow;
        fBashColor->ResetColor();
    }

    if(FilterOrder == 0) fFilterOrder = TSpectrum::kBackOrder2;
    else if(FilterOrder == 1) fFilterOrder = TSpectrum::kBackOrder4;
    else if(FilterOrder == 2) fFilterOrder = TSpectrum::kBackOrder6;
    else if(FilterOrder == 3) fFilterOrder = TSpectrum::kBackOrder8;
    else
    {
        fBashColor->SetWarningOut();
        cout<<"Filter order not valid, possible values :"<<endl;
        cout<<" 0 ==> BackOrder2"<<endl;
        cout<<" 1 ==> BackOrder4"<<endl;
        cout<<" 2 ==> BackOrder6"<<endl;
        cout<<" 3 ==> BackOrder8"<<endl;
        cout<<" Default value is taken : BackOrder8"<<endl;
        fBashColor->ResetColor();
        fFilterOrder = TSpectrum::kBackOrder8;
    }

    if(fFilterOrder == TSpectrum::kBackOrder2) fStrFilterOrder = "BackOrder2";
    else if(fFilterOrder == TSpectrum::kBackOrder4) fStrFilterOrder = "BackOrder4";
    else if(fFilterOrder == TSpectrum::kBackOrder6) fStrFilterOrder = "BackOrder6";
    else if(fFilterOrder == TSpectrum::kBackOrder8) fStrFilterOrder = "BackOrder8";

    fSmoothing = Smoothing;

    if(smoothingWindow<3 || smoothingWindow>15 || !(smoothingWindow & 1))
    {
        fBashColor->SetWarningOut();
        cout<<"Smoothing window not valid, possible values : 3, 5, 7, 9, 11, 13, 15"<<endl;
        cout<<" Default value is taken : BackSmoothing5"<<endl;
        fBashColor->ResetColor();
        smoothingWindow = TSpectrum::kBackSmoothing5;
    }

    fSmoothingWindow = smoothingWindow;
    if(!fSmoothing) fStrSmoothingWindow = "NoSmoothing";
    else if(fSmoothingWindow == TSpectrum::kBackSmoothing3) fStrSmoothingWindow = "BackSmoothing3";
    else if(fSmoothingWindow == TSpectrum::kBackSmoothing5) fStrSmoothingWindow = "BackSmoothing5";
    else if(fSmoothingWindow == TSpectrum::kBackSmoothing7) fStrSmoothingWindow = "BackSmoothing7";
    else if(fSmoothingWindow == TSpectrum::kBackSmoothing9) fStrSmoothingWindow = "BackSmoothing9";
    else if(fSmoothingWindow == TSpectrum::kBackSmoothing11) fStrSmoothingWindow = "BackSmoothing11";
    else if(fSmoothingWindow == TSpectrum::kBackSmoothing13) fStrSmoothingWindow = "BackSmoothing13";
    else if(fSmoothingWindow == TSpectrum::kBackSmoothing15) fStrSmoothingWindow = "BackSmoothing15";

    fCompton = Compton;
}


void GSPlayerTUI::PrintBGParameters()
{
    fBashColor->SetInfoOut();
    cout<<endl;
    cout<<"***********  background parameters  ***********"<<endl;
    cout<<" => Number of iterations : "<<fNumberIterations<<endl;
    cout<<" => Directtion           : "<<fStrDirection<<endl;
    cout<<" => Filter Order         : "<<fStrFilterOrder<<endl;
    cout<<" => Smoothing            : "<<fStrSmoothingWindow<<endl;
    cout<<" => Compton              : "<<fCompton<<endl;
    cout<<"***********************************************"<<endl<<endl;
    fBashColor->ResetColor();
}


TH1 *GSPlayerTUI::RemoveBackground()
{
    if(!fCurrentHist) return 0x0;
    if(!fBackgroundHist)
    {
        fBashColor->SetErrorOut();
        cout<<"No background histogram built"<<endl;
        fBashColor->ResetColor();
        return 0x0;
    }

    fSubtractHist = (TH1*)fCurrentHist->Clone((TString)fCurrentHist->GetName()+ "_NoBG");
    fSubtractHist->Add(fBackgroundHist,-1.);
    fSubtractHist->Draw(fCurrentHist->GetDrawOption());

    gPad->Modified();
    gPad->Update();

    return fSubtractHist;
}


bool GSPlayerTUI::ConnectCanvas(TCanvas *c)
{
    bool ok;

    if(fConnectBSP) ok = fRootSP->Connect(c);
    else ok = true;

    if(ok)
    {
        if(c == 0x0) c = TVirtualPad::Pad()->GetCanvas();

        if ( c) {

            c->Connect("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)",
                       "Gw::GSPlayerTUI",
                       this,
                       "HandleMovement(Int_t, Int_t, Int_t, TObject*)");

            fContextMenu = c->GetContextMenu();
        }

    }

    fCurrentHist = PadManager::GetHisto();

    if(ok && c) fIsConnected = true;

    return ok;
}


bool GSPlayerTUI::DisconnectCanvas(TCanvas *c)
{
    bool ok;
    if(fConnectBSP) ok = fRootSP->Disconnect(c);
    else ok = true;

    if(ok)
    {
        if(c == 0x0) c = TVirtualPad::Pad()->GetCanvas();

        if ( c )
            c->Disconnect("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)",
                          this,
                          "HandleMovement(Int_t, Int_t, Int_t, TObject*)");

        fContextMenu = 0x0;
    }

    if(ok && c) fIsConnected = false;

    return ok;
}


void GSPlayerTUI::HandleMovement(Int_t eventType, Int_t eventX, Int_t eventY, TObject *select)
{

    //    cout<<endl;
    //    cout<<"LasteventType = "<<fLasteventType<<" ; LasteventX = "<<fLasteventX<<" ; LasteventY = "<<fLasteventY<<endl;
    //    cout<<"eventType = "<<eventType<<" ; eventX = "<<eventX<<" ; eventY = "<<eventY<<" ; ObjectName = "<<select->GetName()<<endl;
    //    cout<<endl;

    if( eventType == kButton1Up && fLasteventType == kButton1Down)
    {
        if(select->InheritsFrom("TH1")) fCurrentHist = (TH1*)select;
    }
    if (eventType == kMouseMotion) {
        // to keep track of the last mouse position
        fLasteventX = eventX;
        fLasteventY = eventY;
    }

    bool CTRL = ( eventX == eventY-96);
    EKeySym Key = (EKeySym)eventY;

    bool LastCTRL = ( fLasteventX == fLasteventY-96);
    EKeySym LastKey = (EKeySym)fLasteventY;


    if(eventType == kKeyPress)
    {
        if(Key == kKey_e && !CTRL && LastKey == kKey_b && !LastCTRL)
            EvalBackground();
        if(Key == kKey_s && !CTRL && LastKey == kKey_b && !LastCTRL)
            RemoveBackground();
    }


    if(eventType == kKeyPress && !fActiveBGAdjustment)
    {
        if(Key == kKey_b && !CTRL && LastKey == kKey_i && !LastCTRL)
        {
            InteractiveBGMode(true);
            fLasteventY = 0;fLasteventX = 0;
        }
    }
    if(eventType == kKeyPress && fActiveBGAdjustment)
    {
        if(Key == kKey_i && !CTRL && LastKey == kKey_s && !LastCTRL)
        {
            fActiveIt = true; fActiveFilt = false; fActivSmooth = false;
            fLasteventY = 0;fLasteventX = 0;
        }
        if(Key == kKey_f && !CTRL && LastKey == kKey_s && !LastCTRL)
        {
            fActiveIt = false; fActiveFilt = true; fActivSmooth = false;
            fLasteventY = 0;fLasteventX = 0;
        }
        if(Key == kKey_s && !CTRL && LastKey == kKey_s && !LastCTRL)
        {
            fActiveIt = false; fActiveFilt = false; fActivSmooth = true;
            fLasteventY = 0;fLasteventX = 0;
        }
        if(Key == kKey_c && !CTRL && LastKey == kKey_s && !LastCTRL)
        {
            fCompton = !fCompton;
            EvalBackground();
            fLasteventY = 0;fLasteventX = 0;
        }
        if(Key == kKey_d && !CTRL && LastKey == kKey_s && !LastCTRL)
        {
            fDirection = !fDirection;
            EvalBackground();
            fLasteventY = 0;fLasteventX = 0;
        }
    }

    if( (eventType == kWheelUp || eventType == kWheelDown ) && fActiveBGAdjustment && (fActiveIt || fActiveFilt || fActivSmooth))
    {
        cout<<eventType<<endl;
        Int_t value = TMath::Nint((5.5-(int)eventType)*2); //-1 pour down, +1 pour up
        cout<<value<<endl;
        if(fActiveIt)
        {
            fNumberIterations += value;
            if(fNumberIterations<=1) fNumberIterations = 1;
        }
        if(fActiveFilt)
        {
            fFilterOrder += value;
            if(fFilterOrder<=0) fFilterOrder = 0;
            if(fFilterOrder>=3) fFilterOrder = 3;
        }
        if(fActivSmooth)
        {
            if(fSmoothing == false && value == 1)
            {
                fSmoothingWindow = 3;
                fSmoothing = true;
            }
            else if(fSmoothingWindow == 3 && value == -1)
            {
                fSmoothing = false;
            }
            else if(fSmoothingWindow == 15 && value == 1) fSmoothingWindow = 15;
            else
            {
                fSmoothingWindow += 2*value;
            }
        }
        EvalBackground();
    }

    if(eventY == 0 && eventX == 0 && fActiveBGAdjustment )
    {
        InteractiveBGMode(false);
        fLasteventY = 0;fLasteventX = 0;
    }


    if(eventType == kKeyPress)
    {
        if(Key == kKey_s && !CTRL && LastKey == kKey_a && !LastCTRL)
        {
            TMethod* m = Class()->GetMethodAny("AddSourceFromNDB");
            if (m != 0x0 && fContextMenu != 0x0)
                fContextMenu->Action(this, m);
            fLasteventY = 0;fLasteventX = 0;
        }
        if(Key == kKey_l && !CTRL && LastKey == kKey_s && !LastCTRL)
        {
            TMethod* m = Class()->GetMethodAny("SavePeakList");
            if (m != 0x0 && fContextMenu != 0x0)
                fContextMenu->Action(this, m);
            fLasteventY = 0;fLasteventX = 0;
        }
        if(Key == kKey_l && !CTRL && LastKey == kKey_l && !LastCTRL)
        {
            TMethod* m = Class()->GetMethodAny("LoadPeakList");
            if (m != 0x0 && fContextMenu != 0x0)
                fContextMenu->Action(this, m);
            fLasteventY = 0;fLasteventX = 0;
        }

        if(Key == kKey_e && !CTRL && LastKey == kKey_p && !LastCTRL)
        {
            PlotEfficiencies();
        }

        if(Key == kKey_r && !CTRL && LastKey == kKey_s && !LastCTRL)
        {
            TMethod* m = Class()->GetMethodAny("SetRefpeak");
            if (m != 0x0 && fContextMenu != 0x0)
                fContextMenu->Action(this, m);
            fLasteventY = 0;fLasteventX = 0;
        }
    }


    if(eventType == kKeyPress && Key == kKey_h && !CTRL && LastKey == kKey_p && !LastCTRL)
    {
        fBashColor->SetInfoOut();
        cout<<endl;
        cout<<"[GSPlayerTUI] List of keybord commands:"<<endl;
        cout<<" ** Print this help : p + h"<<endl;
        cout<<endl;
        cout<<" ** Histogram selection **"<<endl;
        cout<<"      ==> Click on a histogram make it the active histogram (the default one is the first histogram in the list of primitives of the active pad)"<<endl;
        cout<<endl;
        cout<<" ** Histogram operations **"<<endl;
        cout<<"      ==> b + e : background evaluation"<<endl;
        cout<<"      ==> b + s : background subtraction"<<endl;
        cout<<endl;
        cout<<" ** background operation **"<<endl;
        cout<<"      ==> i + b : Starting interactive background adjustment utility"<<endl;
        if(fActiveBGAdjustment)
        {
            cout<<"      If the background adjustment utility is on:"<<endl;
            cout<<"          ==> s + i : active the iterator variations by mouse wheel"<<endl;
            cout<<"          ==> s + f : active the filter order variations by mouse wheel"<<endl;
            cout<<"          ==> s + s : active the Smoothing windowd variations by mouse wheel"<<endl;
            cout<<"          ==> s + c : active/unactive compton"<<endl;
            cout<<"          ==> s + d : change direction (BackDecreasingWindow/BackIncreasingWindow)"<<endl;
            cout<<"      Press Escape key to exit the utility"<<endl;
        }
        cout<<endl;
        cout<<" ** Peaks operations **"<<endl;
        cout<<"      ==> h + m : Hide markers"<<endl;
        cout<<"      ==> s + m : Show markers"<<endl;
        cout<<"      ==> a + s : Adding a gamma source from the nuclear database"<<endl;
        cout<<"      ==> f + a : Open fit all panel menu"<<endl;
        cout<<"      ==> a + p : Add a peak at mouse position"<<endl;
        cout<<"      ==> A + P : Add a peak + background at mouse position"<<endl;
        cout<<"      ==> CTRL ( A + P ) : Add a point to the graphical polyline"<<endl;
        cout<<"      ==> s + l : Save the peaks of the current pad the database"<<endl;
        cout<<"      ==> l + l : Load a peak list from the data base"<<endl;
        cout<<"      ==> c + a : Clear all (peaks + graphical polyline)"<<endl;
        cout<<"      ==> o + m : Open PeakCreator menu"<<endl;
        cout<<endl;
        cout<<"      ==> c + 0 : Switch Color to default #0"<<endl;
        cout<<"      ==> c + 1 : Switch Color to default #0"<<endl;
        cout<<"      ==> c + 2 : Switch Color to default #0"<<endl;
        cout<<"      ==> c + 3 : Switch Color to default #0"<<endl;
        cout<<endl;
        cout<<endl;
        cout<<" ** efficiency **"<<endl;
        cout<<"      ==> p + e : Plot efficiencies"<<endl;
        fBashColor->ResetColor();
        fLasteventY = 0;fLasteventX = 0;
    }

    fLasteventType = eventType;
    fLasteventX = eventX;
    fLasteventY = eventY;
    fLastSelectedObj = select;

}

void GSPlayerTUI::SetRefpeak(Float_t area, Float_t error)
{
    if ( fRootSP->CollectPeaks() == 0 )
        return;

    fRootSP->SortPeakList();

    TSeqCollection *PeakList = fRootSP->GetPeakList();

    BasePeak* peak = 0x0;
    TIter next(PeakList);
    while ( (peak = (Gw::BasePeak*)next()) )
    {
        if(peak->InheritsFrom("Peak1D"))
        {
            Peak1D *peak1D = (Peak1D*)peak;
            peak1D->SetRefArea(area,error);
        }
    }

    GetPlayer()->GetPeakCreator()->SetRefArea(area,error);
}


void GSPlayerTUI::InteractiveBGMode(bool ison)
{
    if(fIsConnected) DisconnectCanvas();
    if(ison)
    {
        fConnectBSP = false;
        fActiveBGAdjustment = true;
        fBashColor->SetInfoOut();
        cout<<"[GSPlayerTUI] Starting background utility"<<endl;
        cout<<"[GSPlayerTUI] Canvas connexions with other classes are closed for interferences reasons"<<endl;
        cout<<"              ==> s + i : active the iterator variations by mouse wheel"<<endl;
        cout<<"              ==> s + f : active the filter order variations by mouse wheel"<<endl;
        cout<<"              ==> s + s : active the Smoothing windowd variations by mouse wheel"<<endl;
        cout<<"              ==> s + c : active/unactive compton"<<endl;
        cout<<"              ==> s + d : change direction (BackDecreasingWindow/BackIncreasingWindow)"<<endl;
        cout<<"              Press Escape key to exit the utility"<<endl;
        fBashColor->ResetColor();
        EvalBackground();
    }
    else
    {
        fConnectBSP = true;
        fActiveBGAdjustment = false;
        fActiveIt = false; fActiveFilt = false; fActivSmooth = false;
        fBashColor->SetInfoOut();
        cout<<"[GSPlayerTUI] Ending interactive background adjustment utility !"<<endl;
        cout<<"[GSPlayerTUI] Canvas connexions with other classes have been restored"<<endl;
        fBashColor->ResetColor();
    }
    ConnectCanvas();
}


TH1 *GSPlayerTUI::EvalBackground(bool verbose)
{
    fCurrentHist = PadManager::GetHisto();
    if(fCurrentHist == 0x0) return 0x0;

    DefineBackground();
    if(verbose) PrintBGParameters();

    TString Option = "same";

    if(fDirection == TSpectrum::kBackDecreasingWindow) Option += "BackDecreasingWindow";
    else if(fDirection == TSpectrum::kBackIncreasingWindow) Option += "BackIncreasingWindow";

    if(fFilterOrder == TSpectrum::kBackOrder2) Option += "BackOrder2";
    else if(fFilterOrder == TSpectrum::kBackOrder4) Option += "BackOrder4";
    else if(fFilterOrder == TSpectrum::kBackOrder6) Option += "BackOrder6";
    else if(fFilterOrder == TSpectrum::kBackOrder8) Option += "BackOrder8";

    if(!fSmoothing) Option += "nosmoothing";
    else
    {
        if(fSmoothingWindow == TSpectrum::kBackSmoothing3) Option += "BackSmoothing3";
        else if(fSmoothingWindow == TSpectrum::kBackSmoothing5) Option += "BackSmoothing5";
        else if(fSmoothingWindow == TSpectrum::kBackSmoothing7) Option += "BackSmoothing7";
        else if(fSmoothingWindow == TSpectrum::kBackSmoothing9) Option += "BackSmoothing9";
        else if(fSmoothingWindow == TSpectrum::kBackSmoothing11) Option += "BackSmoothing11";
        else if(fSmoothingWindow == TSpectrum::kBackSmoothing13) Option += "BackSmoothing13";
        else if(fSmoothingWindow == TSpectrum::kBackSmoothing15) Option += "BackSmoothing15";
        else Option += "nosmoothing";
    }
    if(fCompton) Option += "Compton";

    fRootSP->SetNbIter(fNumberIterations);

    TH1 *OldBG = (TH1*) gPad->GetListOfPrimitives()->FindObject((TString)fCurrentHist->GetName() + "_BG");
    if(OldBG) delete OldBG;

    fBackgroundHist = fRootSP->Background(fCurrentHist,Option.Data());

    gPad->Modified();
    gPad->Update();

    return fBackgroundHist;
}


void GSPlayerTUI::SetFWHMFormula(TString name)
{
    fFWHMFormula = name;
    if(fRootSP)
    {
        fRootSP->GetPeakCreator()->SetDefaultPeakFWHM(fFWHMFormula);
    }
}


void GSPlayerTUI::AddSourceFromNDB(const char *SourceName, double EMin, double IMin, const char *option)
{
    if(gPad == 0x0)
    {
        TCanvas *c = ((TCanvas*)((TList*)gROOT->GetListOfClasses())->Last());
        if(c != 0x0) gPad = c->cd(0);
        if(gPad == 0x0) return;
    }

    TString Opt = option;

    std::vector < GammaSourceRay* > GammaList = fDataBase->GetGammaSource(SourceName,EMin,0.,Opt);

    if(GammaList.size()==0)
        return;

    if(!fCurrentHist) fCurrentHist = PadManager::GetHisto();

    if(!gPad->GetListOfPrimitives()->FindObject(fCurrentHist->GetName()))
        fCurrentHist = PadManager::GetHisto();


    TList *listofPeaks = new TList;

    GammaSourceRay *PreviousGamma = 0x0;

    for(unsigned int i=0 ; i<GammaList.size() ; i++)
    {
        GammaSourceRay *Gamma = GammaList[i];
        TString GammaName = Form("%s_%.0lf",Gamma->Emmiter.Data(),Gamma->Energy->GetValue());

        if(PreviousGamma != 0x0 && TMath::Abs(Gamma->Energy->GetValue()-PreviousGamma->Energy->GetValue())<1)
        {
            PreviousGamma->Energy->Set(0.5*(Gamma->Energy->GetValue()+PreviousGamma->Energy->GetValue()));
            PreviousGamma->Energy->SetError(0.5*sqrt(Gamma->Energy->GetError()*Gamma->Energy->GetError()+PreviousGamma->Energy->GetError()*PreviousGamma->Energy->GetError()));

            PreviousGamma->Intensity->Set(Gamma->Intensity->GetValue()+PreviousGamma->Intensity->GetValue());
            PreviousGamma->Intensity->SetError(sqrt(Gamma->Intensity->GetError()*Gamma->Intensity->GetError()+PreviousGamma->Intensity->GetError()*PreviousGamma->Intensity->GetError()));
        }
        else
        {
            Peak1D *Peak = (Peak1D*)fRootSP->GetPeakCreator()->CreatePeak(Gamma->Energy->GetValue(),"bg;ath");
            Peak->SetNameTitle(GammaName,GammaName);
            Peak->SetGammaSourceRay(Gamma);

            listofPeaks->Add(Peak);
        }

        PreviousGamma = Gamma;
    }

    const char* tab = "\t";

    fBashColor->SetInfoOut();
    cout<<endl;
    cout<<"************** Gamma source "<<SourceName<<" loaded for EGamma > "<<EMin<<" and I > "<<IMin<<endl;
    cout<<endl;

    cout<<"DecayMode"<<tab<<
          "Daughter"<<tab<<
          "RadSubType"<<tab<<
          "LifeTime"<<tab<<
          "Energy"<<tab<<tab<<
          "Intensity"<<endl;

    for(int i=0 ; i<listofPeaks->GetEntries() ; i++)
    {
        Peak1D *Peak = (Peak1D*)listofPeaks->At(i);

        GammaSourceRay *Gamma = Peak->GetGammaSourceRay();

        if(Gamma->Intensity->GetValue()<IMin)
        {
            listofPeaks->Remove(Peak);
            gPad->GetListOfPrimitives()->Remove(Peak);
            delete Peak;
            i--;
        }
        else
        {
            cout<<Gamma->DecayMode<<tab<<tab<<
                  Gamma->Daughter<<tab<<tab<<
                  Gamma->RadSubType<<tab<<tab<<
                  Gamma->LifeTime->GetValue()<<"("<<
                  Gamma->LifeTime->GetError()<<")"<<tab<<
                  Gamma->Energy->GetValue()<<"("<<
                  Gamma->Energy->GetError()<<")"<<tab<<
                  Gamma->Intensity->GetValue()<<"("<<
                  Gamma->Intensity->GetError()<<")"<<endl;
        }
    }


    cout<<"******************************************************"<<endl<<endl;

    fBashColor->ResetColor();

    gPad->Modified();
    gPad->Update();
}



void GSPlayerTUI::SavePeakList(const char *ListName)
{
    TString Name = ListName;

    if ( fRootSP->CollectPeaks() == 0 )
        return;

    fRootSP->SortPeakList();

    TSeqCollection *PeakList = fRootSP->GetPeakList();

    vector <double> Energies;

    BasePeak* peak = 0x0;
    // save parameters
    TIter next(PeakList);
    while ( (peak = (Gw::BasePeak*)next()) ) {
        Energies.push_back(peak->GetPosition());
    }

    fDataBase->SaveGammaList(Name,Energies);
}


void GSPlayerTUI::LoadPeakList(const char *ListName, const char* opt)
{
    TString Name = ListName;

    std::vector <double> Energies = fDataBase->LoadGammaList(Name);

    for(unsigned int i=0 ; i<Energies.size() ; i++)
    {
        double E = Energies[i];
        TString GammaName = Form("%s_%.0lf",Name.Data(),E);

        if(!fCurrentHist) fCurrentHist = PadManager::GetHisto();

        if(!gPad->GetListOfPrimitives()->FindObject(fCurrentHist->GetName()))
            fCurrentHist = PadManager::GetHisto();

        Peak1D *Peak = (Peak1D*)fRootSP->GetPeakCreator()->CreatePeak(E,opt);
        Peak->SetNameTitle(GammaName,GammaName);
    }

    if(Energies.size() == 0)
    {
        fBashColor->SetWarningOut();
        cout<<"Empty gamma list !"<<endl;
        fBashColor->ResetColor();
    }

    gPad->Modified();
    gPad->Update();
}

void GSPlayerTUI::PlotEfficiencies()
{

    if ( fRootSP->CollectPeaks() == 0 )
        return;

    fRootSP->SortPeakList();

    TSeqCollection *PeakList = fRootSP->GetPeakList();

    TGraphErrors *gr = new TGraphErrors;
    gr->SetName("EfficiencyPlot");
    gr->SetMarkerStyle(20);
    gr->SetMarkerColor(kRed);

    BasePeak* peak = 0x0;
    TIter next(PeakList);
    while ( (peak = (Gw::BasePeak*)next()) )
    {
        if(peak->InheritsFrom("Peak1D"))
        {
            Peak1D *peak1D = (Peak1D*)peak;

            if(peak1D->IsAGammaSourceRay())
            {
                Float_t Area = peak1D->GetPeakIntegral();
                Float_t AreaError = peak1D->GetPeakIntegralError();
                Float_t BranchingRatio = peak1D->GetGammaSourceRay()->Intensity->GetValue();
                Float_t BranchingRatioError = peak1D->GetGammaSourceRay()->Intensity->GetError();

                Float_t Energy = peak1D->GetGammaSourceRay()->Energy->GetValue();
                Float_t EnergyError = peak1D->GetGammaSourceRay()->Energy->GetError();


                cout<<"Source Information: "<<peak1D->GetGammaSourceRay()->Emmiter<<endl;
                cout<<"Energy         = "<<Energy<< "("<<EnergyError<<")"<<endl;
                cout<<"BranchingRatio = "<<BranchingRatio<< "("<<BranchingRatioError<<")"<<endl;
                cout<<"Area = "<<Area<< "("<<AreaError<<")"<<endl;

                gr->SetPoint(gr->GetN(),Energy,Area/(BranchingRatio/100.));
                gr->SetPointError(gr->GetN()-1,EnergyError,AreaError/(BranchingRatio/100.));
            }
        }
    }

    new TCanvas("EfficiencyPlot","EfficiencyPlot");
    gr->Draw("ap");
}



ClassImp(GSPlayerTUI)