ADTree.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 _ADTree
#define _ADTree

#include "TTreeWatchers.h"
#include "Watchers.h"
#include "TrackedWatchers.h"
#include "EventPSAWatchers.h"
#include "PSAWatchers.h"
#include "CrystalWatchers.h"
#include "EventWatchers.h"

#include "AgataKeyFactory.h"


class ADKeyTree : public Watcher, public TTreeBuilder
{
private:
        SharedFP *fFrame;
        const AgataKey *fKey;
private:
        UInt_t fEventNumber;    // Event Numver
        ULong64_t fTimestamp;   // Timestamp
        
protected:
        virtual void SetBranches();
        
public:
        ADKeyTree(const char *name, const char *title, TTree *tree = 0x0);
        virtual ~ADKeyTree()
        {;}
        
        virtual Bool_t SetTrigger( ADF::DFTrigger * /*trigger*/ = 0x0 );
        
        virtual void Exec(Option_t *option="");
    
        ClassDef(ADKeyTree,0)  // built a root tree for the key part
};


//#define CHECK_COMMISSIONING_GANIL


class ADTrackTree : public TrackedWatcher, public TTreeBuilder
{
private:
        VertexBuilder *fVertexBuilder;
        
protected:
        ULong64_t fTimestamp;
        
private:
        static const Int_t MaxGamma = 500;
    
        Int_t    nbTrack;      // Current number of tracked gamma-rays
        Float_t  trackE[MaxGamma];      // Energies of the tracked gamma
        Float_t  trackEDC[MaxGamma];    // Energies with Doppler Correction
        Float_t trackX1[MaxGamma];      // X position of the first interaction point
        Float_t trackY1[MaxGamma];      // Y position of the first interaction point
        Float_t trackZ1[MaxGamma];      // Z position of the first interaction point
        Float_t trackX2[MaxGamma];      // X position of the second interaction point. Used for polarisation
        Float_t trackY2[MaxGamma];      // Y position of the second interaction point. Used for polarisation
        Float_t trackZ2[MaxGamma];      // Z position of the second interaction point. Used for polarisation
        Float_t trackXS[MaxGamma];      // X position of the source emitting g-rays. To check things
        Float_t trackYS[MaxGamma];      // Y position of the source emitting g-rays. To check things
        Float_t trackZS[MaxGamma];      // Z position of the source emitting g-rays. To check things
        Float_t cosTheta[MaxGamma];     // cosTheta between recoil and gamma
    
    Float_t  trackT[MaxGamma];      // time of the track gamma
        Int_t  trackCrystalID[MaxGamma];  // CrystalID of the first interaction point of the track
    
#ifdef CHECK_COMMISSIONING_GANIL
        static const Int_t MaxG = 45;
        Float_t  Eg[MaxG];
        Float_t  Eg1[MaxG];
        Float_t  EgA[MaxG];
#endif
    
protected:
        virtual void SetBranches();
        
public:
        ADTrackTree(const char *name, const char *title, TTree *tree = 0x0);
        virtual ~ADTrackTree();
        
        virtual void Exec(Option_t *option="");
    
        ClassDef(ADTrackTree,0)  // built a root tree for the gamma part
};


class ADHitTree : public EventPSAWatcher, public TTreeBuilder
{
private:
        VertexBuilder *fVertexBuilder;
    
protected:
        ULong64_t fTimestamp;
        AgataGeometryTransformer *fTrans;
        
private:
        static const Int_t MaxHits = 500; // Max number of hits in one event
        static const Int_t MaxCore = 180; // Max number of cores in one event
    
