LNL/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

// Gw and Watcher definition
#ifndef Gw_Watchers
#include "Watchers.h"
#endif

#ifndef Gw_AgataEventDisplay
#include "AgataEventDisplay.h"
#endif

#ifndef Gw_AgataEventContainer
#include "AgataEventContainer.h"
#endif

// ADF definitions
#ifndef ADF_TrackedFrame
#include "TrackedFrame.h"
#endif

// ROOT definitions
#ifndef ROOT_TH2F
#include "TH2F.h"
#endif
#ifndef ROOT_TH3F
#include "TH3F.h"
#endif
#ifndef ROOT_TMath
#include "TMath.h"
#endif
#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:
    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();
    
    virtual void Exec(Option_t *option="");
    
    virtual void ShowEve(const Char_t* agataPathFile); //*MENU* *GETTER=GetPathFile* *ARGS={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* GetPathFile() const { return fPathFile; }

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

#endif