GANILWatchers.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) IPNL, IN2P3, CNRS                                       *
 *   Contibutor(s) :                                                       *
 *      Olivier Stezowski stezow(AT)ipnl.in2p3.fr [2014]                   *
 *                                                                         *
 *   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 _GANILWatchers
#define _GANILWatchers

// Gw and Watcher definition
#include "WatchersConfig.h"
#include "Watchers.h"
#include "TTreeWatchers.h"

#include "TH2.h"

// Defines required at the VAMOS level
#define WITH_MFM
#define WITH_ROOT

class MFMCommonFrame;
class MFMEbyedatFrame;
class MFMMergeFrame;
class DataParameters;


class GANILInterface
{
public:
    enum EGTYPE { kUnknown = 0, kCobo, kCoboF, kNumexo2, kOscillo, kRaw, kEBYEN, kEBYTS, kEBYENTS, kMergeEN, kMergeTS, kMax } ;
    
    std::string gActionDefault;
    
protected:
    ADF::SharedFP *fMFMinADFFrame;
    
protected:
    MFMCommonFrame  *fMFMFrame;
    
    MFMEbyedatFrame *fEBYFrame;
    MFMCommonFrame  *fInsideFrame;
    MFMMergeFrame   *fMergedFrame;
    
protected:
    Int_t fEGTYPE;
    
protected:
    DataParameters *fDataParameters;
    std::string fActionCurrent;
    
public:
        GANILInterface();
        virtual ~ GANILInterface();
    
    virtual Int_t ReadActionFile(std::string full_name_of_action_file = "");
    
    Bool_t ADF2MFM();
};



class MFMWatcher : public Gw::WatcherWithTag, public GANILInterface
{
protected:
    TH1I *fFrameType;
    TH1I *fFrameSize;
    
protected:
    TH2I *fParXValue;
    TH1D *fMeanNumberOfValues;
    TH1D *fLabelsDistribution;
    
protected:
    virtual void DoCanvas(TCanvas *c, Option_t *);
    
public:
    std::string gActionDefault;
    
public:
    MFMWatcher(const char *, const char *, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
    virtual ~MFMWatcher();
    
    virtual Bool_t SetTrigger( ADF::DFTrigger * /*trigger*/ = 0x0 );
    
    virtual Int_t ReadActionFile(std::string full_name_of_action_file = ""); // *MENU*
        
    virtual void Exec(Option_t *option="");
        
    ClassDef(MFMWatcher,0)  // Watcher for MFM Frames
};


class RawMFMTree : public Gw::Watcher, public GANILInterface, public Gw::TTreeBuilder
{
public:
    static const Int_t MaxValues = 10000;
    
private:
    Int_t fNbValues; // number of values for the current event
    UInt_t fValues[MaxValues]; // values of the current event
    UInt_t fLabels[MaxValues]; // corresponding labels
    
protected:
    virtual void SetBranches();
        
public:
    RawMFMTree(const char *name, const char *title, TTree *tree = 0x0);
    virtual ~RawMFMTree()
    {;}
    
    virtual Bool_t SetTrigger( ADF::DFTrigger * /*trigger*/ = 0x0 );
        
    virtual void Exec(Option_t *option="");
        
    ClassDef(RawMFMTree,0)  // Set/fill branch with raw DATA from GANIL
};

#include "PSAFrame.h"
#include "CanvasVisu.h"


class AGATAVAMOSCoinc: public Gw::WatcherWithTag, public GANILInterface, public CanvasVisu
{
protected:
    ADF::Frame *fPSAFrame;
    ADF::SharedFP *fEventPSA;
    
protected:
    UInt_t GetNbFramePSA();
    ADF::PSAInterface *GetDataPSA(UInt_t which);
    
protected:
    TH2 *fTimeCorrelation;
    std::vector <TH2 *> fGAGATAxGVAMOS;
    TH1 *fCoreCommomVamos;
    TH1 *fCoreCommomAgata;
    TH1 *fSumSpectraVamos;
    TH1 *fSumSpectraAgata;
    TH1 *fCoreDistri;
    TH1 *fTimeVTS_to_TS;
    TH2 *fVTS_Centrum;
    TH1 *fTOF;
    
protected:
    // Some useful label to make coincidence
    std::vector< std::pair<Int_t,ULong64_t> > fVTS;
    std::vector< std::pair<Int_t,ULong64_t> > fT;
    std::pair<Int_t,ULong64_t> fRawToF;
    std::pair<Int_t,ULong64_t> fMW05;
    std::vector< std::pair<std::pair<Int_t,Int_t>,Float_t> > fAGATAE;
    
protected:
    ULong64_t fFirstVTS;
    ULong64_t fFirstCentrum;
    