    //
        Int_t nbHits;                   // Number of hits in the array
    Float_t ESum;                 // Sum of all hit (for calorimeter mode)
        Float_t hitE[MaxHits];          // Energie of the hit
        Float_t hitX[MaxHits];          // X position of the hit in the Crystal Frame
        Float_t hitY[MaxHits];          // Y position of the hit in the Crystal Frame
        Float_t hitZ[MaxHits];          // Z position of the hit in the Crystal Frame
    Float_t hitGX[MaxHits];         // Position x of hit with , in global frame
    Float_t hitGY[MaxHits];         // Position y of hit with , in global frame
    Float_t hitGZ[MaxHits];         // Position z of hit with , in global frame
        Int_t hitId[MaxHits];           // Segment ID in which a hit occurs
        Int_t hitSg[MaxHits];           // Crystal ID in which a hit occurs
    //
        Int_t nbCores;                  // for more than 1 frame (built event)
    Int_t coreId[MaxCore];          // for each crystal fired its ID
    Float_t coreE0[MaxCore];        // Core energie, high gain ... TODO, Should be one !
    Float_t coreE1[MaxCore];        // Core energie,  low gain ... TODO, Should be one !
    Float_t coreT0[MaxCore];
    Float_t coreT1[MaxCore];
    Float_t coreDE0[MaxCore];       // Doppler with position from Hit with Max E
    Float_t coreDE1[MaxCore];       // Doppler with position from Hit with Max E
    //
    Float_t velDop[MaxCore];        // Beta for the doppler correction
    Int_t hit_per_cryst[MaxCore];   // Number of hits for each cryst ID i.e. dans each data:psa frames
    
private:
    // Spectra on the Hit tree. Used here since no tracking yet.
    TH1 *fIdSpectra;
    TH1 *fSumSpectra;
        TH3F *fhitAgata;  // spectra with some position in agata ref: wall, target, Gamma
    
protected:
        virtual Double_t DoDopplerCorrection(const TrackedHit *hit, VertexInterface *vertex);
    //
        virtual void SetBranches();
    
public:
        ADHitTree(const char *name, const char *title, TTree *tree = 0x0);
        virtual ~ADHitTree();
        
        virtual void Exec(Option_t *option="");
    
    void FillSpectraByUser();
    
        ClassDef(ADHitTree,0)  // built a root tree for the gamma part
};


class ADCoincTree : public EventWatcher, public TTreeBuilder
{
protected:
        Float_t fTSCoinc;
        
protected:
        virtual void SetBranches();
        
public:
        ADCoincTree(const char *name, const char *title, TTree *tree = 0x0);
        virtual ~ADCoincTree();
        
        virtual void Exec(Option_t *option="");
        
        ClassDef(ADCoincTree,0)  // quantities compted from coincidences between agata and ancillary
};


class ADPSAHitTree : public PSAWatcher, public TTreeBuilder
{

protected:
    ULong64_t fTimestamp;
    Int_t fEfvtNbr;

private:
    static const Int_t MaxHits = 500;

    Int_t number_of_hits;           // Number of hits in the array
    Float_t hitE[MaxHits];          // Energie of the hit
    Float_t hitX[MaxHits];          // X position of the hit in the Crystal Frame
    Float_t hitY[MaxHits];          // Y position of the hit in the Crystal Frame
    Float_t hitZ[MaxHits];          // Z position of the hit in the Crystal Frame
    Int_t hitSg[MaxHits];           // Crystal ID in which a hit occurs
    Float_t coreE0;                 // Core energie, high gain ... TODO, Should be one !
    Float_t coreE1;                 // Core energie,  low gain ... TODO, Should be one !
    Float_t coreT0;                 // Core time, high gain ... TODO, Should be one !
    Float_t coreT1;                 // Core time,  low gain ... TODO, Should be one !

protected:
    virtual void SetBranches();

public:
    ADPSAHitTree(const char *name, const char *title, TTree *tree = 0x0);
    virtual ~ADPSAHitTree();

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

    void FillSpectraByUser();

    virtual void Print(Option_t *option="") const;  //*MENU*

    ClassDef(ADPSAHitTree,0)  // built a root tree for the gamma part
};


class ADCrystalTree : public ShowSignals, public TTreeBuilder
{
public:
  static const int kNCC = ADF::CrystalInterface::kNbCores;
  static const int kNSG = ADF::CrystalInterface::kNbSegments;
  static const int kNSamples = 100;

protected:
    ULong64_t fTimestamp;
    Int_t fEfvtNbr;

private:
    Float_t SegmentTraces[kNSG*kNSamples];
    Float_t CoreTraces[kNCC*kNSamples];

    Double_t SegBaselines[kNSG];
    Double_t CoreBaselines[kNCC];

    Double_t SegE[kNSG];
    Double_t CoreE[kNCC];

protected:
    virtual void SetBranches();

public:
    ADCrystalTree(const char *name, const char *title, TTree *tree = 0x0);
    virtual ~ADCrystalTree();

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

    void FillSpectraByUser();

    void ConvertInGraph(TH1 *h, TGraph *g);

    virtual void Print(Option_t *option="") const;  //*MENU*

    ClassDef(ADCrystalTree,0)  // built a root tree for the gamma part
};

#endif