GANIL/CrystalWatchers.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 _CrystalWatchers
#define _CrystalWatchers

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

// ADF definitions
#ifndef ADF_CrystalFrame
#include "CrystalFrame.h"
#endif

// ROOT definitions
class TH3;
class TH2;
using namespace ADF;
using namespace Gw;


class CrystalWatcher : public WatcherWithTag
{
protected:
        SharedFP *fFrame;
    
public:
        CrystalWatcher(const char *name, const char *title) :
        WatcherWithTag(name,title,0x0,0x0),
        fFrame(0x0)
    {;}
        virtual ~CrystalWatcher()
    {;}
        

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


class ShowSignals : public CrystalWatcher
{
public:
        static const Short_t gkNB_SIG =  10; // number of signal kept in memory
    
private:
        Short_t fCurrentSig;
    TString fProcessingAlgo;
        
protected:
        TH2 *fEnergies;
    
protected:
        TObjArray *fSeg;
        TObjArray *fCor;
    
protected:
        Int_t fVMin;
        Int_t fVMax;
        Double_t fHMin;
        Double_t fHMax;
        
protected:
        TObjArray *fBaseLines;
    TObjArray *fSpectra;
        TObjArray *fAmplitudes;
    std::vector <Double_t> fFromSignal;
    
        TH3 *fHThreshold;
        TH3 *fHOvershoot;
    std::vector<Int_t > fCoincThreshold;
    std::vector<Int_t > fCoincOverShoot;
    TH2 *fCoinc;
    TH2 *fCoreCoinc;
    
protected:
        TObjArray fBaseLinesArrows;
        TObjArray fThresholdArrows;
        TObjArray fOvershootArrows;
        
protected:
        virtual void DoCanvas(TCanvas *c, Option_t *);
    
protected:
    void ProcessSignal(Signal *, TH1 *h = 0x0);
    // this is done using very basic signal processing
    void ProcessSignalBasic(Signal *, TH1 *h = 0x0);
    
public:
        ShowSignals(const char *name = "ShowSignals", const char *title = "Display the signals for one crystal");
        virtual ~ShowSignals();

    // virtual char * GetObjectInfo(Int_t px, Int_t py) const;
    
        static void SetDefaultArrow(Double_t baseline, Double_t threshold, Double_t overshoot, Double_t pos = 10, Double_t length = 1000 );
    
    void ShowLastOnes(); //*MENU*
    
        void SetVRange(Int_t min = 0, Int_t max = 10000); //*MENU*
        void SetHRange(Double_t min = 0, Double_t max = 100); //*MENU*
        
        void ShowArrow(Int_t which_sig = 0); //*MENU*
        

        // void SetLevel(Double_t baseline, Double_t threshold, Double_t overshoot, UInt_t which_sig = 0); //*MENU*
        
        virtual void Exec(Option_t *option="");
    
        ClassDef(ShowSignals,0)  // to get all the signal of one crystal
};




#include "TBrowser.h"

#include "CrystalWatchers.h"
#include "CanvasVisu.h"

#include "Macros/Visu/LoupeOnPad.h"

class CrystalSpectra : public ShowSignals, public CanvasVisu
{

protected:

    int fNbrOfSignals;
    TString fCrystalName;

public:
    CrystalSpectra(const char *name = "CrystalSpectra", const char *title = "Display the values for one crystal at the producer level");
    virtual ~CrystalSpectra();

    virtual void SetVRange(Int_t min, Int_t max){ShowSignals::SetVRange(min,max);}
    virtual void SetHRange(Double_t min, Double_t max){ShowSignals::SetHRange(min,max);}

    virtual void ShowSignalsMap(int NbrOfSignals = 1);  //*MENU*

    virtual void ShowBaselinesMap(const char *option="");  //*MENU*

    virtual void ShowSpectraMap(const char *option="");   //*MENU*

    virtual void GlobalAutoRange(const char *opt="xy");  //*MENU

    virtual void SetLoupe(bool loupeon = true){CanvasVisu::SetLoupe(loupeon);}  //*MENU*

    virtual void SetRange(double min, double max, const char *x_y = "y"){CanvasVisu::SetRange(min,max,x_y);} //*MENU*
    virtual void UnZoom(const char *x_y = "y"){CanvasVisu::Unzoom(x_y);} //*MENU*

    virtual void LogX(){CanvasVisu::LogX();} //*MENU*
    virtual void LogY(){CanvasVisu::LogY();} //*MENU*

    virtual void ShowLastOnes(){}
    virtual void ShowArrow(Int_t){}
    virtual void ShowCanvas(Option_t){}

    ClassDef(CrystalSpectra,0)  // to get all the signal of one crystal

};


class CCrystalSpectra : public CrystalSpectra
{
public:
    CCrystalSpectra(const char *name = "CCrystalSpectra", const char *title = "Display the values for one crystal at the preprocessing level") : CrystalSpectra(name,title) {}
    virtual ~CCrystalSpectra() {}

//    virtual void ShowSignalsMap(int /*NbrOfSignals*/) {}

//    virtual void ShowBaselinesMap(const char * /*option*/) {}

    ClassDef(CCrystalSpectra,0)

};

#endif