GANIL/TrackedWatchers.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 _TrackedWatchers
#define _TrackedWatchers

#include "Watchers.h"
//#include "AgataEventDisplay.h"
#include "AgataEventContainer.h"
#include "TrackedFrame.h"
#include "CanvasVisu.h"

#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TMath.h"
#include "MetaFrame.h"

class VertexBuilder;

using namespace ADF;
using namespace Gw;


class TrackedWatcher : public WatcherWithTag
{
protected:
        SharedFP *fFrame;
protected:
        Double_t fZOffset;
        
protected:      
        virtual Double_t DoDopplerCorrection(const TrackedHit *hit, VertexInterface *vertex);
        
public:
        TrackedWatcher(const char *name, const char *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0) : 
                WatcherWithTag(name,title,sp_dir,tag_dir), 
                fFrame(0x0), 
                fZOffset(0.0)
                        {;}
        virtual ~TrackedWatcher()
                        {;}
        

        virtual void SetAgataOffset(Double_t offset = 0.0); //*MENU* 
        

        virtual Bool_t SetTrigger( ADF::DFTrigger */*trigger*/ = 0x0 );
                
        ClassDef(TrackedWatcher,0)  // Trigger on tracked Frame
};

class Coinc2D : public TrackedWatcher
{
private:
        VertexBuilder *fVertexBuilder;
        
protected:
    TH1F *fTrackedEnergy;
    TH1F *fTrackedEnergyDopler;
        TH1F *fFold;
        TH2F *fGxG;
        TH2F *fGxG_DC;
        TH3F *fPos3D;

protected:
        virtual void DoCanvas(TCanvas *c, Option_t *);
                
public:
        Coinc2D(const char *name, const char *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~Coinc2D();
        
        virtual void Exec(Option_t *option="");
                        
        ClassDef(Coinc2D,0)  // Gamma Gamma matrix and check singles
};

//__________________________________________
//class EveTrack : public TrackedWatcher
//  {
    
//  private:
    
//    TH1F *fMeanRadius;
//    TH1I *fFold;
//    TH1F *fHitEnergy;
//    TH1F *fTrackEnergy;
//      Int_t fMaxCycle;
//    const Char_t* fPathFile;

//  private:
//    static Float_t fgMetric;
    
//  protected:
//    //! To be overwritten by real implementation if a canvas is produced.
//    virtual void DoCanvas(TCanvas *c, Option_t *);
    
//  public:
//    EveTrack(const char *name, const char *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
//    virtual ~EveTrack();
    
//    //! watch the current frame
//    virtual void Exec(Option_t *option="");
    
//    //! show eve event display
//    virtual void ShowEve(const Char_t* agataPathFile); //*MENU* *GETTER=GetPathFile* *ARGS={agataPathFile=>fPathFile}*
    
//    //! Toggle active task
//    void SetActive(Bool_t active = true); //*TOGGLE*
          
//      //! Set max cycle, before resetting buffer
//      virtual void SetMaxCycle(Int_t cycle) { fMaxCycle = cycle; } //*MENU*
    
//      //! Get max cycle
//      virtual Int_t GetMaxCycle() { return fMaxCycle; }
          
//       //! Get agata path file
//       virtual const Char_t* GetPathFile() const { return fPathFile; }

//    ClassDef(EveTrack,0)  // track container
//};



class TrackingWatcher : public TrackedWatcher, CanvasVisu
{
private:
    VertexBuilder *fVertexBuilder;

protected:
    TH1F *fTrackedEnergy;
    TH1F *fTrackedEnergyDopler;
    TH1F *fGammaMult;
    TH2F *fGxG;
    TH2F *fGxG_DC;
    TH2F *fETheta;
    TH2F *fEThetaDC;

    TH3F *fPos3D;

public:
    TrackingWatcher(const char *name, const char *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
    virtual ~TrackingWatcher();

    void InitVertex(VertexInterface *vertex);

    double GetTheta(const TrackedHit *hit, VertexInterface *vertex);

    void ShowTrackedSpectra(bool OnSamePad = false);  //*MENU*

    void ShowGammaGamma(const char *NoDC_DC_Both = "DC");  //*MENU*

    void ShowETheta(const char *NoDC_DC_Both = "DC");  //*MENU*

    void ShowCommonSumTrackedDC(bool OnSamePad = false, const char *DC_NoDC = "DC");  //*MENU*

    void Show3DHits();  //*MENU*



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

    ClassDef(TrackingWatcher,0)  // Gamma Gamma matrix and check singles
};

#endif