/** Default maximum number of strips */
kMaxStrips = 512
};
- /** Constructor
- @param maxDet Maximum allowed detector number
- @param maxRing Maximum number of rings
- @param maxSec Maximum number of sectors
- @param maxStr Maximum number of strips
- @return */
- AliFMDMap(UShort_t maxDet = kMaxDetectors,
- UShort_t maxRing= kMaxRings,
- UShort_t maxSec = kMaxSectors,
- UShort_t maxStr = kMaxStrips);
+ enum {
+ /** Number used for inner rings */
+ kInner = 0,
+ /** Number used for outer rings */
+ kOuter
+ };
+ enum {
+ /** Number of strips in outer rings */
+ kNStripOuter = 256,
+ /** Number of strips in the inner rings */
+ kNStripInner = 512
+ };
+ enum {
+ /** Number of sectors in the inner rings */
+ kNSectorInner = 20,
+ /** Number of sectorts in the outer rings */
+ kNSectorOuter = 40
+ };
+ enum {
+ /** Base index for inner rings */
+ kBaseInner = 0,
+ /** Base index for outer rings */
+ kBaseOuter = kNSectorInner * kNStripInner
+ };
+ enum {
+ /** Base for FMD1 index */
+ kFMD1Base = 0,
+ /** Base for FMD2 index */
+ kFMD2Base = kNSectorInner * kNStripInner,
+ /** Base for FMD3 index */
+ kFMD3Base = (kBaseOuter + kNSectorOuter * kNStripOuter + kFMD2Base)
+ };
+ /**
+ * Class to do stuff on each element of a map in an efficient
+ * way.
+ */
+ class ForOne
+ {
+ public:
+ /** Destructor */
+ virtual ~ForOne() { }
+ /**
+ * Called for each element considered a floating point number
+ *
+ * @param d Detector number
+ * @param r Ring identifier
+ * @param s Sector number
+ * @param t Strip number
+ * @param v Value (as a floating point number)
+ *
+ * @return Should return @c true on success, @c false otherwise
+ */
+ virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t,
+ Float_t v);
+ /**
+ * Called for each element considered an integer
+ *
+ * @param d Detector number
+ * @param r Ring identifier
+ * @param s Sector number
+ * @param t Strip number
+ * @param v Value (as an integer)
+ *
+ * @return Should return @c true on success, @c false otherwise
+ */
+ virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t,
+ Int_t v);
+ /**
+ * Called for each element considered an integer
+ *
+ * @param d Detector number
+ * @param r Ring identifier
+ * @param s Sector number
+ * @param t Strip number
+ * @param v Value (as an unsigned short integer)
+ *
+ * @return Should return @c true on success, @c false otherwise
+ */
+ virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t,
+ UShort_t v);
+ /**
+ * Called for each element considered an integer
+ *
+ * @param d Detector number
+ * @param r Ring identifier
+ * @param s Sector number
+ * @param t Strip number
+ * @param v Value (as a boolean)
+ *
+ * @return Should return @c true on success, @c false otherwise
+ */
+ virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t,
+ Bool_t v);
+ };
+
+ /**
+ * Constructor
+ *
+ * @param maxDet Maximum allowed detector number
+ * @param maxRing Maximum number of rings
+ * @param maxSec Maximum number of sectors
+ * @param maxStr Maximum number of strips
+ */
+ AliFMDMap(UShort_t maxDet = 0,
+ UShort_t maxRing= 0,
+ UShort_t maxSec = 0,
+ UShort_t maxStr = 0);
+ /**
+ * Copy constructor
+ *
+ * @param other Object to construct from
+ */
+ AliFMDMap(const AliFMDMap& other);
/** Destructor */
virtual ~AliFMDMap() {}
/** @return Maximum detector number */
- UShort_t MaxDetectors() const { return fMaxDetectors; }
+ UShort_t MaxDetectors() const { return fMaxDetectors==0 ? 3 :fMaxDetectors;}
/** @return Maximum number of rings */
- UShort_t MaxRings() const { return fMaxRings; }
+ UShort_t MaxRings() const { return fMaxRings ==0 ? 2 :fMaxRings; }
/** @return Maximum number of sectors */
- UShort_t MaxSectors() const { return fMaxSectors; }
+ UShort_t MaxSectors() const { return fMaxSectors ==0 ? 40 :fMaxSectors; }
/** @return Maximum number of strip */
- UShort_t MaxStrips() const { return fMaxStrips; }
- /** Calculate, check, and return index for strip. If the index is
- invalid, -1 is returned
- @param det Detector number
- @param ring Ring identifier
- @param sec Sector number
- @param str Strip number
- @return Unique index, or -1 in case of errors */
+ UShort_t MaxStrips() const { return fMaxStrips ==0 ? 512 :fMaxStrips; }
+ /**
+ * Calculate the detector coordinates for a given index number
+ *
+ * @param idx Index to find cooresponding detector coordinates for
+ * @param det On return, contain the detector number
+ * @param ring On return, contain the ring identifier
+ * @param sec On return, contain the sector number
+ * @param str On return, contain the strip number
+ */
+ void CalcCoords(Int_t idx,
+ UShort_t& det,
+ Char_t& ring,
+ UShort_t& sec,
+ UShort_t& str) const;
+ /**
+ * Calculate index and return
+ *
+ * @param det Detector number
+ * @param ring Ring identifier
+ * @param sec Sector number
+ * @param str Strip number
+ *
+ * @return Index (not checked)
+ */
+ Int_t CalcIndex(UShort_t det, Char_t ring,
+ UShort_t sec, UShort_t str) const;
+ /**
+ * Calculate index and return
+ *
+ * @param det Detector number
+ * @param ring Ring identifier
+ * @param sec Sector number
+ * @param str Strip number
+ *
+ * @return Index or -1 if the coordinates are invalid
+ */
Int_t CheckIndex(UShort_t det, Char_t ring,
UShort_t sec, UShort_t str) const;
- /** Check if we need UShort_t hack
- @param file File this object was read from */
+ /**
+ * Check if we need UShort_t hack
+ *
+ * @param file File this object was read from
+ */
void CheckNeedUShort(TFile* file);
+ /**
+ * Right multiplication operator
+ *
+ * @param o Other map to multuiply with
+ *
+ * @return Reference to this object
+ */
+ AliFMDMap& operator*=(const AliFMDMap& o);
+ /**
+ * Right division operator
+ *
+ * @param o Other map to divide with
+ *
+ * @return Reference to this object
+ */
+ AliFMDMap& operator/=(const AliFMDMap& o);
+ /**
+ * Right addision operator
+ *
+ * @param o Other map to add to this
+ *
+ * @return Reference to this object
+ */
+ AliFMDMap& operator+=(const AliFMDMap& o);
+ /**
+ * Right subtraction operator
+ *
+ * @param o Other map to substract from this
+ *
+ * @return Reference to this object
+ */
+ AliFMDMap& operator-=(const AliFMDMap& o);
+ /**
+ * For each element of the map, call the user defined overloaded
+ * @c ForOne::operator()
+ *
+ * @param algo Algorithm to use
+ *
+ * @return @c true on success, @c false if for any element, @c
+ * algo(d,r,s,t,v) returns false.
+ */
+ virtual Bool_t ForEach(ForOne& algo) const;
+ /**
+ * Get the total size of the internal array - that is the maximum
+ * index possible plus one.
+ *
+ * @return maximum index, plus 1
+ */
+ virtual Int_t MaxIndex() const = 0;
+ /**
+ * Virtal function to get the value at index @a idx as a floating
+ * point number.
+ *
+ * @note
+ * Even if the map is not floating point valued the
+ * sub-class can define this member function to allow non l-value
+ * usage of the data in the map. That is, if @c a is a floating
+ * point valued map, and @c b is not, then if the class @c B of @c b
+ * implements this member function, expression like
+ *
+ * @verbatim
+ * a += b;
+ * @endverbatim
+ *
+ * multiplies each element of @c a (floating points) with each
+ * element of @c c according to the definition of @c B::AtAsFloat
+ * (@c const version).
+ *
+ * @param idx Index number
+ *
+ * @return Value at index as a floating point number
+ */
+ virtual Float_t AtAsFloat(Int_t idx) const;
+ /**
+ * Virtal function to get the value at index @a idx as a floating
+ * point number.
+ *
+ * This member function should only be defined if the map is a
+ * floating point valued, and can be assigned floating point valued
+ * values. That is, if the map's elements are anything but @c
+ * float then this member function should not be defined in the
+ * derived class. That will prevent expressions like
+ *
+ * @code
+ * a += b;
+ * @endcode
+ *
+ * where @c a is non-floating point valued, and @c b is floating
+ * point valued (only).
+ *
+ * @param idx Index number
+ *
+ * @return Value at index as a floating point number
+ */
+ virtual Float_t& AtAsFloat(Int_t idx);
+ /**
+ * Virtal function to get the value at index @a idx as an integer
+ *
+ * @see Float_t AliFMDMap::AtAsFloat(Int_t) const
+ *
+ * @param idx Index number
+ *
+ * @return Value at index as an integer
+ */
+ virtual Int_t AtAsInt(Int_t idx) const;
+ /**
+ * Virtal function to get the value at index @a idx as an integer
+ *
+ * @see Float_t& AliFMDMap::AtAsFloat(Int_t)
+ *
+ * @param idx Index number
+ *
+ * @return Value at index as an integer
+ */
+ virtual Int_t& AtAsInt(Int_t idx);
+ /**
+ * Virtal function to get the value at index @a idx as an boolean
+ *
+ * @see Float_t AliFMDMap::AtAsFloat(Int_t) const
+ *
+ * @param idx Index number
+ *
+ * @return Value at index as a boolean
+ */
+ virtual UShort_t AtAsUShort(Int_t idx) const;
+ /**
+ * Virtal function to get the value at index @a idx as an boolean
+ *
+ * @see Float_t& AliFMDMap::AtAsFloat(Int_t)
+ *
+ * @param idx Index number
+ *
+ * @return Value at index as a boolean
+ */
+ virtual UShort_t& AtAsUShort(Int_t idx);
+ /**
+ * Virtal function to get the value at index @a idx as an unsigned
+ * short integer
+ *
+ * @see Float_t AliFMDMap::AtAsFloat(Int_t) const
+ *
+ * @param idx Index number
+ *
+ * @return Value at index as an unsigned short integer
+ */
+ virtual Bool_t AtAsBool(Int_t idx) const;
+ /**
+ * Virtal function to get the value at index @a idx as an unsigned
+ * short integer
+ *
+ * @see Float_t& AliFMDMap::AtAsFloat(Int_t)
+ *
+ * @param idx Index number
+ *
+ * @return Value at index as an unsigned short integer
+ */
+ virtual Bool_t& AtAsBool(Int_t idx);
+ /**
+ * Whether this map is floating point valued - that is, it can be
+ * assigned floating point valued values.
+ *
+ * @return @c true if the map is floating point valued
+ */
+ virtual Bool_t IsFloat() const { return kFALSE; }
+ /**
+ * Whether this map is floating point valued or integer valued -
+ * that is, it can be assigned integer valued values
+ *
+ * @return @c true if the map is integer valued
+ */
+ virtual Bool_t IsInt() const { return kFALSE; }
+ /**
+ * Whether this map is unsigned short integer valued - that is it
+ * can be assigned unsigned short integer values
+ *
+ * @return @c true if the map is unsigned short integer valued
+ */
+ virtual Bool_t IsUShort() const { return kFALSE; }
+ /**
+ * Whether this map is boolean valued - that is it can be assigned
+ * boolean values
+ *
+ * @return @c true if the map is boolean valued
+ */
+ virtual Bool_t IsBool() const { return kFALSE; }
+
enum {
/** In case of version 2 of this class, this bit should be set. */
kNeedUShort = 14
};
protected:
- /** Calculate index and return
- @param det Detector number
- @param ring Ring identifier
- @param sec Sector number
- @param str Strip number
- @return Index (not checked) */
- Int_t CalcIndex(UShort_t det, Char_t ring,
+ /**
+ * Calculate, check, and return index for strip. If the index is
+ * invalid, -1 is returned
+ *
+ * This is only used when a full map is used, signalled by
+ * fMaxDetector = 0
+ *
+ * @param det Detector number
+ * @param ring Ring identifier
+ * @param sec Sector number
+ * @param str Strip number
+ *
+ * @return Unique index, or -1 in case of errors
+ */
+ Int_t Coords2Index(UShort_t det, Char_t ring,
UShort_t sec, UShort_t str) const;
+ /**
+ * Calculate, check, and return index for strip. If the index is
+ * invalid, -1 is returned
+ *
+ * This is for back-ward compatibility and for when a map does not
+ * cover all of the FMD strips
+ *
+ * @param det Detector number
+ * @param ring Ring identifier
+ * @param sec Sector number
+ * @param str Strip number
+ *
+ * @return Unique index, or -1 in case of errors
+ */
+ Int_t Coords2IndexOld(UShort_t det, Char_t ring,
+ UShort_t sec, UShort_t str) const;
+ /**
+ * Calculate the detector coordinates from an array index.
+ *
+ * This is used for backward compatibility and for when a map does not
+ * cover all of the FMD strips
+ *
+ * @param idx Index to convert
+ * @param det Detector number on return
+ * @param ring Ring identifier on return
+ * @param sec Sector number on return
+ * @param str Strip number on return
+ */
+ void Index2CoordsOld(Int_t idx,
+ UShort_t& det,
+ Char_t& ring,
+ UShort_t& sec,
+ UShort_t& str) const;
+ /**
+ * Calculate the detector coordinates from an array index.
+ *
+ * This is used for a full map only, signalled by fMaxDetector = 0
+ *
+ * @param idx Index to convert
+ * @param det Detector number on return
+ * @param ring Ring identifier on return
+ * @param sec Sector number on return
+ * @param str Strip number on return
+ */
+ void Index2Coords(Int_t idx,
+ UShort_t& det,
+ Char_t& ring,
+ UShort_t& sec,
+ UShort_t& str) const;
UShort_t fMaxDetectors; // Maximum # of detectors
UShort_t fMaxRings; // Maximum # of rings
UShort_t fMaxSectors; // Maximum # of sectors
UShort_t fMaxStrips; // Maximum # of strips
- ClassDef(AliFMDMap, 3) // Cache of per strip information
+ ClassDef(AliFMDMap, 4) // Cache of per strip information
};
+inline Float_t
+AliFMDMap::AtAsFloat(Int_t) const
+{
+ return 0;
+}
+inline Float_t&
+AliFMDMap::AtAsFloat(Int_t)
+{
+ static Float_t d;
+ return d;
+}
+inline Int_t
+AliFMDMap::AtAsInt(Int_t) const
+{
+ return 0;
+}
+inline Int_t&
+AliFMDMap::AtAsInt(Int_t)
+{
+ static Int_t d;
+ return d;
+}
+inline UShort_t
+AliFMDMap::AtAsUShort(Int_t) const
+{
+ return 0;
+}
+inline UShort_t&
+AliFMDMap::AtAsUShort(Int_t)
+{
+ static UShort_t d;
+ return d;
+}
+inline Bool_t
+AliFMDMap::AtAsBool(Int_t) const
+{
+ return kFALSE;
+}
+inline Bool_t&
+AliFMDMap::AtAsBool(Int_t)
+{
+ static Bool_t d;
+ return d;
+}
+inline Bool_t
+AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, Float_t)
+{
+ return kTRUE;
+}
+inline Bool_t
+AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, Int_t)
+{
+ return kTRUE;
+}
+inline Bool_t
+AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, UShort_t)
+{
+ return kTRUE;
+}
+inline Bool_t
+AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, Bool_t)
+{
+ return kTRUE;
+}
+
+
+
#endif
//____________________________________________________________________
//
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff