LNL/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 *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
};


#endif