adding a base class for track geometry/points description with visualization support...
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Jun 2011 22:06:12 +0000 (22:06 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Jun 2011 22:06:12 +0000 (22:06 +0000)
HLT/BASE/AliHLTSpacePointContainer.cxx
HLT/BASE/AliHLTSpacePointContainer.h
HLT/BASE/AliHLTTrackGeometry.cxx [new file with mode: 0644]
HLT/BASE/AliHLTTrackGeometry.h [new file with mode: 0644]
HLT/BASE/HLTbaseLinkDef.h

index aaf19f4..12816d7 100644 (file)
@@ -32,6 +32,7 @@
 #include "TMath.h"
 #include "TMarker.h"
 #include <memory>
+#include <algorithm>
 #include <iostream>
 
 /** ROOT macro for the implementation of ROOT specific class methods */
@@ -214,6 +215,14 @@ int AliHLTSpacePointContainer::GetNumberOfSpacePoints() const
   return clusterIDs.size();
 }
 
+bool AliHLTSpacePointContainer::Check(AliHLTUInt32_t id) const
+{
+  // check if space point exists
+  vector<AliHLTUInt32_t> clusterIDs;
+  if (GetClusterIDs(clusterIDs)<0) return false;
+  return find(clusterIDs.begin(), clusterIDs.end(), id)!=clusterIDs.end();
+}
+
 TH1* AliHLTSpacePointContainer::DrawProjection(const char* plane, const vector<AliHLTUInt32_t>& selection) const
 {
   // draw the projection of space points in a specified plane
index 9c7ae98..2688f07 100644 (file)
@@ -45,7 +45,8 @@ class AliHLTSpacePointContainer : public TObject, public AliHLTLogging
   /// add input block to the collection
   virtual int AddInputBlock(const AliHLTComponentBlockData* pDesc)=0;
 
-  int GetNumberOfSpacePoints() const;
+  virtual int GetNumberOfSpacePoints() const;
+  virtual bool Check(AliHLTUInt32_t clusterID) const;
   virtual int GetClusterIDs(vector<AliHLTUInt32_t>& tgt) const = 0;
   virtual float GetX(AliHLTUInt32_t clusterID) const = 0;
   virtual float GetXWidth(AliHLTUInt32_t clusterID) const = 0;
@@ -76,6 +77,8 @@ class AliHLTSpacePointContainer : public TObject, public AliHLTLogging
   }
   virtual int SetTrackID(int trackID, const AliHLTUInt32_t* clusterIDs, int arraySize);
 
+  virtual int GetTrackID(AliHLTUInt32_t /*clusterID*/) const {return -1;}
+
   int SetMCID(int mcID, AliHLTUInt32_t clusterID) {
     return SetMCID(mcID, &clusterID, sizeof(clusterID));
   }
