FMD/AliFMDDisplay.h

   1 #ifndef AliFMDDISPLAY_H
   2 #define AliFMDDISPLAY_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
   4  * reserved.
   5  *
   6  * See cxx source for full Copyright notice
   7  */
   8 /** @file    AliFMDDisplay.h
   9     @author  Christian Holm Christensen <cholm@nbi.dk>
  10     @date    Mon Mar 27 12:39:09 2006
  11     @brief   FMD Event display
  12 */
  13 //___________________________________________________________________
  14 //
  15 // The classes defined here, are utility classes for reading in data
  16 // for the FMD.  They are  put in a seperate library to not polute the
  17 // normal libraries.  The classes are intended to be used as base
  18 // classes for customized class that do some sort of analysis on the
  19 // various types of data produced by the FMD.
  20 //
  21 #include "AliFMDInput.h"
  22 #include <TObjArray.h>
  23 #include <TTimer.h>
  24 class TCanvas;
  25 class TPad;
  26 class TButton;
  27 class TSlider;
  28 class TH1;
  29
  30 //___________________________________________________________________
  31 /** @class AliFMDDisplay
  32     @brief Utility class to visualize FMD data in geometry.
  33     @ingroup FMD_util
  34  */
  35 class AliFMDDisplay : public AliFMDInput
  36 {
  37 public:
  38   /**
  39    * Constructor
  40    *
  41    * @param onlyFMD Only show the FMD
  42    * @param gAliceFile galice file
  43    */
  44   AliFMDDisplay(Bool_t onlyFMD=kTRUE, const char* gAliceFile="galice.root");
  45   /**
  46    * DTOR
  47    */
  48   virtual ~AliFMDDisplay();
  49   /**
  50    * Singleton access function
  51    *
  52    * @return Singleton object.
  53    */
  54   static AliFMDDisplay* Instance();
  55
  56   /**
  57    * Continue to next event
  58    */
  59   void  Continue() { fWait = kFALSE; }
  60   /**
  61    * Run throug events as fast as possible
  62    */
  63   void Start() { fContinous = kTRUE; fWait = kFALSE; }
  64   /**
  65    * Pause the processing
  66    */
  67   void Pause() { fContinous = kFALSE; fWait = kTRUE; }
  68   /**
  69    * Zoom mode
  70    */
  71   void  Zoom() { fZoomMode = kTRUE; }
  72   /**
  73    * Pick mode
  74    */
  75   void  Pick() { fZoomMode = kFALSE; }
  76   /**
  77    * Redisplay the event
  78    */
  79   virtual void Redisplay(); // *MENU*
  80   /**
  81    * Break
  82    */
  83   virtual void Break();
  84   /**
  85    * Render in 3D
  86    */
  87   virtual void Render();
  88
  89   /**
  90    * Change cut
  91    */
  92   virtual void ChangeCut();
  93   /**
  94    * Change cut
  95    */
  96   virtual void ChangeFactor();
  97   /**
  98    * Called when a mouse or similar event happens in the display.
  99    *
 100    * @param event Event type
 101    * @param px    where the event happened in pixels along X
 102    * @param py    where the event happened in pixels along Y
 103    */
 104   virtual void  ExecuteEvent(Int_t event, Int_t px, Int_t py);
 105   /**
 106    * Paint into canvas
 107    *
 108    * @param option Not used
 109    */
 110   virtual void  Paint(Option_t* option="") { (void)option; }
 111
 112   /**
 113    * Initialize
 114    *
 115    * @return  @c false on error
 116    */
 117   virtual Bool_t Init();
 118   /**
 119    * Called at beginning of an event
 120    *
 121    * @param event Event number
 122    * @return @c false on error
 123    */
 124   virtual Bool_t Begin(Int_t event);
 125   /**
 126    * Called at end of an event
 127    *
 128    * @return @c false on error
 129    */
 130   virtual Bool_t End();
 131   /**
 132    * Visualize a hit
 133    *
 134    * @param hit Hit
 135    * @param p   Track
 136    * @return @c false on error
 137    */
 138   virtual Bool_t ProcessHit(AliFMDHit* hit, TParticle* p);
 139   /**
 140    * Visualize a digit
 141    *
 142    * @param digit Digit to draw
 143    * @return @c false on error
 144    */
 145   virtual Bool_t ProcessDigit(AliFMDDigit* digit);
 146   /**
 147    * Visualize a summable digit
 148    *
 149    * @param sdigit Summable digit to draw
 150    * @return @c false on error
 151    */
 152   virtual Bool_t ProcessSDigit(AliFMDSDigit* sdigit);
 153   /**
 154    * Visualize a raw digit
 155    *
 156    * @param digit Raw digit.
 157    * @return @c false on error
 158    */
 159   virtual Bool_t ProcessRawDigit(AliFMDDigit* digit);
 160   /**
 161    * Visualize a raw digit
 162    *
 163    * @param digit Raw digit.
 164    * @return @c false on error
 165    */
 166   virtual Bool_t ProcessRawCalibDigit(AliFMDDigit* digit);
 167   /**
 168    * Visualize a reconstructed point.
 169    *
 170    * @param recpoint Reconstructed point
 171    * @return @c false on error
 172    */
 173   virtual Bool_t ProcessRecPoint(AliFMDRecPoint* recpoint);
 174   /**
 175    * Process ESD data for the FMD.  Users should overload this to
 176    * deal with ESD data.
 177    *
 178    * @param d    Detector number (1-3)
 179    * @param r    Ring identifier ('I' or 'O')
 180    * @param s    Sector number (0-19, or 0-39)
 181    * @param t    Strip number (0-511, or 0-255)
 182    * @param eta  Psuedo-rapidity
 183    * @param mult Psuedo-multiplicity
 184    *
 185    * @return  @c false on error
 186    */
 187   virtual Bool_t ProcessESD(UShort_t d, Char_t r, UShort_t s, UShort_t t,
 188                             Float_t eta, Float_t mult);
 189   /**
 190    * Look up a color index, based on the value @a x and the maximum
 191    * value of @a x
 192    *
 193    * @param x   Value
 194    * @param max Maximum (for example 1023 for digits)
 195    * @return @c false on error
 196    */
 197   virtual Int_t  LookupColor(Float_t x, Float_t min, Float_t max)  const;
 198
 199   /**
 200    * Set range of displayed values
 201    */
 202   virtual void SetCut(Float_t l=0., Float_t h=1.); //*MENU*
 203   /**
 204    * Set the noise factor
 205    *
 206    * @param f  Noise factor
 207    */
 208   virtual void SetFactor(Float_t f=1);
 209 protected:
 210   /**
 211    * Copy constructor
 212    *
 213    * @param o Object to copy from
 214    */
 215   AliFMDDisplay(const AliFMDDisplay& o)
 216     : AliFMDInput(o),
 217       fWait(kFALSE),
 218       fMarkers(0),
 219       fHits(0),
 220       fCanvas(0),
 221       fPad(0),
 222       fButtons(0),
 223       fSlider(0),
 224       fFactor(0),
 225       fZoomMode(0),
 226       fX0(0),
 227       fY0(0),
 228       fX1(0),
 229       fY1(0),
 230       fXPixel(0),
 231       fYPixel(0),
 232       fOldXPixel(0),
 233       fOldYPixel(0),
 234       fLineDrawn(0),
 235       fOnlyFMD(kTRUE),
 236       fSpec(0),
 237       fSpecCut(0),
 238       fAux(0),
 239       fReturn(kFALSE),
 240       fContinous(kFALSE),
 241       fTimeout(),
 242       fInitialMin(0),
 243       fInitialMax(1),
 244       fInitialFactor(3./10)
 245   { }
 246   /**
 247    * Assignment operator
 248    *
 249    * @return Reference to this object
 250    */
 251   AliFMDDisplay& operator=(const AliFMDDisplay&) { return *this; }
 252   /**
 253    * Add a marker to the display
 254    *
 255    * @param x   X position
 256    * @param y   Y position
 257    * @param z   Z position
 258    * @param o   Object to refer to
 259    * @param s   Signal
 260    * @param max Maximum of signal
 261    */
 262   virtual void AddMarker(Float_t x, Float_t y, Float_t z,
 263                          TObject* o, Float_t s, Float_t min, Float_t max);
 264   /**
 265    * Add a marker to the display
 266    *
 267    * @param det Detector
 268    * @param rng Ring
 269    * @param sec Sector
 270    * @param str Strip
 271    * @param o   Object to refer to
 272    * @param s   Signal
 273    * @param max Maximum of signal
 274    */
 275   virtual void AddMarker(UShort_t det, Char_t rng, UShort_t sec, UShort_t str,
 276                          TObject* o, Float_t s, Float_t min, Float_t max);
 277
 278   /**
 279    * Show only the FMD detectors.
 280    */
 281   void ShowOnlyFMD();
 282   /**
 283    * Make base canvas
 284    */
 285   virtual void MakeCanvas(const char** which);
 286   /**
 287    * Make AUX canvas
 288    *
 289    */
 290   virtual void MakeAux();
 291   /**
 292    * Draw AUX canvas
 293    *
 294    */
 295   virtual void DrawAux();
 296   /**
 297    * Set the ROOT event loop to idle
 298    *
 299    */
 300   virtual void Idle();
 301   /**
 302    * Called at end of event loop
 303    *
 304    */
 305   virtual void AtEnd();
 306   /**
 307    * Whether a point is inside
 308    *
 309    * @param v   Point
 310    * @param min Minimum
 311    * @param max Maximum
 312    *
 313    * @return true if @a v is inside cut
 314    */
 315   virtual Bool_t InsideCut(Float_t v, const Float_t& min,
 316                          const Float_t& max) const;
 317   /**
 318    * Get the ADC threshold
 319    *
 320    * @param d Detector
 321    * @param r Ring
 322    * @param s Sector
 323    * @param t Strip
 324    *
 325    * @return The threshold
 326    */
 327   virtual Double_t GetADCThreshold(UShort_t d, Char_t r,
 328                                    UShort_t s, UShort_t t) const;
 329
 330   static AliFMDDisplay* fgInstance; // Static instance
 331   Bool_t                fWait;      // Wait until user presses `Continue'
 332   TObjArray*            fMarkers;   // Cache of markers
 333   TObjArray*            fHits;      // Cache of `hits'
 334   TCanvas*              fCanvas;    // Canvas to draw in
 335   TPad*                 fPad;       // View pad.
 336   TObjArray             fButtons;   // Continue button
 337   TSlider*              fSlider;    // Cut slider
 338   TSlider*              fFactor;    // Factor slider
 339   Bool_t                fZoomMode;  // Whether we're in Zoom mode
 340   Float_t               fX0;        // X at lower left corner or range
 341   Float_t               fY0;        // Y at lower left corner or range
 342   Float_t               fX1;        // X at upper right corner or range
 343   Float_t               fY1;        // Y at upper right corner or range
 344   Int_t                 fXPixel;    // X pixel of mark
 345   Int_t                 fYPixel;    // Y pixel of mark
 346   Int_t                 fOldXPixel; // Old x pixel of mark
 347   Int_t                 fOldYPixel; // Old y pixel of mark
 348   Bool_t                fLineDrawn; // Whether we're drawing a box
 349   Bool_t                fOnlyFMD;   // Whether to only do FMD
 350   TH1*                  fSpec;      // Spectra
 351   TH1*                  fSpecCut;   // Cut spectra
 352   TCanvas*              fAux;       // Aux canvas.
 353   Bool_t                fReturn;    // Stop
 354   Bool_t                fContinous; // Run continuous - do not stop
 355   TTimer                fTimeout;   // Timeout
 356   Float_t               fInitialMin;// Initial minimum
 357   Float_t               fInitialMax;// Initial maximum
 358   Float_t               fInitialFactor;//Initial factor
 359
 360   struct Range_t {
 361     UInt_t  fNbins;  // Number of bins
 362     Float_t fLow;    // Low cut
 363     Float_t fHigh;   // High cut
 364   };
 365   static const Range_t fgkEdepRange; // Energy loss range
 366   static const Range_t fgkAdcRange;  // ADC counts range
 367   static const Range_t fgkMultRange; // Multiplicity range
 368
 369   ClassDef(AliFMDDisplay,0)  // FMD specialised event display
 370 };
 371
 372 #endif
 373 //____________________________________________________________________
 374 //
 375 // Local Variables:
 376 //   mode: C++
 377 // End:
 378 //
 379 // EOF
 380 //