    double fLastVTS;
    double fLastCentrum;
    
private:
    unsigned int fNevts;
    unsigned int fNVTSRev;
    unsigned int fNCentrumRev;
    
    TH1F *fTimeStampSpread;
    
    
protected:
    //    //! To be overwritten by real implementation if a canvas is produced.
    //    virtual void DoCanvas(TCanvas *c, Option_t *);
    
public:
    AGATAVAMOSCoinc(const char *, const char *, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
    virtual ~AGATAVAMOSCoinc();
    
    void ShowCrystalSpectra();  //*MENU*
    void ShowTimeCoinc();  //*MENU*
    void ShowCoreCommomAndSumSpectra();  //*MENU*
    
    virtual void Print(Option_t *option="") const;  //*MENU*
    
    virtual Bool_t SetTrigger( ADF::DFTrigger * /*trigger*/ = 0x0 );
    
    virtual void Exec(Option_t *option="");
    
    ClassDef(AGATAVAMOSCoinc,0)  // Watcher for MFM Frames
};

#ifdef HAS_VAMOS

// detectors definitions
#include "DetectorsDefs.hh"
#include "Identification.hh"
#include "TimeStamp.hh"
#include "TargetPos.hh"

class Parameters;
class Map;
class HistoManager;
class Analysis;
class LogManager;
class MOFile;
class BashColor;


//class VAMOSWatcher : public Gw::TTreeWithConditions, public GANILInterface
class VAMOSWatcher : public Gw::Watcher, public GANILInterface, public Gw::TTreeBuilder
{
private:
    // Managers or equivalent
    Parameters *PL;
    Map *M;
    HistoManager *H;
    Analysis *An;
    LogManager *LM;
    MOFile *L;

    BashColor *fBashColor;
    
protected:
    // Detectors
#ifdef D_ID
    Identification* Id;
#endif
#ifdef D_AGATA
    TimeStamp *LTS;
#endif
#ifdef D_TMW
    TargetPos *TP;
#endif
    
    Float_t fBrhoRef;
    UShort_t fMode;
    Bool_t fCalcMode;
    
protected:
    // Should be implemented to set properly the branches in new or update mode
    virtual void SetBranches()
    {;}
    virtual void DoCanvas(TCanvas *c, Option_t *);
    
    
protected:
    virtual void AddBranches(TTree *tree)
    {
        ;
    }
    
    virtual void FillBranches();
    virtual void Clear(Option_t * = "");
    
protected:
    void RetriveHistograms();
    void RetrivePointers();
    
public:
    VAMOSWatcher(const char *name, const char *title, TTree *tree = 0x0);
    virtual ~VAMOSWatcher();
    
    // to create the spectra
    //void BuildSpectraByUser();
    
    //to fill some spectra
    // void FillSpectraByUser();
    
#ifdef D_ID
    inline Identification* GetId(){return Id;};
#endif
#ifdef D_TMW
    inline TargetPos *GetTP(){return TP;};
#endif
    
    virtual Bool_t SetTrigger( ADF::DFTrigger * /*trigger*/ = 0x0 );
    
    virtual void InitVAMOS(UShort_t fMode, Option_t *opt = "tmp_histo_vamos.root", Int_t RunNr = -1, const Char_t * OutDir="./Out");
    
    virtual Float_t SetBrhoRef(Float_t brho = 1.0); //*MENU*
    virtual Float_t GetBrhoRef()
    {
        return fBrhoRef;
    }
    
    virtual void Exec(Option_t *option="");
    
    ClassDef(VAMOSWatcher,0)  // Watcher for MFM Frames
};

#include "MetaWatchers.h"

class VAMOSVertexBuilder : public Gw::WatcherWithTag, public VertexBuilder
{
protected:
    VAMOSWatcher *fVAMOSWatcher;
    TargetPos *fTP;
    Identification *fId;
    
public:
    VAMOSVertexBuilder(const char *, const char *);
    virtual ~VAMOSVertexBuilder()
    {
        ;
    }
    
    // void SetSomething() ; //*MENU*
    
    virtual void Exec(Option_t *option="");
    
    
    ClassDef(VAMOSVertexBuilder,0)  // Watcher for builder vertex using the VAMOS library
};

// endif VAMOS
#endif

/*
 #ifdef IN_DEV_GRU
 #ifdef HAS_GRU
 class GNetServerRoot;
 class GSpectra;
 
 
 class GRUWatcher : public TTask
 {
 protected:
 GNetServerRoot *NetworkRoot;
 GSpectra *SpectraDB;
 
 public:
 GRUWatcher(Int_t Port = 9010);
 virtual ~ GRUWatcher();
 
 virtual void Exec(Option_t *option="")
 {;}
 
 ClassDef(GRUWatcher,0)  // To export GwSpectra to GRU
 };
 #endif
 #endif
 */

#endif