PrismaWatchers.h

Go to the documentation of this file.

#ifndef _PrismaWatchers
#define _PrismaWatchers

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

// ROOT
#include "TString.h"

//includes for libPrisma.so or any other library needed
#include "prismaManager.hh"
#include "detData.hh"


class BasePrismaWatcher : public RancLegnaroWatcher
{
public:
        // number of slot (packet of 32 channels) needed by PRISMA
        static const UShort_t gMaxSlotsForPrisma = 3u ;    
        // number of sections in the MWPPAC
        static const Int_t    gMaxSections = 10;
        // max number of type od detector composing Prisma
        static const Int_t       gmaxTypes = 4;         
        
protected:
        // prisma manager : singleton
        prismaManager *fPM;     
        std::vector<detData*> theMcpData;
        std::vector<detData*> thePpacData;
        std::vector<detData*> theIcData;
        std::vector<detData*> theSideData;
        
private:
        size_t fCurrentSize;
        std::vector<detData *> fDetData;
        
private:
        // map to be filled by rawData using the LUT
        Float_t theMap[240];      
        // LUT
        Int_t LUT[gMaxSlotsForPrisma][gMaxChannels];
        
protected:
        Bool_t InitLUT(const char *);
        detData *GetNextDetData(Int_t, Int_t);
        void ResetDetDataStack() 
        { fCurrentSize = 0; }
        
public:
        BasePrismaWatcher(const char *name, const char *title);
        virtual ~BasePrismaWatcher();
        
        void Configure(const char *pmanager = "Conf/", const char *plut = "Conf/"); 
        
        virtual void Exec(Option_t *option="");
        
        ClassDef(BasePrismaWatcher,0)  // Base for a Prisma watcher
};

class RawPrisma : public BasePrismaWatcher
{
private:
        // spectra for focal plane
        TObjArray *fFP;
        TObjArray *fLR;
        
public:
        RawPrisma(const char *name, const char *title);
        ~RawPrisma();
        
        virtual void Exec(Option_t *option="");
        
        ClassDef(RawPrisma,0)  // Display raw PRISMA spectra
};

class DisplayPrisma : public BasePrismaWatcher
{
private:
        //      TH2 *Ic_Range;
        TH2 *TOF_D;
        TH2 *PRISMA_MCPcal;
        TH1 *PRISMA_X_FP;
        TH1 *PRISMA_Vel;
        TH2 *IcABvsABCD; 
        TH2 *Range_Energy;
        TH2 *Vel_Theta;
        TH2 *a_over_q;
        TH2 *Energy_RBeta;
        TH1 *PRISMA_Mass;
        TH2 *IcAvsABCD;
        
protected:
        virtual void DoCanvas(TCanvas *c, Option_t *);
        
public:
        DisplayPrisma(const char *name, const char *title);
        ~DisplayPrisma()
        {;}
        
        virtual void Exec(Option_t *option="");
        
        
        ClassDef(DisplayPrisma,0)  // Display some standard calibrated PRISMA spectra
};

class EvePrisma : public BasePrismaWatcher
{
        
private:
        TString fTypeName;
        Int_t fMaxCycle; 
   
    const Char_t* fConfFileName;
    const Char_t* fPathFile;

public:
        EvePrisma(const char *name, const char *title);
        ~EvePrisma() {;}
        
        virtual void Exec(Option_t *option="");
        
   virtual void ShowEve(const Char_t* prismaConfFile, const Char_t* agataPathFile); //*MENU* *GETTER=GetConfFileName,GetPathFile* *ARGS={prismaConfFile=>fConfFileName,agataPathFile=>fPathFile}*
        
        virtual void SetActive(Bool_t active = true); //*TOGGLE*
        
        virtual void SetMaxCycle(Int_t cycle) { fMaxCycle = cycle; } //*MENU*   
   
   virtual const Char_t* GetConfFileName() const { return fConfFileName; }
        
   virtual const Char_t* GetPathFile() const { return fPathFile; }
   
        ClassDef(EvePrisma,0)  // Display some standard calibrated PRISMA spectra
};

class MyPrismaTree : public BasePrismaWatcher, public Gw::TTreeBuilder
{
private:
        Float_t fAoverQ; 
        Float_t fRadius; 
        Float_t fIc_AB_DE; 
        Float_t fIc_A_DE; 
        Float_t fIc; 
        Float_t fx_fp; 
        Float_t fTOF; 
        Float_t fRange; 
protected:
        virtual void SetBranches();
        
public:
        MyPrismaTree(const char *name, const char *title, TTree *tree = 0x0);
        ~MyPrismaTree();
        
        virtual void Exec(Option_t *option="");
        
        ClassDef(MyPrismaTree,0)  // Display some standard calibrated PRISMA spectra
};


class DoPrismaDoppler : public BasePrismaWatcher, public VertexBuilder
{       
public:
        DoPrismaDoppler(const char *name, const char *title);
        virtual ~DoPrismaDoppler() 
        {;}
        
        virtual void Exec(Option_t *option=""); 
        
        ClassDef(DoPrismaDoppler,0)  // change doppler of the dedicated watcher
};


#endif