DanteWatchers.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 _DanteWatchers
#define _DanteWatchers

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

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

// a simple structure that kept all the information for one Dante module
struct MyDante {
        
        // position in dante reference system (provided by dante)
        Double_t X; 
        Double_t Y;
        Double_t Z;
        // position in beam reference system (calculated in this watcher)
        Double_t Xr; 
        Double_t Yr;
        Double_t Zr;    
        
        // time and amplitude
        Double_t T;
        Double_t A;
        
        // status flag to know if the detector has fired
        Bool_t   has_fired; 
        
        // used for calibration
        Double_t threshold_adc;
        
        Double_t threshold_x_left; 
        Double_t threshold_x_right;
        Double_t threshold_y_down; 
        Double_t threshold_y_up;   
        
        // used for calibration
        Double_t AX, BX, CX;
        Double_t AY, BY, CY;
        
        MyDante() : 
        X(0.0), 
        Y(0.0), 
        Z(0.0), 
        Xr(0.0), 
        Yr(0.0), 
        Zr(0.0), 
        T(0.0), 
        A(0.0),
        has_fired(false),
        threshold_adc(200.0), 
        threshold_x_left(-100.0),
        threshold_x_right(100.0),
        threshold_y_down(-100.0),
        threshold_y_up(100.0),
        AX(0.0), BX(1.0), CX(0.0),
        AY(0.0), BY(1.0), CY(0.0) {;}
        
        // apply calibration, set is_fired to false if not a good event (i.e in threshold)
        void Calibrate () ;
};


class BaseDanteWatcher : public RancLegnaroWatcher
{
public:
        // number of modules compositing DANTE
        static const Short_t gMaxNumberOfModules = 5;
        // number of items per module (X,Y,T,A)
        static const Short_t gNumberOfItems   = 4;
        // 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();
        
        // Rotations 
        // 0 is Z, 1 is Y, 2 is Z and 4 is X
        TRotation fRotation_tmp[4][gMaxNumberOfModules]; // tmp waiting for a single matrix to be tested
        TRotation fRotation[gMaxNumberOfModules];
        
protected:
        // number of module for the current setting     
        Short_t fNumberOfModules;
        // one structure per module
        MyDante fDante[gMaxNumberOfModules];
protected:
        // Compute true postion of the recoil in beam reference system
        void ComputeRealPosition(Short_t); 
        
public:
        BaseDanteWatcher(const char *, const char *, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~BaseDanteWatcher();
        
        // (re)load the current configuration
        Bool_t LoadCalibration(const char *calib_file = "Dante.conf"); //*MENU*
        
        virtual void Exec(Option_t *option=""); 
        
        ClassDef(BaseDanteWatcher,0)  // Base class to get Dante Data
};

//class Gw::AgataEventDisplay;


class DisplayDante : public BaseDanteWatcher
{
protected:
        
        // histograms to check if everything is all right
        // how many channels fired
        TH1F *fCounts;
        // positions in 2D for each module
        TObjArray *fPositions;
        TObjArray *fPositionsC;
        // positions in 3D space (beam reference)
        TH3F *fPos3D;   
        
        TH1F *fR;
        TH1F *fTheta;
        TH1F *fPhi;
        TH2F *fThetaxPhi;
        
        TString fTypeName;  
        Int_t fMaxCycle; 
        const Char_t* fConfFileName;
        const Char_t* fPathFile;
        
private:
        static Float_t fgMetric;
        
protected:
        virtual void DoCanvas(TCanvas *c, Option_t *o);
        
public:
        DisplayDante(const char *, const char *, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~DisplayDante();
        
        virtual void Exec(Option_t *option=""); 
        
   virtual void ShowEve(const Char_t* danteConfFile, const Char_t* agataPathFile); //*MENU* *GETTER=GetConfFileName,GetPathFile* *ARGS={danteConfFile=>fConfFileName,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* GetConfFileName() const { return fConfFileName; }
   
   virtual const Char_t* GetPathFile() const { return fPathFile; }
   
        ClassDef(DisplayDante,0)  // Display some spectra specific to DANTE
};

class MyDanteTree : public BaseDanteWatcher, public Gw::TTreeBuilder
{
private:
        Int_t fNbDante;
        
        UShort_t *fWhichDante; //[10]
        // hit in the dante module in global reference system
        Float_t *fDanteXr; //[10]   
        Float_t *fDanteYr; //[10]   
        Float_t *fDanteZr; //[10]   
        // amplitude of the signal
        Float_t  *fDanteA; //[10]   
        // calibrated poistion in the module reference system
        Float_t *fDanteXc; //[10]   
        Float_t *fDanteYc; //[10]   
        
        Float_t fDanteBeta; //      
        
protected:
        virtual void SetBranches();
        
public:
        MyDanteTree(const char *name, const char *title, TTree *tree = 0x0);
        ~MyDanteTree();
        
        
        virtual void Exec(Option_t *option="");
        
        ClassDef(MyDanteTree,0)  // Built the Dante Branch
};


class DoDanteDoppler : public BaseDanteWatcher, public VertexBuilder
{       
protected:
        Double_t fMeanBeta;
        
public:
        DoDanteDoppler(const char *, const char *, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~DoDanteDoppler() 
        {;}
        
        Double_t GetMeanBeta() const 
        { return fMeanBeta; }
        void SetMeanBeta(Double_t mean) 
        { fMeanBeta = mean; }
        
        void ChangeMeanBeta(Double_t b); //*MENU* *ARGS={b=>fMeanBeta}
        
        virtual void Exec(Option_t *option=""); 
        
        ClassDef(DoDanteDoppler,0)  // 
};




#endif