ROOT_528-00b_version: include/TEveCaloData.h Source File

00001 // @(#)root/eve:$Id: TEveCaloData.h 33955 2010-06-17 11:33:13Z matevz $
00002 // Author: Matevz Tadel 2007
00003 
00004 /*************************************************************************
00005  * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers.               *
00006  * All rights reserved.                                                  *
00007  *                                                                       *
00008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
00009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
00010  *************************************************************************/
00011 
00012 #ifndef ROOT_TEveCaloData
00013 #define ROOT_TEveCaloData
00014 
00015 #include <vector>
00016 #include "TEveElement.h"
00017 
00018 class TGLSelectRecord;
00019 
00020 class TH2F;
00021 class TAxis;
00022 class THStack;
00023 
00024 class TEveCaloData: public TEveElement,
00025                     public TNamed
00026 {
00027 public:
00028    struct SliceInfo_t
00029    {
00030       TString  fName;      // Name of the slice, eg. ECAL, HCAL.
00031       Float_t  fThreshold; // Only display towers with higher energy.
00032       Color_t  fColor;     // Color used to draw this longitudinal slice.
00033       Color_t  fTransparency; // Transparency used to draw this longitudinal slice.
00034       
00035       SliceInfo_t(): fName(""), fThreshold(0), fColor(kRed), fTransparency(0) {}
00036 
00037       virtual ~SliceInfo_t() {}
00038 
00039       void Setup(const char* name, Float_t threshold, Color_t col, Char_t transp = 101)
00040       {
00041          fName      = name;
00042          fThreshold = threshold;
00043          fColor     = col;
00044          if (transp <= 100) fTransparency = transp;
00045       };
00046 
00047       ClassDef(SliceInfo_t, 0); // Slice info for histogram stack.
00048    };
00049 
00050    typedef std::vector<SliceInfo_t>           vSliceInfo_t;
00051    typedef std::vector<SliceInfo_t>::iterator vSliceInfo_i;
00052 
00053    /**************************************************************************/
00054 
00055    struct CellId_t
00056    {
00057       // Cell ID inner structure.
00058 
00059       Int_t fTower;
00060       Int_t fSlice;
00061 
00062       Float_t fFraction;
00063 
00064       CellId_t(Int_t t, Int_t s, Float_t f=1.0f) : fTower(t), fSlice(s), fFraction(f) {}
00065 
00066       bool operator<(const CellId_t& o) const
00067       { return (fTower == o.fTower) ? fSlice < o.fSlice : fTower < o.fTower; }
00068    };
00069 
00070    struct CellGeom_t
00071    {
00072       // Cell geometry inner structure.
00073 
00074       Float_t fPhiMin;
00075       Float_t fPhiMax;
00076       Float_t fEtaMin;
00077       Float_t fEtaMax;
00078 
00079       Float_t fThetaMin; // cached
00080       Float_t fThetaMax; // cached
00081 
00082       CellGeom_t(): fPhiMin(0), fPhiMax(0), fEtaMin(0), fEtaMax(0), fThetaMin(0), fThetaMax(0) {}
00083       CellGeom_t(Float_t etaMin, Float_t etaMax, Float_t phiMin, Float_t phiMax) {Configure(etaMin, etaMax, phiMin, phiMax);}
00084       virtual ~CellGeom_t() {}
00085 
00086       void Configure(Float_t etaMin, Float_t etaMax, Float_t phiMin, Float_t phiMax);
00087 
00088       Float_t EtaMin()   const { return fEtaMin; }
00089       Float_t EtaMax()   const { return fEtaMax; }
00090       Float_t Eta()      const { return (fEtaMin+fEtaMax)*0.5f; }
00091       Float_t EtaDelta() const { return fEtaMax-fEtaMin; }
00092 
00093       Float_t PhiMin()   const { return fPhiMin; }
00094       Float_t PhiMax()   const { return fPhiMax; }
00095       Float_t Phi()      const { return (fPhiMin+fPhiMax)*0.5f; }
00096       Float_t PhiDelta() const { return fPhiMax-fPhiMin; }
00097 
00098       Float_t ThetaMin() const { return fThetaMin; }
00099       Float_t ThetaMax() const { return fThetaMax; }
00100       Float_t Theta() const { return (fThetaMax+fThetaMin)*0.5f; }
00101       Float_t ThetaDelta() const { return fThetaMax-fThetaMin; }
00102 
00103       virtual void  Dump() const;
00104    };
00105 
00106    struct CellData_t : public CellGeom_t
00107    {
00108       // Cell data inner structure.
00109 
00110       Float_t fValue;
00111 
00112       CellData_t() : CellGeom_t(), fValue(0) {}
00113       virtual ~CellData_t() {}
00114 
00115       Float_t Value(Bool_t) const;
00116       virtual void Dump() const;
00117    };
00118 
00119 
00120    struct RebinData_t
00121    {
00122       Int_t fNSlices;
00123 
00124       std::vector<Float_t> fSliceData;
00125       std::vector<Int_t>   fBinData;
00126 
00127       Float_t* GetSliceVals(Int_t bin);
00128 
00129       void Clear()
00130       {
00131          fSliceData.clear();
00132          fBinData.clear();
00133       }
00134    };
00135 
00136    /**************************************************************************/
00137 
00138    typedef std::vector<CellId_t>               vCellId_t;
00139    typedef std::vector<CellId_t>::iterator     vCellId_i;
00140 
00141    typedef std::vector<CellGeom_t>             vCellGeom_t;
00142    typedef std::vector<CellGeom_t>::iterator   vCellGeom_i;
00143    typedef std::vector<CellGeom_t>::const_iterator   vCellGeom_ci;
00144 
00145 private:
00146    TEveCaloData(const TEveCaloData&);            // Not implemented
00147    TEveCaloData& operator=(const TEveCaloData&); // Not implemented
00148 
00149 protected:
00150    vSliceInfo_t fSliceInfos;
00151 
00152    TAxis*       fEtaAxis;
00153    TAxis*       fPhiAxis;
00154 
00155    Bool_t       fWrapTwoPi;
00156 
00157    Float_t      fMaxValEt; // cached
00158    Float_t      fMaxValE;  // cached
00159 
00160    Float_t      fEps;
00161 
00162    vCellId_t    fCellsSelected;
00163    vCellId_t    fCellsHighlighted;
00164 
00165 public:
00166    TEveCaloData(const char* n="TEveCalData", const char* t="");
00167    virtual ~TEveCaloData() {}
00168 
00169    virtual void UnSelected();
00170    virtual void UnHighlighted();
00171 
00172    virtual TString GetHighlightTooltip();
00173 
00174    virtual void    FillImpliedSelectedSet(Set_t& impSelSet);
00175 
00176    virtual void    GetCellList(Float_t etaMin, Float_t etaMax,
00177                                Float_t phi,    Float_t phiRng,
00178                                vCellId_t &out) const = 0;
00179 
00180    vCellId_t&      GetCellsSelected()    { return fCellsSelected; }
00181    vCellId_t&      GetCellsHighlighted() { return fCellsHighlighted; }
00182    void            PrintCellsSelected();
00183    void  ProcessSelection(vCellId_t& sel_cells, TGLSelectRecord& rec);
00184 
00185    virtual void    Rebin(TAxis *ax, TAxis *ay, vCellId_t &in, Bool_t et, RebinData_t &out) const = 0;
00186 
00187 
00188    virtual void    GetCellData(const CellId_t &id, CellData_t& data) const = 0;
00189 
00190    virtual void    InvalidateUsersCellIdCache();
00191    virtual void    DataChanged();
00192    virtual void    CellSelectionChanged();
00193 
00194    Int_t           GetNSlices()    const { return fSliceInfos.size(); }
00195    SliceInfo_t&    RefSliceInfo(Int_t s) { return fSliceInfos[s]; }
00196    void            SetSliceThreshold(Int_t slice, Float_t threshold);
00197    Float_t         GetSliceThreshold(Int_t slice) const;
00198    void            SetSliceColor(Int_t slice, Color_t col);
00199    Color_t         GetSliceColor(Int_t slice) const;
00200    void            SetSliceTransparency(Int_t slice, Char_t t);
00201    Char_t          GetSliceTransparency(Int_t slice) const;
00202 
00203    virtual void    GetEtaLimits(Double_t &min, Double_t &max) const = 0;
00204 
00205    virtual void    GetPhiLimits(Double_t &min, Double_t &max) const = 0;
00206 
00207    virtual Float_t GetMaxVal(Bool_t et) const { return et ? fMaxValEt : fMaxValE; }
00208    Bool_t  Empty() const { return fMaxValEt < 1e-5; }
00209 
00210    virtual TAxis*  GetEtaBins()    const { return fEtaAxis; }
00211    virtual void    SetEtaBins(TAxis* ax) { fEtaAxis=ax; }
00212 
00213    virtual TAxis*  GetPhiBins()    const { return fPhiAxis; }
00214    virtual void    SetPhiBins(TAxis* ax) { fPhiAxis=ax; }
00215 
00216    virtual Float_t GetEps()      const { return fEps; }
00217    virtual void    SetEps(Float_t eps) { fEps=eps; }
00218 
00219    Bool_t   GetWrapTwoPi() const { return fWrapTwoPi; }
00220    void     SetWrapTwoPi(Bool_t w) { fWrapTwoPi=w; }
00221 
00222    static  Float_t EtaToTheta(Float_t eta);
00223 
00224 
00225    ClassDef(TEveCaloData, 0); // Manages calorimeter event data.
00226 };
00227 
00228 /**************************************************************************/
00229 /**************************************************************************/
00230 
00231 class TEveCaloDataVec: public TEveCaloData
00232 {
00233 
00234 private:
00235    TEveCaloDataVec(const TEveCaloDataVec&);            // Not implemented
00236    TEveCaloDataVec& operator=(const TEveCaloDataVec&); // Not implemented
00237 
00238 protected:
00239    typedef std::vector<Float_t>               vFloat_t;
00240    typedef std::vector<Float_t>::iterator     vFloat_i;
00241 
00242    typedef std::vector<vFloat_t>              vvFloat_t;
00243    typedef std::vector<vFloat_t>::iterator    vvFloat_i;
00244 
00245    vvFloat_t   fSliceVec;
00246    vCellGeom_t fGeomVec;
00247 
00248    Int_t       fTower; // current tower
00249 
00250    Float_t     fEtaMin;
00251    Float_t     fEtaMax;
00252 
00253    Float_t     fPhiMin;
00254    Float_t     fPhiMax;
00255 
00256 public:
00257    TEveCaloDataVec(Int_t nslices);
00258    virtual ~TEveCaloDataVec();
00259   
00260    Int_t AddSlice();
00261    Int_t AddTower(Float_t etaMin, Float_t etaMax, Float_t phiMin, Float_t phiMax);
00262    void  FillSlice(Int_t slice, Float_t value);
00263    void  FillSlice(Int_t slice, Int_t tower, Float_t value);
00264 
00265    Int_t GetNCells() { return fGeomVec.size(); }
00266    std::vector<Float_t>&  GetSliceVals(Int_t slice) { return fSliceVec[slice]; }
00267    std::vector<TEveCaloData::CellGeom_t>& GetCellGeom() { return fGeomVec; } 
00268 
00269    virtual void GetCellList(Float_t etaMin, Float_t etaMax,
00270                             Float_t phi,    Float_t phiRng,
00271                             vCellId_t &out) const;
00272 
00273    virtual void Rebin(TAxis *ax, TAxis *ay, vCellId_t &in, Bool_t et, RebinData_t &out) const;
00274 
00275    virtual void GetCellData(const TEveCaloData::CellId_t &id, TEveCaloData::CellData_t& data) const;
00276    virtual void GetEtaLimits(Double_t &min, Double_t &max) const { min=fEtaMin, max=fEtaMax;}
00277    virtual void GetPhiLimits(Double_t &min, Double_t &max) const { min=fPhiMin; max=fPhiMax;}
00278 
00279   
00280    virtual void  DataChanged();
00281    void          SetAxisFromBins(Double_t epsX=0.001, Double_t epsY=0.001);
00282 
00283    ClassDef(TEveCaloDataVec, 0); // Manages calorimeter event data.
00284 };
00285 
00286 /**************************************************************************/
00287 /**************************************************************************/
00288 
00289 class TEveCaloDataHist: public TEveCaloData
00290 {
00291 private:
00292    TEveCaloDataHist(const TEveCaloDataHist&);            // Not implemented
00293    TEveCaloDataHist& operator=(const TEveCaloDataHist&); // Not implemented
00294 
00295 protected:
00296    THStack*    fHStack;
00297 
00298 public:
00299    TEveCaloDataHist();
00300    virtual ~TEveCaloDataHist();
00301 
00302    virtual void GetCellList( Float_t etaMin, Float_t etaMax,
00303                              Float_t phi, Float_t phiRng, vCellId_t &out) const;
00304 
00305    virtual void Rebin(TAxis *ax, TAxis *ay, vCellId_t &in, Bool_t et, RebinData_t &out) const;
00306 
00307    virtual void GetCellData(const TEveCaloData::CellId_t &id, TEveCaloData::CellData_t& data) const;
00308 
00309    virtual void GetEtaLimits(Double_t &min, Double_t &max) const;
00310    virtual void GetPhiLimits(Double_t &min, Double_t &max) const;
00311 
00312 
00313    virtual void DataChanged();
00314 
00315    THStack* GetStack() { return fHStack; }
00316 
00317    TH2F*    GetHist(Int_t slice) const;
00318    
00319    Int_t   AddHistogram(TH2F* hist);
00320 
00321    ClassDef(TEveCaloDataHist, 0); // Manages calorimeter TH2F event data.
00322 };
00323 
00324 #endif
00325