diff --git a/HLT/BASE/AliHLTTrackGeometry.cxx b/HLT/BASE/AliHLTTrackGeometry.cxx
new file mode 100644 (file)
index 0000000..47f7007
--- /dev/null
@@ -0,0 +1,288 @@
+// $Id$
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
+//*                  for The ALICE HLT Project.                            *
+//*                                                                        *
+//* Permission to use, copy, modify and distribute this software and its   *
+//* documentation strictly for non-commercial purposes is hereby granted   *
+//* without fee, provided that the above copyright notice appears in all   *
+//* copies and that both the copyright notice and this permission notice   *
+//* appear in the supporting documentation. The authors make no claims     *
+//* about the suitability of this software for any purpose. It is          *
+//* provided "as is" without express or implied warranty.                  *
+//**************************************************************************
+
+/// @file   AliHLTTrackGeometry.cxx
+/// @author Matthias Richter
+/// @date   2011-05-20
+/// @brief  Desciption of a track by a sequence of track points
+///
+
+#include "AliHLTTrackGeometry.h"
+#include "AliHLTSpacePointContainer.h"
+#include "TObjArray.h"
+#include "TMarker.h"
+#include "TMath.h"
+#include <memory>
+#include <iostream>
+#include <algorithm>
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTTrackGeometry)
+
+AliHLTTrackGeometry::AliHLTTrackGeometry()
+  : TObject(), AliHLTLogging()
+  , fTrackPoints()
+  , fTrackId(-1)
+{
+  /// standard constructor
+}
+
+AliHLTTrackGeometry::AliHLTTrackGeometry(const AliHLTTrackGeometry& src)
+  : TObject(src), AliHLTLogging()
+  , fTrackPoints(src.fTrackPoints)
+  , fTrackId(src.fTrackId)
+{
+  /// copy constructor
+}
+
+AliHLTTrackGeometry& AliHLTTrackGeometry::operator=(const AliHLTTrackGeometry& src)
+{
+  /// assignment operator
+  if (this!=&src) {
+    fTrackPoints.assign(src.fTrackPoints.begin(), src.fTrackPoints.end());
+    fTrackId=src.fTrackId;
+  }
+  return *this;
+}
+
+AliHLTTrackGeometry::~AliHLTTrackGeometry()
+{
+  /// destructor
+}
+
+int AliHLTTrackGeometry::AddTrackPoint(const AliHLTTrackPoint& point)
+{
+  /// add a track point to the list
+  vector<AliHLTTrackPoint>::const_iterator element = find(fTrackPoints.begin(), fTrackPoints.end(), point);
+  if (element==fTrackPoints.end()) {
+    fTrackPoints.push_back(point);
+  } else {
+    HLTError("track point of id %08x already existing", point.GetId());
+    return -EEXIST;
+  }
+  return 0;
+}
+
+void AliHLTTrackGeometry::Clear(Option_t * /*option*/)
+{
+  // internal cleanup
+}
+
+void AliHLTTrackGeometry::Print(Option_t *option) const
+{
+  // print info
+  Print(cout, option);
+}
+
+void AliHLTTrackGeometry::Print(ostream& out, Option_t */*option*/) const
+{
+  // print to stream
+  out << "AliHLTTrackGeometry::Print" << endl;
+}
+
+void AliHLTTrackGeometry::Draw(Option_t *option)
+{
+  /// Inherited from TObject, draw the track
+  float scale=250;
+  float center[2]={0.5,0.5};
+  int markerColor=1;
+  int markerSize=1;
+
+  TString strOption(option);
+  std::auto_ptr<TObjArray> tokens(strOption.Tokenize(" "));
+  if (!tokens.get()) return;
+  for (int i=0; i<tokens->GetEntriesFast(); i++) {
+    if (!tokens->At(i)) continue;
+    const char* key="";
+    TString arg=tokens->At(i)->GetName();
+
+    key="scale=";
+    if (arg.BeginsWith(key)) {
+      arg.ReplaceAll(key, "");
+      scale=arg.Atof();
+      continue;
+    }
+    key="centerx=";
+    if (arg.BeginsWith(key)) {
+      arg.ReplaceAll(key, "");
+      center[0]=arg.Atof();
+      continue;
+    }
+    key="centery=";
+    if (arg.BeginsWith(key)) {
+      arg.ReplaceAll(key, "");
+      center[1]=arg.Atof();
+      continue;
+    }
+
+    key="markercolor=";
+    if (arg.BeginsWith(key)) {
+      arg.ReplaceAll(key, "");
+      markerColor=arg.Atoi();
+      continue;
+    }
+
+    key="markersize=";
+    if (arg.BeginsWith(key)) {
+      arg.ReplaceAll(key, "");
+      markerSize=arg.Atoi();
+      continue;
+    }
+  }
+
+  bool bFirstPoint=true;
+  float firstalpha=0.0;
+  for (vector<AliHLTTrackPoint>::const_iterator point=fTrackPoints.begin();
+       point!=fTrackPoints.end(); 
+       point++) {
+    float alpha=GetPlaneAlpha(point->GetId());
+    float r=GetPlaneR(point->GetId());
+    float cosa=TMath::Cos(alpha);
+    float sina=TMath::Sin(alpha);
+    float x = r*sina + point->GetU()*cosa;
+    float y =-r*cosa + point->GetU()*sina;
+    int color=markerColor;
+    if (bFirstPoint) {
+      bFirstPoint=false;
+      TMarker* m=new TMarker(x/(2*scale)+center[0], y/(2*scale)+center[1], 29);
+      m->SetMarkerSize(2);
+      m->SetMarkerColor(2);
+      m->Draw("same");
+      firstalpha=alpha;
+    } else {
+      color+=9*TMath::Abs(alpha-firstalpha)/TMath::Pi();
+    }
+    TMarker* m=new TMarker(x/(2*scale)+center[0], y/(2*scale)+center[1], point->GetV()>0?2:5);
+    m->SetMarkerColor(color);
+    m->SetMarkerSize(markerSize);
+    m->Draw("same");
+  }
+}
+
+int AliHLTTrackGeometry::SetAssociatedSpacePoint(UInt_t planeId, UInt_t spacepointId, int status)
+{
+  /// set the spacepoint associated with a track point
+  vector<AliHLTTrackPoint>::iterator element = find(fTrackPoints.begin(), fTrackPoints.end(), planeId);
+  if (element==fTrackPoints.end()) return -ENOENT;
+  element->SetAssociatedSpacePoint(spacepointId, status);
+  return 0;
+}
+
+int AliHLTTrackGeometry::GetAssociatedSpacePoint(UInt_t planeId, UInt_t& spacepointId) const
+{
+  /// get the spacepoint associated with a track point
+  /// return status flag if found, -ENOENT if no associated spacepoint found
+  vector<AliHLTTrackPoint>::const_iterator element = find(fTrackPoints.begin(), fTrackPoints.end(), planeId);
+  if (element==fTrackPoints.end()) return -ENOENT;
+  if (!element->HaveAssociatedSpacePoint()) return -ENODATA;
+  return element->GetAssociatedSpacePoint(spacepointId);
+}
+
+const AliHLTTrackGeometry::AliHLTTrackPoint* AliHLTTrackGeometry::GetTrackPoint(AliHLTUInt32_t id) const
+{
+  /// get const pointer to track point
+  vector<AliHLTTrackPoint>::const_iterator element = find(fTrackPoints.begin(), fTrackPoints.end(), id);
+  if (element==fTrackPoints.end()) return NULL;
+  return &(*element);
+}
+
+AliHLTTrackGeometry::AliHLTTrackPoint* AliHLTTrackGeometry::GetTrackPoint(AliHLTUInt32_t id)
+{
+  /// get const pointer to track point
+  vector<AliHLTTrackPoint>::iterator element = find(fTrackPoints.begin(), fTrackPoints.end(), id);
+  if (element==fTrackPoints.end()) return NULL;
+  return &(*element);
+}
+
+int AliHLTTrackGeometry::AssociateSpacePoints(AliHLTSpacePointContainer& points)
+{
+  /// associate the track space points to the calculated track points
+  vector<AliHLTUInt32_t> ids;
+  points.GetClusterIDs(ids);
+  if (ids.size()>0) return 0;
+  int result=AssociateSpacePoints(&ids[0], ids.size(), points);
+  if (result>0) {
+    HLTInfo("associated %d space point(s) to track points", result);
+  }
+  return result;
+}
+
+int AliHLTTrackGeometry::AssociateSpacePoints(const AliHLTUInt32_t* trackpoints, AliHLTUInt32_t nofPoints, AliHLTSpacePointContainer& points)
+{
+  /// associate the track space points to the calculated track points
+  if (nofPoints==0) return 0;
+  if (trackpoints==NULL) return -EINVAL;
+  int count=0;
+  for (int i=nofPoints-1; i>=0; i--) {
+    if (!points.Check(trackpoints[i])) {
+      HLTWarning("can not find point id %08x", trackpoints[i]);
+      continue;
+    }
+    float xyz[3]={points.GetX(trackpoints[i]), points.GetY(trackpoints[i]), points.GetZ(trackpoints[i])};
+    AliHLTUInt32_t planeId=0;
+    int result=FindMatchingTrackPoint(trackpoints[i], xyz, planeId);
+    if (result<0) {
+      HLTWarning("no associated track point found for space point id %08x x=%f y=%f z=%f", trackpoints[i], xyz[0], xyz[1], xyz[2]);
+      continue;
+    } else if (result==0) {
+      HLTWarning("associated track point for space pointid %08x x=%f y=%f z=%f occupied", trackpoints[i], xyz[0], xyz[1], xyz[2]);
+      continue;
+    }
+    SetAssociatedSpacePoint(planeId, trackpoints[i], 1);
+    if (points.GetTrackID(trackpoints[i])<0 && GetTrackId()>=0) {
+      points.SetTrackID(GetTrackId(), trackpoints[i]);
+      HLTDebug("associating unused cluster %08x with track %d", trackpoints[i], GetTrackId());
+    }
+    count++;
+  }
+  return count;
+}
+
+int AliHLTTrackGeometry::AssociateUnusedSpacePoints(AliHLTSpacePointContainer& points)
+{
+  /// associate the track space points to the calculated track points
+  int count=0;
+  vector<AliHLTUInt32_t> ids;
+  points.GetClusterIDs(ids);
+  for (vector<AliHLTUInt32_t>::iterator id=ids.begin();
+       id!=ids.end(); id++) {
+    float xyz[3]={points.GetX(*id), points.GetY(*id), points.GetZ(*id)};
+    AliHLTUInt32_t planeId=0;
+    int result=FindMatchingTrackPoint(*id, xyz, planeId);
+    if (result<0) {
+      //HLTWarning("no associated track point found for space point id %08x x=%f y=%f z=%f", *id, xyz[0], xyz[1], xyz[2]);
+      continue;
+    } else if (result==0) {
+      //HLTWarning("associated track point for space pointid %08x x=%f y=%f z=%f occupied", *id, xyz[0], xyz[1], xyz[2]);
+      continue;
+    }
+    SetAssociatedSpacePoint(planeId, *id, 1);
+    if (points.GetTrackID(*id)<0 && GetTrackId()>=0) {
+      points.SetTrackID(GetTrackId(), *id);
+      HLTDebug("associating unused cluster %08x with track %d", *id, GetTrackId());
+    }
+    count++;
+  }
+  return count;
+}
+
+ostream& operator<<(ostream &out, const AliHLTTrackGeometry& p)
+{
+  p.Print(out);
+  return out;
+}
diff --git a/HLT/BASE/AliHLTTrackGeometry.h b/HLT/BASE/AliHLTTrackGeometry.h
new file mode 100644 (file)
index 0000000..66ac40c
--- /dev/null
@@ -0,0 +1,252 @@
+//-*- Mode: C++ -*-
+// $Id$
+#ifndef ALIHLTTRACKGEOMETRY_H
+#define ALIHLTTRACKGEOMETRY_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+/// @file   AliHLTTrackGeometry.h
+/// @author Matthias Richter
+/// @date   2011-05-20
+/// @brief  Desciption of a track by a sequence of track points
+///
+
+#include <vector>
+#include <TObject.h>
+#include "AliHLTLogging.h"
+#include "AliHLTDataTypes.h"
+#include "AliHLTStdIncludes.h"
+#include "AliHLTExternalTrackParam.h"
+
+class AliHLTGlobalBarrelTrack;
+class AliHLTSpacePointContainer;
+
+/**
+ * @class AliHLTTrackGeometry
+ * Description of a track by a sequence of track points given by the
+ * intersection of the track with a set of planes.
+ *
+ * Each plane describes a local 2D coordinate system with origin at the
+ * norm vector going through global {0,0,0}. The local coordinates u and v
+ * correspond to global y and z at zero alpha and theta. In that case, r
+ * corresponds to global x.
+ *
+ * Each plane is identified by
+ * - rotation angle alpha in the global xy plane
+ * - rotation angle theta
+ * - unique 32bit AliHLTUInt32_t plane id
+ *
+ * The geometry of planes can be defined in child classes defining the
+ * plane id.
+ * @ingroup alihlt_base
+ */
+class AliHLTTrackGeometry : public TObject, public AliHLTLogging
+{
+ public:
+  /// standard constructor
+  AliHLTTrackGeometry();
+  /// copy constructor
+  AliHLTTrackGeometry(const AliHLTTrackGeometry&);
+  /// assignment operator
+  AliHLTTrackGeometry& operator=(const AliHLTTrackGeometry&);
+
+  /// destructor
+  ~AliHLTTrackGeometry();
+
+  /// set the track id
+  void SetTrackId(int trackId) {fTrackId=trackId;}
+  /// get the track id
+  int GetTrackId() const {return fTrackId;}
+
+  enum {
+    kLower = 0,
+    kUpper = 1,
+    kBoundsDimension
+  };
+
+  /**
+   * class AliHLTTrackPlane
+   * Helper class to describe a plane
+   */
+  class AliHLTTrackPlane {
+  public:
+    AliHLTTrackPlane(AliHLTUInt32_t id, float alpha, float r, float theta) 
+      : fId(id), fAlpha(alpha), fR(r), fTheta(theta), fBoundsU(), fBoundsV() {
+      fBoundsU[kLower]=-5.0; fBoundsU[kUpper]=5.0; fBoundsV[kLower]=-5.0; fBoundsV[kUpper]=5.0;
+    }
+    virtual ~AliHLTTrackPlane() {}
+
+    /// id of the plane
+    AliHLTUInt32_t GetId() const {return fId;}
+    /// alpha of the plane
+    float GetPlaneAlpha() const {return fAlpha;}
+    /// radial distance from global {0,0,0}
+    float GetPlaneR() const {return fR;}
+    /// theta of the plane
+    float GetPlaneTheta() const {return fTheta;}
+
+    // set bounds of u coordinate
+    void SetBoundsU(const float bounds[kBoundsDimension]) {
+      fBoundsU[kLower]=bounds[kLower]; fBoundsU[kUpper]=bounds[kUpper];
+    }
+    // set bounds of v coordinate
+    void SetBoundsV(const float bounds[kBoundsDimension]) {
+      fBoundsV[kLower]=bounds[kLower]; fBoundsV[kUpper]=bounds[kUpper];
+    }
+
+    bool CheckBounds(float u, float v) const {
+      return (u>=fBoundsU[kLower]) && (u<=fBoundsU[kUpper]) 
+       && (v>=fBoundsV[kLower]) && (v<=fBoundsV[kUpper]);
+    }
+
+  private:
+    // standard constructor prohibited
+    AliHLTTrackPlane();
+
+    AliHLTUInt32_t fId; // unique id
+    float fAlpha;       // alpha of the plane
+    float fR;           // radial distance from global {0,0,0}
+    float fTheta;       // theta of the plane
+    float fBoundsU[kBoundsDimension];  // bounds u coordinate
+    float fBoundsV[kBoundsDimension];  // bounds v coordinate
+  };
+
+  class AliHLTTrackPlaneYZ : public AliHLTTrackPlane {
+  public:
+    AliHLTTrackPlaneYZ(AliHLTUInt32_t id, float alpha, float r) 
+      : AliHLTTrackPlane(id, alpha, r, 0.0) {}
+    ~AliHLTTrackPlaneYZ() {}
+
+  private:
+    // standard constructor prohibited
+    AliHLTTrackPlaneYZ();
+  };
+
+  class AliHLTTrackPoint {
+  public:
+    // constructor
+    AliHLTTrackPoint(AliHLTUInt32_t id, float u, float v)
+      : fId(id), fU(u), fV(v), fSpacePoint(0), fSpacePointStatus(-1) {}
+    // copy constructor
+    AliHLTTrackPoint(const AliHLTTrackPoint& src)
+      : fId(src.fId), fU(src.fU), fV(src.fV), fSpacePoint(src.fSpacePoint), fSpacePointStatus(src.fSpacePointStatus) {}
+    // assignment operator
+    AliHLTTrackPoint& operator=(const AliHLTTrackPoint& src) {
+      if (this!=&src) {fId=src.fId; fU=src.fU; fV=src.fV; fSpacePoint=src.fSpacePoint; fSpacePointStatus=src.fSpacePointStatus;}
+      return *this;
+    }
+    ~AliHLTTrackPoint() {}
+
+    bool operator==(const AliHLTTrackPoint& point) const {
+      return point.fId==fId;
+    }
+    bool operator==(AliHLTUInt32_t id) const {
+      return id==fId;
+    }
+
+    /// id of the plane
+    AliHLTUInt32_t GetId() const {return fId;}
+    /// u coordinate
+    float GetU() const {return fU;}
+    /// u coordinate
+    float GetV() const {return fV;}
+
+    /// check associate space point
+    bool HaveAssociatedSpacePoint() const {
+      return fSpacePointStatus>=0;
+    }
+
+    /// associate a space point
+    int SetAssociatedSpacePoint(AliHLTUInt32_t spacepointId, int status) {
+      fSpacePoint=spacepointId; fSpacePointStatus=status; return 0;
+    }
+
+    int GetAssociatedSpacePoint(AliHLTUInt32_t& spacepointId) const {
+      spacepointId=fSpacePoint; return fSpacePointStatus<0?-ENOENT:fSpacePointStatus;
+    }
+
+  private:
+    // standard constructor prohibited
+    AliHLTTrackPoint();
+
+    AliHLTUInt32_t fId; // unique id
+    float fU;           // u coordinate
+    float fV;           // v coordinate
+    AliHLTUInt32_t fSpacePoint; // associated space point id
+    int fSpacePointStatus; // space point status
+  };
+
+  // interface to plane description
+
+  /// alpha of the plane
+  virtual float GetPlaneAlpha(AliHLTUInt32_t planeId) const = 0;
+  /// radial distance from global {0,0,0}
+  virtual float GetPlaneR(AliHLTUInt32_t planeId) const = 0;
+  /// theta of the plane
+  virtual float GetPlaneTheta(AliHLTUInt32_t planeId) const = 0;
+  /// check bounds in u and v coordinate
+  virtual bool CheckBounds(AliHLTUInt32_t planeId, float u, float v) const =0;
+
+  // track interface
+
+  /// calculate the track points, expects the global magnetic field to be initialized
+  virtual int CalculateTrackPoints(const AliHLTExternalTrackParam& track) = 0;
+
+  /// calculate the track points, expects the global magnetic field to be initialized
+  virtual int CalculateTrackPoints(AliHLTGlobalBarrelTrack& track) = 0;
+
+  /// associate all space points of the container to the calculated track points
+  int AssociateSpacePoints(AliHLTSpacePointContainer& points);
+  /// associate specified space points of the container to the calculated track points
+  int AssociateSpacePoints(const AliHLTUInt32_t* trackpoints, AliHLTUInt32_t nofPoints, AliHLTSpacePointContainer& points);
+  int AssociateUnusedSpacePoints(AliHLTSpacePointContainer& points);
+
+  /// find the track point which can be associated to a spacepoint with coordinates and id
+  virtual int FindMatchingTrackPoint(AliHLTUInt32_t spacepointId, float spacepoint[3], AliHLTUInt32_t& planeId) = 0;
+
+  /// get track point of id
+  const AliHLTTrackPoint* GetTrackPoint(AliHLTUInt32_t id) const;
+  /// get track point of id
+  AliHLTTrackPoint* GetTrackPoint(AliHLTUInt32_t id);
+
+  /// set the spacepoint associated with a track point
+  /// @param  planeId       track point
+  /// @param  spacepointId  space point id to be associated with track point
+  /// @param  status        status flag
+  /// @return 0 on success, -ENOENT planeId not found
+  int SetAssociatedSpacePoint(AliHLTUInt32_t planeId, AliHLTUInt32_t spacepointId, int status);
+
+  /// get the spacepoint associated with a track point
+  /// @param  planeId       id of the track point
+  /// @param  spacepointId  target to get the spacepoint data
+  /// @return status flag if found, -ENOENT planeId not found, -ENODATA no associated spacepoint found
+  int GetAssociatedSpacePoint(AliHLTUInt32_t planeId, AliHLTUInt32_t& spacepointId) const;
+
+  // services
+
+  /// inherited from TObject: clear the object and reset pointer references
+  virtual void Clear(Option_t * /*option*/ ="");
+
+  /// inherited from TObject
+  virtual void Print(Option_t *option="") const;
+
+  virtual void Print(ostream& out, Option_t *option="") const;
+
+  /// Inherited from TObject, draw the track points
+  virtual void Draw(Option_t *option="");
+
+ protected:
+  int AddTrackPoint(const AliHLTTrackPoint& point);
+
+ private:
+  vector<AliHLTTrackPoint> fTrackPoints; // list of points
+
+  int fTrackId; // track id
+
+  ClassDef(AliHLTTrackGeometry, 0)
+};
+
+ostream& operator<<(ostream &out, const AliHLTTrackGeometry& c);
+
+#endif
index b4654e2..f128b1c 100644 (file)
 #pragma link C++ class AliHLTTriggerMenuSymbol+;
 #pragma link C++ class AliHLTRunStatistics+;
 #pragma link C++ class AliHLTSpacePointContainer+;
+#pragma link C++ class AliHLTTrackGeometry+;
 #pragma link C++ class AliHLTMisc+;
 #pragma link C++ class AliHLTCTPData+;
 #pragma link C++ class AliHLTScalars+;