GANIL/EventPSAWatchers.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 _EventPSAWatchers
#define _EventPSAWatchers

#include "Watchers.h"
#include "CompositeFrame.h"
#include "PSAFrame.h"
#include "CanvasVisu.h"
#include "TF1.h"

#include "AgataGeometryTransformer.h"


class TObjArray;
class TPaveText;
class TLatex;
class VertexBuilder;

using namespace ADF;
class TTimer;




class EventPSAWatcher : public WatcherWithTag
{
protected:
    static Float_t fgMetric;

protected:
        Frame *fPSAFrame; 
        
protected:
        SharedFP *fFrame; 
        
protected:
        UInt_t GetNbFramePSA();
  
        PSAInterface *GetDataPSA(UInt_t which); 

public:
        EventPSAWatcher(const char *name, const char *title,  TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0) : 
                WatcherWithTag(name,title,sp_dir,tag_dir), 
                fPSAFrame(0x0), 
                fFrame(0x0) 
                        {;}
        virtual ~EventPSAWatcher()
        { 
                        if (fPSAFrame) 
                                delete fPSAFrame; 
                fPSAFrame = 0x0; 
        }
        

        virtual Bool_t SetTrigger( ADF::DFTrigger */*trigger*/ = 0x0 );
                
        ClassDef(EventPSAWatcher,0)  // Trigger on tracked Frame
};




class HitsSpectra : public EventPSAWatcher
{
    static const UShort_t gNbCrys = 180u;
        
private:
        VertexBuilder *fVertexBuilder;
        
protected:
        AgataGeometryTransformer *fTrans;
        
protected:
        TObjArray fSpectra;
        TObjArray fSpectraDoppler;

    TH1 *fCoreCommon;
    TH1 *fSumSpectra;

    TH2 *fGxG;
    TH2 *fGxT;
    TH1 *fCoreCommonDoppler;
        TH2 *fGxGDoppler;

    TH1 *fFold; 
    
