STEER/ESD/AliFMDMap.h

   1 #ifndef ALIFMDMAP_H
   2 #define ALIFMDMAP_H
   3 /* Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights
   4  * reserved.
   5  *
   6  * See cxx source for full Copyright notice
   7  */
   8 #ifndef ROOT_TObject
   9 # include <TObject.h>
  10 #endif
  11 class TFile;
  12
  13 //____________________________________________________________________
  14 /** @class AliFMDMap
  15     @brief Base class for caches of per-strip information.
  16     @ingroup FMD_data
  17     This is used to index a strip. Data stored depends on derived
  18     class.  */
  19 class AliFMDMap : public TObject
  20 {
  21 public:
  22   enum {
  23     /** Default maximum detector number */
  24     kMaxDetectors = 3,
  25     /** Default maximum number of rings */
  26     kMaxRings     = 2,
  27     /** Default maximum number of sectors */
  28     kMaxSectors   = 40,
  29     /** Default maximum number of strips */
  30     kMaxStrips    = 512
  31   };
  32   enum {
  33     /** Number used for inner rings */
  34     kInner = 0,
  35     /** Number used for outer rings */
  36     kOuter
  37   };
  38   enum {
  39     /** Number of strips in outer rings */
  40     kNStripOuter = 256,
  41     /** Number of strips in the inner rings */
  42     kNStripInner = 512
  43   };
  44   enum {
  45     /** Number of sectors in the inner rings */
  46     kNSectorInner = 20,
  47     /** Number of sectorts in the outer rings */
  48     kNSectorOuter = 40
  49  };
  50   enum {
  51     /** Base index for inner rings */
  52     kBaseInner = 0,
  53     /** Base index for outer rings */
  54     kBaseOuter = kNSectorInner * kNStripInner
  55   };
  56   enum {
  57     /** Base for FMD1 index */
  58     kFMD1Base = 0,
  59     /** Base for FMD2 index */
  60     kFMD2Base = kNSectorInner * kNStripInner,
  61     /** Base for FMD3 index */
  62     kFMD3Base = (kBaseOuter + kNSectorOuter * kNStripOuter + kFMD2Base)
  63   };
  64   /**
  65    * Class to do stuff on each element of a map in an efficient
  66    * way.
  67    */
  68   class ForOne
  69   {
  70   public:
  71   /** Destructor */
  72     virtual ~ForOne() { }
  73     /**
  74      * Called for each element considered a floating point number
  75      *
  76      * @param d   Detector number
  77      * @param r   Ring identifier
  78      * @param s   Sector number
  79      * @param t   Strip number
  80      * @param v   Value (as a floating point number)
  81      *
  82      * @return Should return @c true on success, @c false otherwise
  83      */
  84     virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t,
  85                               Float_t v);
  86     /**
  87      * Called for each element considered an integer
  88      *
  89      * @param d   Detector number
  90      * @param r   Ring identifier
  91      * @param s   Sector number
  92      * @param t   Strip number
  93      * @param v   Value (as an integer)
  94      *
  95      * @return Should return @c true on success, @c false otherwise
  96      */
  97     virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t,
  98                               Int_t v);
  99     /**
 100      * Called for each element considered an integer
 101      *
 102      * @param d   Detector number
 103      * @param r   Ring identifier
 104      * @param s   Sector number
 105      * @param t   Strip number
 106      * @param v   Value (as an unsigned short integer)
 107      *
 108      * @return Should return @c true on success, @c false otherwise
 109      */
 110     virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t,
 111                               UShort_t v);
 112     /**
 113      * Called for each element considered an integer
 114      *
 115      * @param d   Detector number
 116      * @param r   Ring identifier
 117      * @param s   Sector number
 118      * @param t   Strip number
 119      * @param v   Value (as a boolean)
 120      *
 121      * @return Should return @c true on success, @c false otherwise
 122      */
 123     virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t,
 124                               Bool_t v);
 125   };
 126
 127   /**
 128    * Constructor
 129    *
 130    * @param maxDet  Maximum allowed detector number
 131    * @param maxRing Maximum number of rings
 132    * @param maxSec  Maximum number of sectors
 133    * @param maxStr  Maximum number of strips
 134    */
 135   AliFMDMap(UShort_t maxDet = 0,
 136             UShort_t maxRing= 0,
 137             UShort_t maxSec = 0,
 138             UShort_t maxStr = 0);
 139   /**
 140    * Copy constructor
 141    *
 142    * @param other Object to construct from
 143    */
 144   AliFMDMap(const AliFMDMap& other);
 145   /** Destructor */
 146   virtual ~AliFMDMap() {}
 147   /** @return  Maximum detector number */
 148   UShort_t MaxDetectors() const { return fMaxDetectors==0 ?   3 :fMaxDetectors;}
 149   /** @return  Maximum number of rings */
 150   UShort_t MaxRings()     const { return fMaxRings    ==0 ?   2 :fMaxRings; }
 151   /** @return  Maximum number of sectors */
 152   UShort_t MaxSectors()   const { return fMaxSectors  ==0 ?  40 :fMaxSectors; }
 153   /** @return  Maximum number of strip */
 154   UShort_t MaxStrips()    const { return fMaxStrips   ==0 ? 512 :fMaxStrips; }
 155   /**
 156    * Calculate the detector coordinates for a given index number
 157    *
 158    * @param idx  Index to find cooresponding detector coordinates for
 159    * @param det  On return, contain the detector number
 160    * @param ring On return, contain the ring identifier
 161    * @param sec  On return, contain the sector number
 162    * @param str  On return, contain the strip number
 163    */
 164   void CalcCoords(Int_t     idx,
 165                   UShort_t& det,
 166                   Char_t&   ring,
 167                   UShort_t& sec,
 168                   UShort_t& str) const;
 169   /**
 170    * Calculate index and return
 171    *
 172    * @param det  Detector number
 173    * @param ring Ring identifier
 174    * @param sec  Sector number
 175    * @param str  Strip number
 176    *
 177    * @return  Index (not checked)
 178    */
 179   Int_t CalcIndex(UShort_t det, Char_t ring,
 180                   UShort_t sec, UShort_t str) const;
 181   /**
 182    * Calculate index and return
 183    *
 184    * @param det  Detector number
 185    * @param ring Ring identifier
 186    * @param sec  Sector number
 187    * @param str  Strip number
 188    *
 189    * @return  Index or -1 if the coordinates are invalid
 190    */
 191   Int_t  CheckIndex(UShort_t det, Char_t ring,
 192                     UShort_t sec, UShort_t str) const;
 193   /**
 194    * Check if we need UShort_t hack
 195    *
 196    * @param file File this object was read from
 197    */
 198   void CheckNeedUShort(TFile* file);
 199   /**
 200    * Right multiplication operator
 201    *
 202    * @param o Other map to multuiply with
 203    *
 204    * @return Reference to this object
 205    */
 206   AliFMDMap& operator*=(const AliFMDMap& o);
 207   /**
 208    * Right division operator
 209    *
 210    * @param o Other map to divide with
 211    *
 212    * @return Reference to this object
 213    */
 214   AliFMDMap& operator/=(const AliFMDMap& o);
 215   /**
 216    * Right addision operator
 217    *
 218    * @param o Other map to add to this
 219    *
 220    * @return Reference to this object
 221    */
 222   AliFMDMap& operator+=(const AliFMDMap& o);
 223   /**
 224    * Right subtraction operator
 225    *
 226    * @param o Other map to substract from this
 227    *
 228    * @return Reference to this object
 229    */
 230   AliFMDMap& operator-=(const AliFMDMap& o);
 231   /**
 232    * For each element of the map, call the user defined overloaded
 233    * @c ForOne::operator()
 234    *
 235    * @param algo Algorithm to use
 236    *
 237    * @return @c true on success, @c false if for any element, @c
 238    * algo(d,r,s,t,v) returns false.
 239    */
 240   virtual Bool_t  ForEach(ForOne& algo) const;
 241   /**
 242    * Get the total size of the internal array - that is the maximum
 243    * index possible plus one.
 244    *
 245    * @return maximum index, plus 1
 246    */
 247   virtual Int_t MaxIndex() const = 0;
 248   /**
 249    * Virtal function to get the value at index @a idx as a floating
 250    * point number.
 251    *
 252    * @note
 253    * Even if the map is not floating point valued the
 254    * sub-class can define this member function to allow non l-value
 255    * usage of the data in the map.   That is, if @c a is a floating
 256    * point valued map, and @c b is not, then if the class @c B of @c b
 257    * implements this member function, expression like
 258    *
 259    * @verbatim
 260    *   a += b;
 261    * @endverbatim
 262    *
 263    * multiplies each element of @c a (floating points) with each
 264    * element of @c c according to the definition of @c B::AtAsFloat
 265    * (@c const version).
 266    *
 267    * @param idx Index number
 268    *
 269    * @return Value at index as a floating point number
 270    */
 271   virtual Float_t AtAsFloat(Int_t idx) const;
 272   /**
 273    * Virtal function to get the value at index @a idx as a floating
 274    * point number.
 275    *
 276    * This member function should only be defined if the map is a
 277    * floating point valued, and can be assigned floating point valued
 278    * values.  That is, if the map's elements are anything but @c
 279    * float then this member function should not be defined in the
 280    * derived class.  That will prevent expressions like
 281    *
 282    * @code
 283    *   a += b;
 284    * @endcode
 285    *
 286    * where @c a is non-floating point valued, and @c b is floating
 287    * point valued (only).
 288    *
 289    * @param idx Index number
 290    *
 291    * @return Value at index as a floating point number
 292    */
 293   virtual Float_t& AtAsFloat(Int_t idx);
 294   /**
 295    * Virtal function to get the value at index @a idx as an integer
 296    *
 297    * @see Float_t AliFMDMap::AtAsFloat(Int_t) const
 298    *
 299    * @param idx Index number
 300    *
 301    * @return Value at index as an integer
 302    */
 303   virtual Int_t   AtAsInt(Int_t idx) const;
 304   /**
 305    * Virtal function to get the value at index @a idx as an integer
 306    *
 307    * @see Float_t& AliFMDMap::AtAsFloat(Int_t)
 308    *
 309    * @param idx Index number
 310    *
 311    * @return Value at index as an integer
 312    */
 313   virtual Int_t&   AtAsInt(Int_t idx);
 314   /**
 315    * Virtal function to get the value at index @a idx as an boolean
 316    *
 317    * @see Float_t AliFMDMap::AtAsFloat(Int_t) const
 318    *
 319    * @param idx Index number
 320    *
 321    * @return Value at index as a boolean
 322    */
 323   virtual UShort_t   AtAsUShort(Int_t idx) const;
 324   /**
 325    * Virtal function to get the value at index @a idx as an boolean
 326    *
 327    * @see Float_t& AliFMDMap::AtAsFloat(Int_t)
 328    *
 329    * @param idx Index number
 330    *
 331    * @return Value at index as a boolean
 332    */
 333   virtual UShort_t&   AtAsUShort(Int_t idx);
 334   /**
 335    * Virtal function to get the value at index @a idx as an unsigned
 336    * short integer
 337    *
 338    * @see Float_t AliFMDMap::AtAsFloat(Int_t) const
 339    *
 340    * @param idx Index number
 341    *
 342    * @return Value at index as an unsigned short integer
 343    */
 344   virtual Bool_t   AtAsBool(Int_t idx) const;
 345   /**
 346    * Virtal function to get the value at index @a idx as an unsigned
 347    * short integer
 348    *
 349    * @see Float_t& AliFMDMap::AtAsFloat(Int_t)
 350    *
 351    * @param idx Index number
 352    *
 353    * @return Value at index as an unsigned short integer
 354    */
 355   virtual Bool_t&   AtAsBool(Int_t idx);
 356   /**
 357    * Whether this map is floating point valued - that is, it can be
 358    * assigned floating point valued values.
 359    *
 360    * @return @c true if the map is floating point valued
 361    */
 362   virtual Bool_t IsFloat() const { return kFALSE; }
 363   /**
 364    * Whether this map is floating point valued or integer valued -
 365    * that is, it can be assigned integer valued values
 366    *
 367    * @return @c true if the map is integer valued
 368    */
 369   virtual Bool_t IsInt() const { return kFALSE; }
 370   /**
 371    * Whether this map is unsigned short integer valued - that is it
 372    * can be assigned unsigned short integer values
 373    *
 374    * @return @c true if the map is unsigned short integer valued
 375    */
 376   virtual Bool_t IsUShort() const { return kFALSE; }
 377   /**
 378    * Whether this map is boolean valued - that is it can be assigned
 379    * boolean values
 380    *
 381    * @return @c true if the map is boolean valued
 382    */
 383   virtual Bool_t IsBool() const { return kFALSE; }
 384
 385   enum {
 386     /** In case of version 2 of this class, this bit should be set. */
 387     kNeedUShort = 14
 388   };
 389 protected:
 390   /**
 391    * Calculate, check, and return index for strip.  If the index is
 392    * invalid, -1 is returned
 393    *
 394    * This is only used when a full map is used, signalled by
 395    * fMaxDetector = 0
 396    *
 397    * @param det   Detector number
 398    * @param ring  Ring identifier
 399    * @param sec   Sector number
 400    * @param str   Strip number
 401    *
 402    * @return  Unique index, or -1 in case of errors
 403    */
 404   Int_t  Coords2Index(UShort_t det, Char_t ring,
 405                   UShort_t sec, UShort_t str) const;
 406   /**
 407    * Calculate, check, and return index for strip.  If the index is
 408    * invalid, -1 is returned
 409    *
 410    * This is for back-ward compatibility and for when a map does not
 411    * cover all of the FMD strips
 412    *
 413    * @param det   Detector number
 414    * @param ring  Ring identifier
 415    * @param sec   Sector number
 416    * @param str   Strip number
 417    *
 418    * @return  Unique index, or -1 in case of errors
 419    */
 420   Int_t  Coords2IndexOld(UShort_t det, Char_t ring,
 421                          UShort_t sec, UShort_t str) const;
 422   /**
 423    * Calculate the detector coordinates from an array index.
 424    *
 425    * This is used for backward compatibility and for when a map does not
 426    * cover all of the FMD strips
 427    *
 428    * @param idx  Index to convert
 429    * @param det  Detector number on return
 430    * @param ring Ring identifier on return
 431    * @param sec  Sector number on return
 432    * @param str  Strip number on return
 433    */
 434   void Index2CoordsOld(Int_t     idx,
 435                        UShort_t& det,
 436                        Char_t&   ring,
 437                        UShort_t& sec,
 438                        UShort_t& str) const;
 439   /**
 440    * Calculate the detector coordinates from an array index.
 441    *
 442    * This is used for a full map only, signalled by fMaxDetector = 0
 443    *
 444    * @param idx  Index to convert
 445    * @param det  Detector number on return
 446    * @param ring Ring identifier on return
 447    * @param sec  Sector number on return
 448    * @param str  Strip number on return
 449    */
 450   void Index2Coords(Int_t     idx,
 451                     UShort_t& det,
 452                     Char_t&   ring,
 453                     UShort_t& sec,
 454                     UShort_t& str) const;
 455   UShort_t fMaxDetectors;             // Maximum # of detectors
 456   UShort_t fMaxRings;                 // Maximum # of rings
 457   UShort_t fMaxSectors;               // Maximum # of sectors
 458   UShort_t fMaxStrips;                // Maximum # of strips
 459
 460   ClassDef(AliFMDMap, 4) // Cache of per strip information
 461 };
 462
 463 inline Float_t
 464 AliFMDMap::AtAsFloat(Int_t) const
 465 {
 466   return 0;
 467 }
 468 inline Float_t&
 469 AliFMDMap::AtAsFloat(Int_t)
 470 {
 471   static Float_t d;
 472   return d;
 473 }
 474 inline Int_t
 475 AliFMDMap::AtAsInt(Int_t) const
 476 {
 477   return 0;
 478 }
 479 inline Int_t&
 480 AliFMDMap::AtAsInt(Int_t)
 481 {
 482   static Int_t d;
 483   return d;
 484 }
 485 inline UShort_t
 486 AliFMDMap::AtAsUShort(Int_t) const
 487 {
 488   return 0;
 489 }
 490 inline UShort_t&
 491 AliFMDMap::AtAsUShort(Int_t)
 492 {
 493   static UShort_t d;
 494   return d;
 495 }
 496 inline Bool_t
 497 AliFMDMap::AtAsBool(Int_t) const
 498 {
 499   return kFALSE;
 500 }
 501 inline Bool_t&
 502 AliFMDMap::AtAsBool(Int_t)
 503 {
 504   static Bool_t d;
 505   return d;
 506 }
 507 inline Bool_t
 508 AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, Float_t)
 509 {
 510   return kTRUE;
 511 }
 512 inline Bool_t
 513 AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, Int_t)
 514 {
 515   return kTRUE;
 516 }
 517 inline Bool_t
 518 AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, UShort_t)
 519 {
 520   return kTRUE;
 521 }
 522 inline Bool_t
 523 AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, Bool_t)
 524 {
 525   return kTRUE;
 526 }
 527
 528
 529
 530 #endif
 531 //____________________________________________________________________
 532 //
 533 // Local Variables:
 534 //   mode: C++
 535 // End:
 536 //
 537 // EOF
 538 //
 539
 540