GANIL/PSAWatchers.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 _PSAWatchers
#define _PSAWatchers

// Watcher definition
#include "Watchers.h"

// ADF definitions
#include "PSAFrame.h"

// ROOT definitions
#include "Rtypes.h"

#include "CanvasVisu.h"

class TH1F;
class TH2F;
class TH3F;


using namespace ADF;
using namespace Gw;


class PSAWatcher : public WatcherWithTag
{
protected:
        SharedFP    *fFrame;
public:
        PSAWatcher(const char *name, const char *title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0) : 
                WatcherWithTag(name,title,sp_dir,tag_dir), 
                fFrame(0x0) 
                        {;}
        virtual ~PSAWatcher()
                {;}
        

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

/*
  
 for OpenGL support :
 You must add 
 gStyle->SetCanvasPreferGL(1); 
 and TH3D::Draw("glbox") for cubic symbol
 or TH3D::Draw("glbox1") for spherical symbol
 
 for plane slicing put your mouse on a plane (the plane become green)
 stay press on shift and move the mouse
 
*/
class PSACrystal3D : public PSAWatcher
{
private:
        static Float_t fgMetric;
        static Float_t fRadius;
        static Float_t fDepht;
        static Int_t fNBinX;
        static Int_t fNBinZ;
        static Float_t fDefaultECutMin;
        static Float_t fDefaultECutMax;

private:
        TH3F * fH3DHitPosition;
        TH1F * fE0;     
        TH1F * fE1;     
        TH1F * fT0;     
        TH1F * fT1;
        TH2F * fTE0;    
        TH2F * fTE1;    
        TH1F * fEnergySeg;      
        TH1F * fNbHits; 
        
private:        
        Float_t fCurrentECutMin;
        Float_t fCurrentECutMax;
        
protected:
        virtual void DoCanvas(TCanvas *c, Option_t *);  

public:
        PSACrystal3D( const char * name, const char * title, TDirectory *sp_dir = 0x0, TDirectory *tag_dir = 0x0);
        virtual ~PSACrystal3D();
        
        virtual void Exec(Option_t * option="");
        
        void SetEnergyCut(Float_t EcutMin,
                                          Float_t EcutMax ); //*MENU* *ARGS={EcutMin=>fCurrentECutMin,EcutMax=>fCurrentECutMax}
        
        void SetCurrentECutMin( Float_t EcutMin );
        void SetCurrentECutMax( Float_t EcutMax );
        
        Float_t GetCurrentECutMin() const;
        Float_t GetCurrentECutMax() const;
        
        ClassDef(PSACrystal3D,0) // To get a 3D map of hits in a particular crystal
};



class PSACrystal : public PSAWatcher, public CanvasVisu
{
protected:
    static Float_t fgMetric;
    static Float_t fRadius;
    static Float_t fDepht;
    static Int_t fNBinX;
    static Int_t fNBinZ;
    static Float_t fDefaultECutMin;
    static Float_t fDefaultECutMax;

protected:
    TH3F * fH3DHitPosition;
    TH1F * fE0;
    TH1F * fE1;
    TH1F * fT0;
    TH1F * fT1;
    TH2F * fTE0;
    TH2F * fTE1;
    TH1F * fEnergySeg;
    TH1F * fNbHits;
    
    TH2F * fHitsSlices[6];

protected:
    Float_t fCurrentECutMin;
    Float_t fCurrentECutMax;

protected:
    TObjArray *fSpectra;

private:
    unsigned int fNevts;
    int fCrystalID;

public:
    PSACrystal(const char *name = "PSACrystal", const char *title = "Display the psa values for one crystal at the producer level", TDirectory *sp_dir=0x0, TDirectory *tag_dir=0x0);
    virtual ~PSACrystal();

    void Exec(Option_t * /*option*/);

    Bool_t SetTrigger(ADF::DFTrigger* trigger );

    virtual void ShowSpectraMap(const char *option="");   //*MENU*
    virtual void SetLoupe(bool loupeon = true){CanvasVisu::SetLoupe(loupeon);}  //*MENU*

    void ShowCoreVsSumSeg();  //*MENU*

    void ShowTimeVsE();  //*MENU*

    void Show3DHits(); //*MENU*
    void SetEnergyCut(Float_t EcutMin, Float_t EcutMax ); //*MENU* *ARGS={EcutMin=>fCurrentECutMin,EcutMax=>fCurrentECutMax}

    void SetCurrentECutMin( Float_t EcutMin );
    void SetCurrentECutMax( Float_t EcutMax );

    Float_t GetCurrentECutMin() const;
    Float_t GetCurrentECutMax() const;

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

    virtual void UnZoom(const char *x_y_z = "y"){CanvasVisu::Unzoom(x_y_z);} //*MENU*

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

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

    virtual void ShowCanvas(Option_t){}

    ClassDef(PSACrystal,0)
};

#endif