LLaBr3Watchers.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 _LLaBr3Watchers
#define _LLaBr3Watchers

// root includes
#include "TRotation.h"
#include "TH3.h"
#include "TString.h"
#include "TVector3.h"

// Gw and Watcher definition
#include "TTreeWatchers.h"
#include "RancLegnaroWatchers.h"

// a simple structure that kept all the information for one LaBr3 module
struct MyLLaBr3 {

        // position in beam reference system 
        TVector3 P;     

        // time and amplitude
        Double_t T;
        Double_t E;

        // threshold to 
        Int_t threshold_adc_min;
        Int_t threshold_adc_max;        

        // status flag to know if the detector has fired
        Bool_t   has_fired; 
        
        // used for calibration
        Double_t A, B, C;
        
        MyLLaBr3() : 
                P(), 
                T(0.0), 
                E(0.0),
                threshold_adc_min(200), 
                threshold_adc_max(20000), 
                has_fired(false),
                A(0.0), B(1.0), C(0.0) {;}
        
        // apply calibration, set is_fired to false if not a good event (i.e in threshold)
        void Calibrate () ;
};


class BaseLLaBr3Watcher : public RancLegnaroWatcher
{
public:
        // number of modules compositng 
        static const Short_t gMaxNumberOfModules = 10;
        // number of items per module (E,T)
        static const Short_t gNumberOfItems   = 2;
        // table to get for each items the position in the rawBuf vector
        static Short_t gLUT[gNumberOfItems][gMaxNumberOfModules];
        // init table to default
        static void InitLUT();
        
protected:
        // number of module for the current setting     
        Short_t fNumberOfModules;
        // one structure per module
        MyLLaBr3 fLaBr3[gMaxNumberOfModules];
        
public:
        BaseLLaBr3Watcher(const char *, const char *, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~BaseLLaBr3Watcher();

        // (re)load the current configuration
        Bool_t LoadCalibration(const char *calib_file = "LLaBr3.conf"); //*MENU*
        
        virtual void Exec(Option_t *option=""); 
        
        ClassDef(BaseLLaBr3Watcher,0)  // Base classe for LaBr3 modules as ancillary of AGATA through AGAVA
};

class DisplayLLaBr3 : public BaseLLaBr3Watcher
{
private:
        VertexBuilder *fVertexBuilder; 
        
protected:
        // histograms to check if everything is all right
        // how many channels fired
        TH1F *fCounts;
        TH1F *fHitPattern;
        TObjArray fE_no_doppler;
        TObjArray fE_doppler;
        TObjArray fT;
  
protected:
        virtual void DoCanvas(TCanvas *c, Option_t *o);
        
public:
        DisplayLLaBr3(const char *, const char *, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~DisplayLLaBr3();

        virtual void Exec(Option_t *option=""); 
        
        ClassDef(DisplayLLaBr3,0)  // 
};

class MyLLaBr3Tree : public BaseLLaBr3Watcher, public Gw::TTreeBuilder
{
private:
        Int_t fNbLaBr3;
        
        UShort_t fWhichLaBr3[gMaxNumberOfModules]; //[fNbModule]

        Float_t fELaBr3[gMaxNumberOfModules]; //[fNbModule]   
        Float_t fTLaBr3[gMaxNumberOfModules]; //[fNbModule]   

protected:
        virtual void SetBranches();

public:
        MyLLaBr3Tree(const char *name, const char *title, TTree *tree = 0x0);
        ~MyLLaBr3Tree();
        
        virtual void Exec(Option_t *option="");
        
        ClassDef(MyLLaBr3Tree,0)  // Built the Dante Branch
};


#endif