LNL/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

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

// ADF definitions
#ifndef ADF_CompositeFrame
#include "CompositeFrame.h"
#endif

#ifndef ADF_PSAFrame
#include "PSAFrame.h"
#endif

// ROOT definitions
#ifndef ROOT_ArrayI
#include "TArrayI.h"
#endif

#ifndef ROOT_TH2F
#include "TH2F.h"
#endif
#include "TH3F.h"

#ifndef ROOT_TVirtualPad
#include "TVirtualPad.h"
#endif

#ifndef Gw_AgataEventDisplay
#include "AgataEventDisplay.h"
#endif

#ifndef Gw_AgataEventContainer
#include "AgataEventContainer.h"
#endif

#ifndef Gw_AgataGeometryTransformer
#include "AgataGeometryTransformer.h"
#endif
#include "MetaFrame.h"

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

using namespace ADF;
using namespace Gw;

class TTimer;

class EventPSAWatcher : public WatcherWithTag
{
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 = 50u;
        
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;
    static Float_t fgMetric;
    
protected:
    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();
    
    virtual void Exec(Option_t *option="");
    
   virtual void ShowEve(const Char_t* agataPathFile); //*MENU* *GETTER=GetPathFile* *ARGS={agataPathFile=>fPathFile}*
    
    void SetActive(Bool_t active = true); //*TOGGLE*
        
        virtual void SetMaxCycle(Int_t cycle) { fMaxCycle = cycle; } //*MENU*   
    
        virtual Int_t GetMaxCycle() { return fMaxCycle; }
        
   virtual const Char_t* GetPathFile() const { return fPathFile; }
   
    ClassDef(HitDisplay3D,0)  // psa display
};

class TGToolTip;
class TBox;
class TObject;

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:
    virtual void DoCanvas(TCanvas* canvas, Option_t* option);
    
    void AddCluster(Double_t xOffset = 0, Double_t yOffset = 0);

    void AddCristals(Double_t xPos = 0, Double_t yPos = 0);
    
    void AddRates();
    
public:
        RateDisplay(const Char_t *name, const Char_t *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
    virtual ~RateDisplay();
    
    virtual void Exec(Option_t *option="");
    
    virtual void SetDepth(Int_t depth = 1, Bool_t stop = true); //*MENU*
    
    virtual Int_t GetDepth() { return fDepth; }
  
        virtual void SetNormalization(Bool_t norm) {fNormByAll = norm;} //*TOGGLE* *ARGS={norm=>fNormByAll} *GETTER=IsNormByAll
        
        virtual Bool_t IsNormByAll() {return fNormByAll;}
    
    virtual void SetMaxCycle(Int_t cycle) { fMaxCycle = cycle; } //*MENU*
    
    virtual Int_t GetMaxCycle() { return fMaxCycle; }
  
        void SetRefresh(Long_t r); //*MENU*
  
        virtual Long_t GetRefresh() { return fRefresh; }
    
    void UpdateRates();
  
        void UpdateCanvas();
    
    void Reset();
    
    virtual void Zero(Option_t *hname="pool", Option_t *binning=""); //*MENU*
    
    virtual Bool_t SetTrigger( ADF::DFTrigger */*trigger*/ = 0x0 );
  
        void HandleMovement(Int_t eventType, Int_t eventX, Int_t eventY, TObject* select);
            
    ClassDef(RateDisplay,0)  // rate display
};

#endif