HLT/TPCLib/AliHLTTPCSliceTrackerComponent.h

   1 // XEmacs -*-C++-*-
   2 // @(#) $Id$
   3
   4 #ifndef ALIHLTTPCSLICETRACKERCOMPONENT_H
   5 #define ALIHLTTPCSLICETRACKERCOMPONENT_H
   6 //* This file is property of and copyright by the ALICE HLT Project        *
   7 //* ALICE Experiment at CERN, All rights reserved.                         *
   8 //* See cxx source for full Copyright notice                               *
   9
  10 /** @file   AliHLTTPCSliceTrackerComponent.h
  11     @author Timm Steinbeck, Matthias Richter
  12     @date
  13     @brief  The TPC conformal mapping tracker component.
  14 */
  15
  16 #include "AliHLTProcessor.h"
  17
  18 class AliHLTTPCConfMapper;
  19 class AliHLTTPCVertex;
  20 class AliHLTTPCInterMerger;
  21
  22 /**
  23  * @class AliHLTTPCSliceTrackerComponent
  24  * The TPC conformal mapping tracker component.
  25  *
  26  * Component ID: \b TPCSliceTracker <br>
  27  * Library: \b libAliHLTTPC.
  28  *
  29  * Mandatory arguments: <br>
  30  * \li -bfield     <i> magnetic field   </i> <br>
  31  *      should allways be used. If there is no magnetic field, use 0.00001
  32  *
  33  * Optional arguments: <br>
  34  * \li -pp-run <br>
  35  *      will give fixed trackparameters for p-p runs.
  36  * \li -Pb-Pb-run <br>
  37  *      will give fixed trackparameters for Pb-Pb runs.
  38  * \li -multiplicity     <i> multiplicity  </i> <br>
  39  *      set the multiplicity of your collitions. Used for Pb-Pb events.
  40  * \li -disable-merger <br>
  41  *      turns off the intermerging on sectorlevel. Only use in spacial cases.
  42  * \li -nonvertextracking <br>
  43  *      the tracking will do a reconstruction of clusters without vertex constraint.
  44  * \li -mainvertextrackingoff <br>
  45  *      will turn off the tracking with vertex constraint. Use together with -nonvertextracking.
  46  * \li -etarange   <i> eta range   </i> <br>
  47  *      sets the eta range for the tracking.
  48  * \li -etasegment <i> eta segments   </i> <br>
  49  *      let you set the number of eta segments in the trscker.
  50  * \li -chi2cut <i> chi²   </i> <br>
  51  *      set the chi² for the tracker.
  52  * \li -rowscopetracklet <i> number of padrows   </i> <br>
  53  *     tells the tracker how many padrows down it should look for the next cluster when making tracklets.
  54  * \li -rowscopetrack <i> number of padrows   </i> <br>
  55  *     tells the tracker how many padrows down it should look for the next cluster when making track.
  56  * \li -trackletlength <i> number of clusters   </i> <br>
  57  *     the minimum number of clusters to be on a tracklet.
  58  * \li -tracklength <i> number of clusters   </i> <br>
  59  *     the minimum number of clusters to be on a track.
  60  * \li -clusterZ <i> cutoff in z-direction (cm)   </i> <br>
  61  *     makes the tracker to not read in Clusters with a higher value then the
  62  *     one given in both directions
  63  *
  64  * @ingroup alihlt_tpc_components
  65  */
  66 class AliHLTTPCSliceTrackerComponent : public AliHLTProcessor
  67 {
  68 public:
  69   /** default constructor */
  70   AliHLTTPCSliceTrackerComponent();
  71   /** destructor */
  72   virtual ~AliHLTTPCSliceTrackerComponent();
  73
  74   // Public functions to implement AliHLTComponent's interface.
  75   // These functions are required for the registration process
  76
  77   /** interface function, see AliHLTComponent for description */
  78   const char* GetComponentID();
  79   /** interface function, see AliHLTComponent for description */
  80   void GetInputDataTypes(AliHLTComponentDataTypeList& list);
  81   /** interface function, see AliHLTComponent for description */
  82   AliHLTComponentDataType GetOutputDataType();
  83   /** interface function, see AliHLTComponent for description */
  84   virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
  85   /** interface function, see AliHLTComponent for description */
  86   AliHLTComponent* Spawn();
  87
  88 protected:
  89
  90   /**
  91    * Set Tracker parameters
  92    * Knowledge on that has been lost, so somebody has to insert more
  93    * documentation.
  94    */
  95   void SetTrackerParam(Int_t phiSegments=50,Int_t etaSegments=100,
  96                        Int_t trackletlength=3,Int_t tracklength=5,
  97                        Int_t rowscopetracklet=2,Int_t rowscopetrack=3,
  98                        Double_t minPtFit=0,Double_t maxangle=1.31,
  99                        Double_t goodDist=5,Double_t hitChi2Cut=10,
 100                        Double_t goodHitChi2=20,Double_t trackChi2Cut=50,
 101                        Int_t maxdist=50,Double_t maxphi=0.1,Double_t maxeta=0.1);
 102
 103   /**
 104    * Set Tracker parameters
 105    * Knowledge on that has been lost, so somebody has to insert more
 106    * documentation.
 107    */
 108   void SetTrackerParam( Bool_t doPP, Bool_t doPbPb, Int_t multiplicity,
 109                         Double_t bField, Int_t etasegment, Double_t hitchi2cut,
 110                         Int_t rowscopetracklet, Int_t rowscopetrack,
 111                         Int_t trackletlength, Int_t tracklength );
 112
 113   /**
 114    * Set default tracker parameters
 115    * Knowledge on that has been lost, so somebody has to insert more
 116    * documentation.
 117    */
 118   void SetTrackerParam1();
 119
 120   // Protected functions to implement AliHLTComponent's interface.
 121   // These functions provide initialization as well as the actual processing
 122   // capabilities of the component.
 123
 124   /** interface function, see AliHLTComponent for description */
 125   int DoInit( int argc, const char** argv );
 126   /** interface function, see AliHLTComponent for description */
 127   int DoDeinit();
 128   /** interface function, see AliHLTComponent for description */
 129   int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
 130                AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
 131                AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks );
 132
 133   int Reconfigure(const char* cdbEntry, const char* chainId);
 134   int ReadPreprocessorValues(const char* modules);
 135
 136   using AliHLTProcessor::DoEvent;
 137
 138 private:
 139   /** copy constructor prohibited */
 140   AliHLTTPCSliceTrackerComponent(const AliHLTTPCSliceTrackerComponent&);
 141   /** assignment operator prohibited */
 142   AliHLTTPCSliceTrackerComponent& operator=(const AliHLTTPCSliceTrackerComponent&);
 143   /**
 144    * Configure the component.
 145    * Parse a string for the configuration arguments and set the component
 146    * properties.
 147    */
 148   int Configure(const char* arguments);
 149
 150   /** instance of the tracker */
 151   AliHLTTPCConfMapper* fTracker;                                   //! transient
 152   /** vertex object */
 153   AliHLTTPCVertex* fVertex;                                        //! transient
 154   /** eta range */
 155   Float_t fEta[2];                                                 //  see above
 156   /** switch for subsequent non-vertex tracking */
 157   Bool_t fDoNonVertex;                                             //  see above
 158   /** */
 159   Bool_t  fDoPP;                                                   //  see above
 160    /** */
 161   Bool_t  fDoPbPb;                                                 //  see above
 162   /** multiplicity estimate */
 163   Int_t fMultiplicity;                                             //  see above
 164   /** magnetic field */
 165   Double_t fBField;                                                //  see above
 166
 167   Bool_t fnonvertextracking;   // enable NONVERTEX Tracking
 168   Bool_t fmainvertextracking;  // enable MAINVERTEX Tracking
 169
 170   /** ParameterVariables for the trackeparameters */
 171
 172
 173   /** phi_segments:     Devide the space into phi_segments */
 174   Int_t fPhisegment;              //! transient
 175   /** ets_segments:     Devide the space into eta_segments */
 176   Int_t fEtasegment;              //! transient
 177   /** trackletlength:   Number of hits a tracklet has to have */
 178   Int_t fTrackletlength;          //! transient
 179   /** tracklength:      Number of hits a track has to have */
 180   Int_t fTracklength;             //! transient
 181   /** rowscopetracklet: Search range of rows for a tracklet */
 182   Int_t fRowscopetracklet;        //! transient
 183   /** rowscopetrack:    Search range of rows for a track */
 184   Int_t fRowscopetrack;           //! transient
 185   /** min_pt_fit:       Cut for moment fit, use:SetMaxDca(min_pt_fit) */
 186   Double_t fMinPtFit;             //! transient
 187   /** maxangle:         AliHLTTPCTransform::Deg2Rad(10), max angle for the three point look aheand */
 188   Double_t fMaxangle;             //! transient
 189   /** goodDist:         Threshold distancs between two hits when building tracklets */
 190   Double_t fGoodDist;             //! transient
 191   /** hitChi2Cut:       Max chi2 of added hit to track */
 192   Double_t fHitChi2Cut;           //! transient
 193   /** goodHitChi2:      Stop looking for next hit to add if chi2 is less then goodHitChi2 */
 194   Double_t fGoodHitChi2;          //! transient
 195   /** trackChi2Cut:     Max chi2 for track after final fit */
 196   Double_t fTrackChi2Cut;         //! transient
 197   /** maxdist:          Maximum distance between two clusters when forming segments */
 198   Int_t fMaxdist;                 //! transient
 199   /** maxphi:           Max phi difference for neighboring hits */
 200   Double_t fMaxphi;               //! transient
 201   /** maxeta:           Max eta difference for neighboring hits */
 202   Double_t fMaxeta;               //! transient
 203
 204   /** merger object */
 205   AliHLTTPCInterMerger *fpInterMerger;                             //! transient
 206
 207   ClassDef(AliHLTTPCSliceTrackerComponent, 0);
 208
 209 };
 210 #endif