        TH1F *fDistri;
    TH3F *fPosXYZ;
    TH3F *fPosXYZ_Ta;
        
protected:
    virtual void DoCanvas(TCanvas *c, Option_t *);
 
protected:      
        virtual Double_t DoDopplerCorrection(const TrackedHit *hit, VertexInterface *vertex);
   
public:
        HitsSpectra(const char *name, const char *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~HitsSpectra();
        
        virtual void Exec(Option_t *option="");
                
        ClassDef(HitsSpectra,0)  // Gamma-rays spectra using hits
};



//class HitDisplay3D : public EventPSAWatcher
//{
    
//private:
//    AgataGeometryTransformer*  fTrans;
        
//    Int_t fMaxCycle;
      
//    const Char_t* fPathFile;
    
//protected:
//    //! To be overwritten by real implementation if a canvas is produced.
//    virtual void DoCanvas(TCanvas *c, Option_t *);
    
//public:
//    HitDisplay3D(const char *name, const char *type, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
//    virtual ~HitDisplay3D();
    
//    //! watch the current frame
//    virtual void Exec(Option_t *option="");
    
//   //! show eve event display
//   virtual void ShowEve(const Char_t* agataPathFile); //*MENU* *GETTER=GetPathFile* *ARGS={agataPathFile=>fPathFile}*
    
//      //! Toggle active task
//    void SetActive(Bool_t active = true); //*TOGGLE*
        
//    //! Set max cycle, before resetting buffer
//      virtual void SetMaxCycle(Int_t cycle) { fMaxCycle = cycle; } //*MENU*
    
//      //! Get max cycle
//      virtual Int_t GetMaxCycle() { return fMaxCycle; }
        
//   //! Get Prima conf file
//   virtual const Char_t* GetPathFile() const { return fPathFile; }
   
//    ClassDef(HitDisplay3D,0)  // psa display
//};



//class TGToolTip;
//class TBox;
//class TObject;
// A schematic view of a triple cluster is drawn (a hexagon per crystal) the size of the triangle inside each sector
// is proportional to the counts inside this sector for a given depth. This latter could be set via the menu.
// Default wise the depth change for a given range of time in seconds (SetRefresh in Menu). To watch a single depth
// use SetDepth method, it stops the automatic refresh. To launch again this refresh use SetRefresh method.
// There are two ways of normalization. Default wise the rates in each sector is normalized onto the maximum counts
// found in all crystals. By setting in Menu via the method SetNormalization, the rates are normalized onto the maximum
// of counts for each individual crystal.
// Depth equal to zero correspond to the rate in core.
 
//*/
//class RateDisplay : public EventPSAWatcher
//{
//private:
    
//    TObjArray* fSectorList;      // container of detector sector Polyline
    
//    TObjArray* fLabelList;       // container of label crystal PaveText
    
//    TObjArray* fRateList;        // container of rate sector Polyline
    
//    AgataGeometryTransformer* fTransf; // geometry transformer
    
//    TArrayI*   fCountArray[7];   // count array for each sector for a given depth
    
//    TArrayI*   fCountMax;        // max count per crystal
    
//      Int_t      fCountCoreMax;    // max count for core
  
//      Int_t      fCountMaxAll;     // max count in all cristals

//    Int_t      fCurrentCycle;    // current number of cycles
    
//    Int_t      fMaxCycle;        // maximum number of cycles before resetting histo
    
//    Int_t      fDepth;           // depth number of the crystal
  
//      Bool_t     fNormByAll;       // fNorm: true, count normalized by the maximum of all cristals; false, normalized per cristal

//      TTimer*    fTimer;           // timer

//      Long_t     fRefresh;         // time lapse between two depth refreshes in seconds
    
//      TLatex*    fDepthText;       // text for depth
  
//      Int_t      fLastX;           // last position of mouse in X
  
//      Int_t      fLastY;           // last position of mouse in Y
  
//      TBox* fBox;                  // just a box for tool tip

//      TGToolTip* fInfoTip;         // info tool tip


//    TH1I*      fHistoCntCrystal; // number of counts per crystal
    
//    TH1I*      fHistoCntSlice[180*6*6]; // number of counts in each detector per depth and per sector

//private:
//    const ADF::NamedItem<UShort_t>* fCrysID;  //!
//    const ADF::NamedItem<Float_t>*  fCoreE1;  //!
    
//private:
//    static const Double_t fgkDRho;       // distance between two crystal
//    static const Double_t fgkRho1;       // inner radius of the sector
//    static const Double_t fgkRho2;       // outer radius of the sector
//    static const Double_t fgkDRange;     // range of the pad
//    static const Int_t    fgkNofPoints;  // number of points of the polyline for a sector
//    static const Int_t    fgkNofSectors; // total number of sectors
//    static const Int_t    fgkNofCrystals;// total number of crystals
//    static const Int_t    fgkNofSlices;  // total number of slices (= number of depths-1, depth = 0 for core)
//    static const Int_t    fgkNDivX;      // number of clusters displayed in X
//    static const Int_t    fgkNDivY;      // number of clusters displayed in Y
    
//protected:
//    //! To be overwritten by real implementation if a canvas is produced.
//    virtual void DoCanvas(TCanvas* canvas, Option_t* option);
    
//    //! Add sectors for a cluster to list
//    void AddCluster(Double_t xOffset = 0, Double_t yOffset = 0);

//    //! Add cluster at a given position to list
//    void AddCristals(Double_t xPos = 0, Double_t yPos = 0);
    
//    //! Add polyline rate object list
//    void AddRates();
    
//public:
//      RateDisplay(const Char_t *name, const Char_t *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
//    virtual ~RateDisplay();
    
//    //! watch the current frame
//    virtual void Exec(Option_t *option="");
    
//    //! Set depth
//    virtual void SetDepth(Int_t depth = 1, Bool_t stop = true); //*MENU*
    
//    //! Get depth
//    virtual Int_t GetDepth() { return fDepth; }
  
//      //! Set normalization of counts per all crystals (true) or per each crystal (false)
//      virtual void SetNormalization(Bool_t norm) {fNormByAll = norm;} //*TOGGLE* *ARGS={norm=>fNormByAll} *GETTER=IsNormByAll
        
//      //! return normalization
//      virtual Bool_t IsNormByAll() {return fNormByAll;}
    
//    //! Set max cycle
//    virtual void SetMaxCycle(Int_t cycle) { fMaxCycle = cycle; } //*MENU*
    
//    //! Get max cycle
//    virtual Int_t GetMaxCycle() { return fMaxCycle; }
  
//      //! Set Refresh
//      void SetRefresh(Long_t r); //*MENU*
  
//      //!Get Refresh
//      virtual Long_t GetRefresh() { return fRefresh; }
    
//    //! Update rates
//    void UpdateRates();
  
//      //! Update canvas
//      void UpdateCanvas();
    
//    //! reset
//    void Reset();
    
//    //! Zero
//    virtual void Zero(Option_t *hname="pool", Option_t *binning=""); //*MENU*
    
//    //! Set the trigger attached to this watcher
//    virtual Bool_t SetTrigger( ADF::DFTrigger */*trigger*/ = 0x0 );
  
//      //! Handle Movement
//      void HandleMovement(Int_t eventType, Int_t eventX, Int_t eventY, TObject* select);
            
//    ClassDef(RateDisplay,0)  // rate display
//};


class EBWatcher : public EventPSAWatcher, public CanvasVisu
{
    static const UShort_t gNbCrys = 180u;

private:
    VertexBuilder *fVertexBuilder;

protected:
    AgataGeometryTransformer *fTrans;

protected:
    TObjArray fSpectra;

