GSIPrespecWatchers.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 _GSIPrespecWatchers
#define _GSIPrespecWatchers

// Gw and Watcher definition
#include "GSIWatchers.h"
//Test of maybe missing include
#include "MetaWatchers.h"
//class VertexBuilder;

class UnpackData;
class PhDUnpacker;
class SortData;
class SortClass;
class FRSCalibrData;
class FRSCalibr;
class HectorCalibrData;
class HectorCalibr;
class FRSAnl;
class FRSAnlData;
class LyccaLib;
class LyccaData;


class Unpack : public BaseGSIWatcher
{
protected:
        UnpackData  *fUnpackData;
        PhDUnpacker *fUnpacker;
        
protected:
        virtual void AddBranches(TTree *tree);
        virtual void FillBranches();
        virtual void Clear(Option_t * = "");

protected:
    //Spectra to check the unpack data
    TObjArray fsis;

public:
//      Unpack(const char *name, const char *title, TTree *tree = 0x0);
        Unpack(const char *name, const char *title, TTree *tree = 0x0, Short_t do_spectra=2, Short_t do_tree=2);
        virtual ~Unpack();
        
        UnpackData *GetUnpackData()
        {
                return fUnpackData;
        }
        
        // virtual void Exec(Option_t *option="");

     // to create the spectra
     void BuildSpectraByUser();
     //to fill some spectra 
     //need to access the public UnpackData variable
     void FillSpectraByUser();
        
        ClassDef(Unpack,0)  // Unpacker Part
};




class Sort : public BaseGSIWatcher 
{
protected:
     UnpackData *fUnpackData;
protected:
        SortData  *fSortData;
        SortClass  *fSortClass;
        
protected:
        virtual void AddBranches(TTree *tree);
        virtual void FillBranches();
        virtual void Clear(Option_t * = "");
        
protected:
    //Spectra to check the Sort data
    TH1 *fTrigger;

public:
        Sort(const char *name, const char *title, TTree *tree = 0x0, Short_t do_spectra=2, Short_t do_tree=2);
        virtual ~Sort();
        
        SortData *GetSortData()
        {
                return fSortData;
        }

        // to create the spectra
    void BuildSpectraByUser();
    //to fill some spectra 
    //need to access the public UnpackData variable
    void FillSpectraByUser();
        
        ClassDef(Sort,0)  // Sort Part
};

class Calibr : public BaseGSIWatcher 
{
protected:
    SortData *fSortData;

protected:
        FRSCalibrData  *fFRSCalibrData;
        HectorCalibrData  *fHectorCalibrData;
        FRSCalibr  *fFRSCalibr;
    HectorCalibr *fHectorCalibr;
  
protected:
        virtual void AddBranches(TTree *tree);
        virtual void FillBranches();
        virtual void Clear(Option_t * = "");
        
protected:
    //Spectra to check the Calibr data
    TH1 *fTrigger;

public:
        Calibr(const char *name, const char *title, TTree *tree = 0x0, Short_t do_spectra=2, Short_t do_tree=2);
        virtual ~Calibr();
        
        FRSCalibrData *GetFRSCalibrData()
        {
                return fFRSCalibrData;
        }
        
        HectorCalibrData *GetHectorCalibrData()
        {
                return fHectorCalibrData;
        }

    // to create the spectra
    void BuildSpectraByUser();
    //to fill some spectra 
    //need to access the public UnpackData variable
    void FillSpectraByUser();
        

        ClassDef(Calibr,0)  // Calib Part
};

class Anl : public BaseGSIWatcher 
{
protected:
    SortData *fSortData;
protected:
        FRSCalibrData  *fFRSCalibrData;
        HectorCalibrData  *fHectorCalibrData;
protected:
    FRSAnl     *fFRSAnl;
    FRSAnlData *fFRSAnlData;
    LyccaLib   *fLyccaLib;
    LyccaData  *fLyccaData;
  
protected:
    //Spectra to check the Calibr data
    TH2 *fTa_PvsN;
    TH2 *fTa_PvsP;
    TH2 *fTa_NvsN;
    TH2 *fTa_N_strip;
    TH2 *fTa_P_strip;

    TH2 *fWall_D06_NvsP;
    TH2 *fWall_D07_NvsP;
    TH2 *fWall_D11_NvsP;
    TH2 *fWall_D12_NvsP;
    TH2 *fWall_D13_NvsP;
    TH2 *fWall_D14_NvsP;
    TH2 *fWall_D18_NvsP;
    TH2 *fWall_D19_NvsP;

protected:
        virtual void AddBranches(TTree *tree);
        virtual void FillBranches();
        virtual void Clear(Option_t * = "");
        
public:
        Anl(const char *name, const char *title, TTree *tree = 0x0, Short_t do_spectra=2, Short_t do_tree=2);
        virtual ~Anl();
        
  // to create the spectra
  void BuildSpectraByUser();
  //to fill some spectra 
  //need to access the public UnpackData variable
  void FillSpectraByUser();
        
        FRSCalibrData *GetFRSCalibrData()
        {
                return fFRSCalibrData;
        }
        
        HectorCalibrData *GetHectorCalibrData()
        {
                return fHectorCalibrData;
        }

        LyccaData *GetLyccaData()
        {
                return fLyccaData;
  }

        ClassDef(Anl,0)  // Anl Part
};

class LightLYCCAVertexBuilder_1 : public Gw::WatcherWithTag, public VertexBuilder
{
protected:
        LyccaData  *fLyccaData; // required to get the information concerning the recoil velocity
    
protected:
        Double_t fMeanBeta;
        Double_t fZTa_Wall;
        Double_t fZTDSSDOffset;
        Double_t fcosTheta;
  Double_t fWallPosx,fWallPosy,fWallPosz;
        
public:
    //  LightLYCCAVertexBuilder_1();
        LightLYCCAVertexBuilder_1(const char *, const char *);
        virtual ~LightLYCCAVertexBuilder_1()
        {
                ;
        }
    

        void SetTA_Wall(Double_t z_tdssd_offset = 0, Double_t ta_wall = 3590.); // *MENU*
        
        void SetMeanBeta(Double_t beta = 0.5); // *MENU*
        
        void SetBeta(); // *MENU*

        void SetTheta(Double_t cosTheta); // *MENU*

  Double_t GetTheta(); // *MENU*

  void GetPosWall(Double_t &,Double_t &,Double_t &); // *MENU*

  void SetPosWall(Double_t ,Double_t ,Double_t ); // *MENU*

        virtual void Exec(Option_t *option="");
        
        ClassDef(LightLYCCAVertexBuilder_1,0)  // Watcher for builder vertex using only LYCCA
};

#endif