HLT/BASE/AliHLTTrackGeometry.h

   1 //-*- Mode: C++ -*-
   2 // $Id$
   3 #ifndef ALIHLTTRACKGEOMETRY_H
   4 #define ALIHLTTRACKGEOMETRY_H
   5 //* This file is property of and copyright by the ALICE HLT Project        *
   6 //* ALICE Experiment at CERN, All rights reserved.                         *
   7 //* See cxx source for full Copyright notice                               *
   8
   9 /// @file   AliHLTTrackGeometry.h
  10 /// @author Matthias Richter
  11 /// @date   2011-05-20
  12 /// @brief  Desciption of a track by a sequence of track points
  13 ///
  14
  15 #include <vector>
  16 #include <TObject.h>
  17 #include "AliHLTLogging.h"
  18 #include "AliHLTDataTypes.h"
  19 #include "AliHLTStdIncludes.h"
  20 #include "AliHLTExternalTrackParam.h"
  21 #include "AliHLTIndexGrid.h"
  22
  23 class AliHLTGlobalBarrelTrack;
  24 class AliHLTSpacePointContainer;
  25 class TH2;
  26
  27 /**
  28  * @class AliHLTTrackGeometry
  29  * Description of a track by a sequence of track points given by the
  30  * intersection of the track with a set of planes.
  31  *
  32  * Each plane describes a local 2D coordinate system with origin at the
  33  * norm vector going through global {0,0,0}. The local coordinates u and v
  34  * correspond to global y and z at zero alpha and theta. In that case, r
  35  * corresponds to global x.
  36  *
  37  * Each plane is identified by
  38  * - rotation angle alpha in the global xy plane
  39  * - rotation angle theta
  40  * - unique 32bit AliHLTUInt32_t plane id
  41  *
  42  * The geometry of planes can be defined in child classes defining the
  43  * plane id.
  44  * @ingroup alihlt_base
  45  */
  46 class AliHLTTrackGeometry : public TObject, public AliHLTLogging
  47 {
  48  public:
  49   /// standard constructor
  50   AliHLTTrackGeometry();
  51   /// copy constructor
  52   AliHLTTrackGeometry(const AliHLTTrackGeometry&);
  53   /// assignment operator
  54   AliHLTTrackGeometry& operator=(const AliHLTTrackGeometry&);
  55
  56   /// destructor
  57   ~AliHLTTrackGeometry();
  58
  59   typedef AliHLTIndexGrid<int, AliHLTUInt32_t> AliHLTTrackGrid;
  60
  61   /// set the track id
  62   void SetTrackId(int trackId) {fTrackId=trackId;}
  63   /// get the track id
  64   int GetTrackId() const {return fTrackId;}
  65
  66   enum {
  67     kLower = 0,
  68     kUpper = 1,
  69     kBoundsDimension
  70   };
  71
  72   /**
  73    * class AliHLTTrackPlane
  74    * Helper class to describe a plane
  75    */
  76   class AliHLTTrackPlane {
  77   public:
  78     AliHLTTrackPlane(AliHLTUInt32_t id, float alpha, float r, float theta)
  79       : fId(id), fAlpha(alpha), fR(r), fTheta(theta), fBoundsU(), fBoundsV() {
  80       fBoundsU[kLower]=-5.0; fBoundsU[kUpper]=5.0; fBoundsV[kLower]=-5.0; fBoundsV[kUpper]=5.0;
  81     }
  82     virtual ~AliHLTTrackPlane() {}
  83
  84     /// id of the plane
  85     AliHLTUInt32_t GetId() const {return fId;}
  86     /// alpha of the plane
  87     float GetPlaneAlpha() const {return fAlpha;}
  88     /// radial distance from global {0,0,0}
  89     float GetPlaneR() const {return fR;}
  90     /// theta of the plane
  91     float GetPlaneTheta() const {return fTheta;}
  92
  93     // set bounds of u coordinate
  94     void SetBoundsU(const float bounds[kBoundsDimension]) {
  95       fBoundsU[kLower]=bounds[kLower]; fBoundsU[kUpper]=bounds[kUpper];
  96     }
  97     // set bounds of v coordinate
  98     void SetBoundsV(const float bounds[kBoundsDimension]) {
  99       fBoundsV[kLower]=bounds[kLower]; fBoundsV[kUpper]=bounds[kUpper];
 100     }
 101
 102     bool CheckBounds(float u, float v) const {
 103       return (u>=fBoundsU[kLower]) && (u<=fBoundsU[kUpper])
 104         && (v>=fBoundsV[kLower]) && (v<=fBoundsV[kUpper]);
 105     }
 106
 107   private:
 108     // standard constructor prohibited
 109     AliHLTTrackPlane();
 110
 111     AliHLTUInt32_t fId; // unique id
 112     float fAlpha;       // alpha of the plane
 113     float fR;           // radial distance from global {0,0,0}
 114     float fTheta;       // theta of the plane
 115     float fBoundsU[kBoundsDimension];  // bounds u coordinate
 116     float fBoundsV[kBoundsDimension];  // bounds v coordinate
 117   };
 118
 119   class AliHLTTrackPlaneYZ : public AliHLTTrackPlane {
 120   public:
 121     AliHLTTrackPlaneYZ(AliHLTUInt32_t id, float alpha, float r)
 122       : AliHLTTrackPlane(id, alpha, r, 0.0) {}
 123     ~AliHLTTrackPlaneYZ() {}
 124
 125   private:
 126     // standard constructor prohibited
 127     AliHLTTrackPlaneYZ();
 128   };
 129
 130   struct AliHLTTrackSpacepoint {
 131     AliHLTTrackSpacepoint(AliHLTUInt32_t id, float dU=-1000., float dV=-1000.)
 132       : fId(id), fdU(dU), fdV(dV) {}
 133
 134     int SetResidual(int coordinate, float value) {
 135       if (coordinate==0) fdU=value;
 136       else if (coordinate==1) fdV=value;
 137       return 0;
 138     }
 139
 140     float GetResidual(int coordinate) const {
 141       if (coordinate==0) return fdU;
 142       else if (coordinate==1) return fdV;
 143       return -1000.;
 144     }
 145
 146     AliHLTUInt32_t fId; // space point id
 147     float fdU;          // residual of the spacepoint
 148     float fdV;          // residual of the spacepoint
 149   };
 150
 151   class AliHLTTrackPoint {
 152   public:
 153     // constructor
 154     AliHLTTrackPoint(AliHLTUInt32_t id, float u, float v)
 155       : fId(id), fU(u), fV(v), fSpacePoints() {}
 156     // copy constructor
 157     AliHLTTrackPoint(const AliHLTTrackPoint& src)
 158       : fId(src.fId), fU(src.fU), fV(src.fV), fSpacePoints(src.fSpacePoints) {}
 159     // assignment operator
 160     AliHLTTrackPoint& operator=(const AliHLTTrackPoint& src) {
 161       if (this!=&src) {fId=src.fId; fU=src.fU; fV=src.fV; fSpacePoints=src.fSpacePoints;}
 162       return *this;
 163     }
 164     ~AliHLTTrackPoint() {}
 165
 166     bool operator==(const AliHLTTrackPoint& point) const {
 167       return point.fId==fId;
 168     }
 169     bool operator==(AliHLTUInt32_t id) const {
 170       return id==fId;
 171     }
 172
 173     /// id of the plane
 174     AliHLTUInt32_t GetId() const {return fId;}
 175     /// u coordinate
 176     float GetU() const {return fU;}
 177     /// u coordinate
 178     float GetV() const {return fV;}
 179
 180     /// check associate space point
 181     bool HaveAssociatedSpacePoint() const {
 182       return fSpacePoints.size()>0;
 183     }
 184
 185     /// associate a space point
 186     int AddAssociatedSpacePoint(AliHLTUInt32_t spacepointId, float dU=-1000., float dV=-1000.) {
 187       fSpacePoints.push_back(AliHLTTrackSpacepoint(spacepointId, dU, dV));
 188       return 0;
 189     }
 190
 191     const vector<AliHLTTrackSpacepoint>& GetSpacepoints() const {return fSpacePoints;}
 192     vector<AliHLTTrackSpacepoint>& GetSpacepoints() {return fSpacePoints;}
 193
 194     int SetResidual(AliHLTUInt32_t id, int coordinate, float value) {
 195       for (unsigned i=0; i<fSpacePoints.size(); i++) {
 196         if (fSpacePoints[i].fId!=id) continue;
 197         return fSpacePoints[i].SetResidual(coordinate, value);
 198       }
 199       return -ENOENT;
 200     }
 201
 202   private:
 203     // standard constructor prohibited
 204     AliHLTTrackPoint();
 205
 206     AliHLTUInt32_t fId; // unique id
 207     float fU;           // u coordinate
 208     float fV;           // v coordinate
 209     vector<AliHLTTrackSpacepoint> fSpacePoints;
 210   };
 211
 212   // interface to plane description
 213
 214   /// alpha of the plane
 215   virtual float GetPlaneAlpha(AliHLTUInt32_t planeId) const = 0;
 216   /// radial distance from global {0,0,0}
 217   virtual float GetPlaneR(AliHLTUInt32_t planeId) const = 0;
 218   /// theta of the plane
 219   virtual float GetPlaneTheta(AliHLTUInt32_t planeId) const = 0;
 220   /// check bounds in u and v coordinate
 221   virtual bool CheckBounds(AliHLTUInt32_t planeId, float u, float v) const =0;
 222
 223   // track interface
 224
 225   /// calculate the track points, expects the global magnetic field to be initialized
 226   virtual int CalculateTrackPoints(const AliHLTExternalTrackParam& track) = 0;
 227
 228   /// calculate the track points, expects the global magnetic field to be initialized
 229   virtual int CalculateTrackPoints(AliHLTGlobalBarrelTrack& track) = 0;
 230
 231   /// associate all space points of the container to the calculated track points
 232   int AssociateSpacePoints(AliHLTSpacePointContainer& points);
 233   /// associate specified space points of the container to the calculated track points
 234   int AssociateSpacePoints(const AliHLTUInt32_t* trackpoints, AliHLTUInt32_t nofPoints, AliHLTSpacePointContainer& points);
 235   int AssociateUnusedSpacePoints(AliHLTSpacePointContainer& points);
 236
 237   /// find the track point which can be associated to a spacepoint with coordinates and id
 238   virtual int FindMatchingTrackPoint(AliHLTUInt32_t spacepointId, float spacepoint[3], AliHLTUInt32_t& planeId) = 0;
 239
 240   /// register track points in the index grid
 241   virtual int RegisterTrackPoints(AliHLTTrackGrid* pGrid) const;
 242
 243   /// fill track points to index grid
 244   virtual int FillTrackPoints(AliHLTTrackGrid* pGrid) const;
 245
 246   /// get track point of id
 247   const AliHLTTrackPoint* GetTrackPoint(AliHLTUInt32_t id) const;
 248   /// get track point of id
 249   AliHLTTrackPoint* GetTrackPoint(AliHLTUInt32_t id);
 250
 251   /// create a collection of all points
 252   virtual AliHLTSpacePointContainer* ConvertToSpacePoints() const {return ConvertToSpacePoints(false);}
 253   virtual AliHLTSpacePointContainer* ConvertToSpacePoints(bool bAssociated) const;
 254
 255   /// set the spacepoint associated with a track point
 256   /// @param  planeId       track point
 257   /// @param  spacepointId  space point id to be associated with track point
 258   /// @param  status        status flag
 259   /// @return 0 on success, -ENOENT planeId not found
 260   int SetAssociatedSpacePoint(AliHLTUInt32_t planeId, AliHLTUInt32_t spacepointId, int status, float fdU=0.0, float fdV=0.0);
 261
 262   /// get the spacepoint associated with a track point
 263   /// @param  planeId       id of the track point
 264   /// @param  spacepointId  target to get the spacepoint data
 265   /// @return status flag if found, -ENOENT planeId not found, -ENODATA no associated spacepoint found
 266   int GetAssociatedSpacePoint(AliHLTUInt32_t planeId, AliHLTUInt32_t& spacepointId) const;
 267
 268   // services
 269
 270   int FillResidual(int coordinate, TH2* histo) const;
 271
 272   void SetVerbosity(int verbosity) {fVerbosity=verbosity;}
 273   int GetVerbosity() const {return fVerbosity;}
 274
 275   /// inherited from TObject: clear the object and reset pointer references
 276   virtual void Clear(Option_t * /*option*/ ="");
 277
 278   /// inherited from TObject
 279   virtual void Print(Option_t *option="") const;
 280
 281   virtual void Print(ostream& out, Option_t *option="") const;
 282
 283   /// Inherited from TObject, draw the track points
 284   virtual void Draw(Option_t *option="");
 285
 286  protected:
 287   int AddTrackPoint(const AliHLTTrackPoint& point, AliHLTUInt32_t selectionMask=kAliHLTVoidDataSpec);
 288
 289   const vector<AliHLTTrackPoint>& TrackPoints() const {return fTrackPoints;}
 290
 291  private:
 292   vector<AliHLTTrackPoint> fTrackPoints; // list of points
 293   vector<AliHLTUInt32_t> fSelectionMasks; // selection masks
 294
 295   int fTrackId; // track id
 296   int fVerbosity; // verbosity
 297
 298   ClassDef(AliHLTTrackGeometry, 0)
 299 };
 300
 301 ostream& operator<<(ostream &out, const AliHLTTrackGeometry& c);
 302
 303 #endif