    TH1 *fCoreCommon;
    TH1 *fSumSpectra;

    TH2 *fGxG;
    TH2 *fGxT;

    TH1 *fFold; 

    TH1F *fDistri;
    TH3F *fPosXYZ_Ta;

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

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

    void ShowCrystalSpectra();  //*MENU*
    virtual void SetLoupe(bool loupeon = true){CanvasVisu::SetLoupe(loupeon);}  //*MENU*

    void ShowSuperimposedCores(); //*MENU*

    void ShowCoreVsSumSpectra(bool OnSamePad = false);  //*MENU*

    void ShowGammaGamma();  //*MENU*

    void ShowGammaTime();  //*MENU*

    void Show3DHits();  //*MENU*




    ClassDef(EBWatcher,0)  // Gamma-rays spectra using hits
};



#include "TLine.h"

class TimeCheckBuilder : public EventPSAWatcher, public CanvasVisu
{
    static const UShort_t gNbCrystTot = 180u;
    static const UShort_t gNbSeg = 36u;

private:
    UShort_t gNbCrys;
    TString CrystalNames[gNbCrystTot];

    ULong64_t fFirstTS[gNbCrystTot];
    ULong64_t fLastTS[gNbCrystTot];
    ULong64_t fTS;

    Double_t fTSMax[gNbCrystTot];

    TString fCrystalList;
    TString fCrystalListForSegments;

    Int_t fTSWindow;
    Int_t fDeltaTS;

    Int_t fTotalHistPos;
    Int_t fGraphPos;
    Int_t fNToFill;

    Bool_t fGoodInit;

    TList *fListOfHists;

    TObjArray *f_TS_Dist[gNbCrystTot];
    TObjArray *f_CoreCheck[gNbCrystTot];
    TObjArray *f_SegCheck[gNbCrystTot][gNbSeg];
    TH1F *fSpectra[gNbCrystTot];
    TLine *fCoreLines[gNbCrystTot];
    TH1F *fLastFittedHist[gNbCrystTot];
    TF1 *fLastFitFunction[gNbCrystTot];

    Float_t fERef;
    Float_t fLastFitResultCore[gNbCrystTot][4];
    Float_t fLastFitResultSeg[gNbCrystTot][gNbSeg][4];

    TF1 *fGausFuncCry[gNbCrystTot];
    TF1 *fGausFuncSeg[gNbCrystTot][gNbSeg];

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

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

    void ShowCrystalSpectra();  //*MENU*
    void ShowCrystalLastFits();  //*MENU*
    void ShowSegments(const char *CrystalName);  //*MENU*
    virtual void SetLoupe(bool loupeon = true){CanvasVisu::SetLoupe(loupeon);}  //*MENU*


private:
    void ReadConfFile();
    TObjArray *BuildArray(const char * BaseName,Int_t NBins, Double_t Min, Double_t Max, Bool_t MakeGraph);
    void ReProcessHists(Int_t cry);
    Int_t GetNFill(Int_t cry);
    void AnalyseGraphs(Int_t cry);

    TString  GetCrystalName(Int_t cry);
    Int_t GetCrystalId(TString Name);



    ClassDef(TimeCheckBuilder,0)  // Gamma-rays spectra using hits
};

#endif