ILLWatchers.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.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.             *
 ***************************************************************************/

#ifndef _EXOILLWatchers
#define _EXOILLWatchers

// NOMAD
 #include "NOMADMap.h"

// Watcher definition
#include "Watchers.h"
#include "TTreeWatchers.h"

// ROOT definitions
#include "TH1.h"
#include "TH2.h"
#include "TRegexp.h"
#include "TList.h"

using namespace ADF;
using namespace Gw;


class BaseEXOILLWatcher : public Watcher
{
protected:
        NOMADMap fMap;

protected:
        SharedFP *fFrame;

protected:
        Bool_t fIsEvent;
        
protected:
        ULong64_t fCurrentTS;
        UInt_t fNbSubEvent;
        std::vector< NOMADEvent > fEvent;
        std::vector< NOMADEvent *> fGEEvent;
        std::vector< NOMADEvent *> fACEvent;
        std::vector< NOMADEvent *> fLAEvent;

public:
        BaseEXOILLWatcher(): 
                Watcher("BaseEXOILLWatcher","BaseEXOILLWatcher"), 
                fMap(),
                fFrame(0x0),
                fIsEvent(false),
                fNbSubEvent(0u),
                fEvent(0u),
        fGEEvent(0u),
        fACEvent(0u),
        fLAEvent(0u)
                        { LoadConfig(); }       
        BaseEXOILLWatcher(const char *name, const char *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0):
                Watcher(name,title,sp_dir,tag_dir), 
                fFrame(0x0) 
                        {;}
        virtual ~BaseEXOILLWatcher()
                        {;}

        virtual Bool_t LoadConfig(const Char_t *fname = "EXOILLWatcher.conf"); 
        

        virtual Bool_t SetTrigger( ADF::DFTrigger * /*trigger*/ = 0x0 );

        virtual void Exec(Option_t * option="");

        ClassDef(BaseEXOILLWatcher,0)  // Watcher on any kind of Frames
};


class DoEXOILLCalib : public BaseEXOILLWatcher
{
        static const Int_t time_depth = 15; // have to be even 

private:
        std::vector< ULong64_t > fTimelineUID;
        std::pair<UShort_t, ULong64_t> fTimeline;

private:
        TH1 *fUIDDistri;
        TH1 *fFoldDistri;
        TObjArray fADCSpectra;
        TObjArray fESpectra;
        TObjArray fTSSpectra;
private:
        Double_t fSigma;
        Double_t fThreshold;
        
protected:
        void  FindCo60(TH1 *h, TList &list_of_peaks);
        void FindEu152(TH1 *h, TList &list_of_peaks, const TF1 *fcalib);
        void FindBaCl2(TH1 *h, TList &list_of_peaks, const TF1 *fcalib);

        void Calibrate(TH1 *h, TF1 *function, const TList & peaks);
        
public:
        DoEXOILLCalib(const char *name, const char *title);
        virtual ~DoEXOILLCalib()
                {;}

        virtual void Exec(Option_t * option="");

        void ProcessDisplayPeaks(Int_t np_peaks, const Double_t peaks[], Option_t *fit);


        void AlignTS(Option_t * opt = "dry", Option_t *algo = "mean"); // *MENU*

        void Calib(const Char_t *what_source = "Co60", Option_t * opt = "dry",  Option_t* DefFileName = "CalibStorage.txt"); // *MENU* 
        
        void SearchParameters(Double_t sig = 2.0, Double_t thre = 0.05); // *MENU*

        void DisplayPeaks(Option_t *opt = "BaCl", Option_t *fit = "fitted" ); // *MENU*

        void SaveMAP(const Char_t *fname = "NOMADMap.conf.new", Option_t *opt = ""); // *MENU*

        ClassDef(DoEXOILLCalib,0)  // built spectra for calibration + method to calib
};


class RawMatrices : public BaseEXOILLWatcher
{
private:
        TH1 *fFoldDistri;
        TH2 *fGG;       
        TH2 *fGT;       
        TH2 *fUIDT;
        TH2 *fUIDUID;

        TH2 *fGeELaE;
        TH2 *fGeELaT;
    
        
public:
        RawMatrices(const char *name, const char *title);
        virtual ~RawMatrices()
                {;}

        virtual void Exec(Option_t * option="");

        ClassDef(RawMatrices,0)  // built gamma - gamma matrix
};


class GatedGG : public BaseEXOILLWatcher
{
private:
        static const Int_t fConditions = 1;
private:
        std::vector< std::pair<Float_t, Float_t> > fListOfGates;
        
private:
        TH2 *fGG;       
        
public:
        GatedGG(const char *name, const char *title);
        virtual ~GatedGG()
        {;}
        
        virtual void Exec(Option_t * option="");
        
        ClassDef(GatedGG,0)  // built a gated gg matrix
};


class MyILLTree : public BaseEXOILLWatcher, public TTreeBuilder
{
private:
        static const Int_t MaxGamma = 500;
        
        ULong64_t TS;
        Int_t FOLD;
        Int_t    DT [MaxGamma]; 
        Float_t  E  [MaxGamma];
        Int_t    ID [MaxGamma];
        
protected:
        virtual void SetBranches();
        
public:
        MyILLTree(const char *name, const char *title, TTree *tree = 0x0);
        virtual ~MyILLTree()
                {;}
        
        virtual void Exec(Option_t * option="");
        
        ClassDef(MyILLTree,0)  // to build a TTree
};

#endif