MyTree.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 _MyTree
#define _MyTree

#include "TTreeWatchers.h"
#include "AgataKeyFactory.h"
#include "DanteWatchers.h"
#include "TrackedWatchers.h"
#include "EventPSAWatchers.h"
#include "EventWatchers.h"

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


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



class DoMyRawAncillaryTree : public RancLegnaroWatcher, public TTreeBuilder
{               
protected:
        ULong64_t fTimestamp;

protected:
        virtual void SetBranches();
        
public:
        DoMyRawAncillaryTree(const char *name, const char *title, TTree *tree = 0x0);
        virtual ~DoMyRawAncillaryTree();
    
        virtual void Exec(Option_t *option="");
    
        ClassDef(DoMyRawAncillaryTree,0)  // built a raw root tree for the ancillary part
};


class DoMyAncillaryTree : public BaseDanteWatcher, public TTreeBuilder
{       
protected:
        ULong64_t fTimestamp;
        
private:
        Float_t DR; // the data to be set in the tree
        Float_t DTheta; 
        Float_t DPhi;   
        
protected:
        virtual void SetBranches();
        
public:
        DoMyAncillaryTree(const char *name, const char *title, TTree *tree = 0x0);
        virtual ~DoMyAncillaryTree();
    
        virtual void Exec(Option_t *option="");
    
        ClassDef(DoMyAncillaryTree,0)  // built a root tree for the ancillary part
};


class DoMyTrackTree : public TrackedWatcher, public TTreeBuilder
{       
private:
        VertexBuilder *fVertexBuilder;
        
protected:
        ULong64_t fTimestamp;
        
private:
        static const Int_t MaxGamma = 500;
        Int_t    number_of_gammas;      // 
        Float_t  gammaE[MaxGamma];
        Float_t  gammaEDC[MaxGamma];    
        Float_t gammaX1[MaxGamma];
        Float_t gammaY1[MaxGamma];
        Float_t gammaZ1[MaxGamma];
        Float_t gammaX2[MaxGamma];
        Float_t gammaY2[MaxGamma];
        Float_t gammaZ2[MaxGamma];      
        
protected:
        virtual void SetBranches();
        
public:
        DoMyTrackTree(const char *name, const char *title, TTree *tree = 0x0);
        virtual ~DoMyTrackTree();
        
        virtual void Exec(Option_t *option="");
    
        ClassDef(DoMyTrackTree,0)  // built a root tree for the gamma part
};


class DoMyHitTree : public EventPSAWatcher, public TTreeBuilder
{

private:
        VertexBuilder *fVertexBuilder;

protected:
        ULong64_t fTimestamp;
        AgataGeometryTransformer *fTrans;
        
private:
        static const Int_t MaxHits = 500;
        Int_t number_of_hits; //Total hit number in AGATA
        Int_t mult_gamma;  //for more than 1 frame (built event)
        Float_t hitE[MaxHits];
        Float_t hitX[MaxHits];
        Float_t hitY[MaxHits];
        Float_t hitZ[MaxHits];
  Int_t hit_per_cryst[MaxHits]; //Number of hit for each psa frame, for each cryst ID
        Int_t hitId[MaxHits];
        Int_t hitSg[MaxHits];
  Float_t coreE0[MaxHits];
  Float_t coreE1[MaxHits];

  Float_t MhitX[MaxHits]; //Position x of hit with , in global frame
  Float_t MhitY[MaxHits]; //Position y of hit with , in global frame
  Float_t MhitZ[MaxHits]; //Position z of hit with , in global frame
  Float_t velDop[MaxHits]; //Beta for the doppler correction
  Float_t coreDE0[MaxHits]; //Doppler with position from Hit with Max E
  Float_t coreDE1[MaxHits]; //Doppler with position from Hit with Max E


  // 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:
        DoMyHitTree(const char *name, const char *title, TTree *tree = 0x0);
        virtual ~DoMyHitTree();
        
        virtual void Exec(Option_t *option="");

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


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

#endif