LNL/ADFWatchers.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 _ADFWatchers
#define _ADFWatchers

// Watcher definition
#ifndef Gw_Watchers
#include "Watchers.h"
#endif

// ADF definitions
#ifndef ADF_AgataKeyFactory
#include "AgataKeyFactory.h"
#endif

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

using namespace ADF;
using namespace Gw;



class ADFWatcher : public Watcher
{
protected:
        SharedFP *fFrame;

public:
        ADFWatcher(): 
                Watcher("ADFWatcher","ADFWatcher"), 
                fFrame(0x0) 
                        {;}     
        ADFWatcher(const char *name, const char *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0):
                Watcher(name,title,sp_dir,tag_dir), fFrame(0x0) 
                {;}
        virtual ~ADFWatcher()
                {;}
        

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

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


class Dumper : public ADFWatcher
{       
private:
        TString fFilename; 
        Bool_t  fIsNew;
        
public:
        Dumper(const char *name = "Dumper", const char *title = "Just dump the frames in a file"):
                ADFWatcher(name,title),
                fFilename(Form("%s.adf",name)),
                fIsNew(true) 
                        {;}
        Dumper(const char *name, const char *title, TDirectory *sp_dir, TDirectory *tag_dir):
                ADFWatcher(name,title,sp_dir,tag_dir), 
                fFilename(Form("%s.adf",name)), 
                fIsNew(true)
    {
        SetActive(false) ;
    }
        virtual ~Dumper()
                        {;}
                        
        void SetOutputFile(const Char_t *filename); //*MENU*
        
        virtual void Exec(Option_t *option="");
                
        ClassDef(Dumper,0)  // Dump the frames in a file
};


class AgataKeyWatcher : public ADFWatcher
{       
private:
        const AgataKey *fKey;

private:
        static const Int_t kMaxCycle = 1000u;
        Int_t fWhichBin;
        
private:
        TRegexp fKeyFilter;
        TRegexp fSubKeyFilter;
        
private:        
        UInt_t fLastEventNumber;
        ULong64_t flastTimestamp;

private:
    Bool_t fShowGlobalConf;
        
private:        
        TH1F *fLengthFrame;
        TH1F *fKeyMessage;
        TH1D *fEventNumber;
        TH1D *fTimeStamp;
        TH1F *fCEventNumber;
        TH1F *fCTimeStamp;      
        TH1F *fCoincTimeStamp;  
        
        TH1F *fLengthSubFrame;
        TH1F *fKeyMessageSubFrame;
        
protected:
        virtual void DoCanvas(TCanvas *c, Option_t *);
        
public:
        AgataKeyWatcher(const Char_t *name, const Char_t *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~AgataKeyWatcher();
        
        void SetKeyFilter(const Char_t *keypattern = "*", const Char_t *subkeypattern = "*"); //*MENU*
        
//      virtual Bool_t SetTrigger( ADF::DFTrigger */*trigger*/ = 0x0 );

        virtual void Exec(Option_t *option="");
        
        ClassDef(AgataKeyWatcher,0)  // Watcher on AgataKey
};

#include <vector>

/*
        This Watcher keeps an array of the last timestamps for the given trigger.
        This array has to be reset (using LastValues().resize(0)) outside the class for the intance by a TSRateCollector
*/
class TSRate : public ADFWatcher
{       
private:
        std::vector < ULong64_t > fTSRates;

public:
        TSRate(const Char_t *name, const Char_t *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~TSRate() 
                {;}
        
    std::vector <ULong64_t>  &LastValues()
                { return fTSRates; }
        
        virtual void Exec(Option_t *option="");
        
        ClassDef(TSRate,0)  // to get rate using the timestamp  
};

#include "THStack.h"

/*
 */
class TSRateCollector : public Watcher 
{       
protected:
        static const ULong64_t fgkOneSecond = 100000000UL; // one second in TS unit
        
public:
        class D_Rate {
                public:
                        // number of scales on which rates are computes
                        UShort_t fNbScales; 
                
                        // scales's definitions
                        std::vector<ULong64_t> fPrecision; // in TS unit
                        std::vector<Int_t>     fNbSamples;      
                
                public:
                        D_Rate(): fNbScales(0), fPrecision(0), fNbSamples(0) 
                                {;}
                        void Add(ULong64_t precision, Int_t nb_samples) 
                                { 
                                        fNbScales++; fPrecision.push_back(precision); fNbSamples.push_back(nb_samples);
                                }
        };
        class C_Rate {  
                public:
                        std::vector<ULong64_t>  fCycle;
                        std::vector<Int_t>              fNbCounts;
                        std::vector<Double_t>   fSum;
                
                        ULong64_t fLastTS;
                public:
                        C_Rate(Int_t nb_scales = 1): fCycle(0), fNbCounts(0), fSum(0), fLastTS(0UL)
                                { Reset(nb_scales) ; }
                        void Reset(Int_t nb_scales = 1)
                                { fCycle.resize(nb_scales,0); fNbCounts.resize(nb_scales,0); fSum.resize(nb_scales,0); fLastTS = 0UL; }
        };
    
private:
        D_Rate fDefinitionRate; 
        std::vector<C_Rate> fCurrentRate;
        
private:
        TList fTSRates;
        
private:
        static const Short_t gEmptyBins = 50 ; 
        THStack fRates;
        TObjArray fPacketWidth;
        TObjArray fDeadTime;
                
private:
        ULong64_t fT0;

protected:
        Bool_t SetT0();
        
protected:
        virtual void DoCanvas(TCanvas *c, Option_t *);
        
public:
        TSRateCollector(const Char_t *name, const Char_t *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~TSRateCollector() 
                {;}
        
        void AddHook(Watcher *, const char *);
                
        virtual void Exec(Option_t *option="");
        
        ClassDef(TSRateCollector,0)  // to get rate using the timestamp 
};

class TimeStampWatcher : public ADFWatcher
{
public:

    TH1F *TimeStampHist;
    ULong64_t FirstTimeStamp;
    ULong64_t LastTimeStamp;

protected:
    virtual void DoCanvas(TCanvas *c, Option_t *);

public:
    TimeStampWatcher(const char * name, const char * title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
    virtual ~TimeStampWatcher();

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

    virtual void Zero(Option_t *opt1, Option_t *opt2); //*MENU*

    ClassDef(TimeStampWatcher,0) // To get a 3D map of hits in a particular crystal
};

#endif