[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCSliceTrackerComponent.h

// XEmacs -*-C++-*-
// @(#) $Id$

#ifndef ALIHLTTPCSLICETRACKERCOMPONENT_H
#define ALIHLTTPCSLICETRACKERCOMPONENT_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   AliHLTTPCSliceTrackerComponent.h
    @author Timm Steinbeck, Matthias Richter
    @date   
    @brief  The TPC conformal mapping tracker component.
*/

#include "AliHLTProcessor.h"

class AliHLTTPCConfMapper;
class AliHLTTPCVertex;
class AliHLTTPCInterMerger;

/**
 * @class AliHLTTPCSliceTrackerComponent
 * The TPC conformal mapping tracker component.
 * 
 * Component ID: \b TPCSliceTracker <br>
 * Library: \b libAliHLTTPC.
 *
 * Mandatory arguments: <br>
 * \li -bfield     <i> magnetic field   </i> <br> 
 *      should allways be used. If there is no magnetic field, use 0.00001
 * 
 * Optional arguments: <br>
 * \li -pp-run <br>  
 *      will give fixed trackparameters for p-p runs.
 * \li -Pb-Pb-run <br>  
 *      will give fixed trackparameters for Pb-Pb runs.
 * \li -multiplicity     <i> multiplicity  </i> <br> 
 *      set the multiplicity of your collitions. Used for Pb-Pb events.
 * \li -disable-merger <br>
 *      turns off the intermerging on sectorlevel. Only use in spacial cases.
 * \li -nonvertextracking <br> 
 *      the tracking will do a reconstruction of clusters without vertex constraint.
 * \li -mainvertextrackingoff <br>
 *      will turn off the tracking with vertex constraint. Use together with -nonvertextracking.
 * \li -etarange   <i> eta range   </i> <br> 
 *      sets the eta range for the tracking.
 * \li -etasegment <i> eta segments   </i> <br> 
 *      let you set the number of eta segments in the trscker.
 * \li -chi2cut <i> chi²   </i> <br> 
 *      set the chi² for the tracker.
 * \li -rowscopetracklet <i> number of padrows   </i> <br> 
 *     tells the tracker how many padrows down it should look for the next cluster when making tracklets.
 * \li -rowscopetrack <i> number of padrows   </i> <br>
 *     tells the tracker how many padrows down it should look for the next cluster when making track.
 * \li -trackletlength <i> number of clusters   </i> <br>
 *     the minimum number of clusters to be on a tracklet.
 * \li -tracklength <i> number of clusters   </i> <br>
 *     the minimum number of clusters to be on a track.
 *
 * @ingroup alihlt_tpc_components
 */
class AliHLTTPCSliceTrackerComponent : public AliHLTProcessor
{
public:
  /** default constructor */
  AliHLTTPCSliceTrackerComponent();
  /** destructor */
  virtual ~AliHLTTPCSliceTrackerComponent();

  // Public functions to implement AliHLTComponent's interface.
  // These functions are required for the registration process

  /** interface function, see @ref AliHLTComponent for description */
  const char* GetComponentID();
  /** interface function, see @ref AliHLTComponent for description */
  void GetInputDataTypes(AliHLTComponentDataTypeList& list);
  /** interface function, see @ref AliHLTComponent for description */
  AliHLTComponentDataType GetOutputDataType();
  /** interface function, see @ref AliHLTComponent for description */
  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
  /** interface function, see @ref AliHLTComponent for description */
  AliHLTComponent* Spawn();

protected:

  /**
   * Set Tracker parameters
   * Knowledge on that has been lost, so somebody has to insert more
   * documentation.
   */	
  void SetTrackerParam(Int_t phiSegments=50,Int_t etaSegments=100,
		       Int_t trackletlength=3,Int_t tracklength=5,
		       Int_t rowscopetracklet=2,Int_t rowscopetrack=3,
		       Double_t minPtFit=0,Double_t maxangle=1.31,
		       Double_t goodDist=5,Double_t hitChi2Cut=10,
		       Double_t goodHitChi2=20,Double_t trackChi2Cut=50,
		       Int_t maxdist=50,Double_t maxphi=0.1,Double_t maxeta=0.1);

  /**
   * Set Tracker parameters
   * Knowledge on that has been lost, so somebody has to insert more
   * documentation.
   */
  void SetTrackerParam( Bool_t doPP, Bool_t doPbPb, Int_t multiplicity, 
			Double_t bField, Int_t etasegment, Double_t hitchi2cut, 
			Int_t rowscopetracklet, Int_t rowscopetrack, 
			Int_t trackletlength, Int_t tracklength );

  /**
   * Set default tracker parameters
   * Knowledge on that has been lost, so somebody has to insert more
   * documentation.
   */
  void SetTrackerParam1();

  // Protected functions to implement AliHLTComponent's interface.
  // These functions provide initialization as well as the actual processing
  // capabilities of the component. 

  /** interface function, see @ref AliHLTComponent for description */
  int DoInit( int argc, const char** argv );
  /** interface function, see @ref AliHLTComponent for description */
  int DoDeinit();
  /** interface function, see @ref AliHLTComponent for description */
  int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
	       AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
	       AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks );

  int Reconfigure(const char* cdbEntry, const char* chainId);

  using AliHLTProcessor::DoEvent;
  
private:
  /** copy constructor prohibited */
  AliHLTTPCSliceTrackerComponent(const AliHLTTPCSliceTrackerComponent&);
  /** assignment operator prohibited */
  AliHLTTPCSliceTrackerComponent& operator=(const AliHLTTPCSliceTrackerComponent&);
  /**
   * Configure the component.
   * Parse a string for the configuration arguments and set the component
   * properties.
   */  
  int Configure(const char* arguments);

  /** instance of the tracker */
  AliHLTTPCConfMapper* fTracker;                                   //! transient
  /** vertex object */
  AliHLTTPCVertex* fVertex;                                        //! transient
  /** eta range */
  Float_t fEta[2];                                                 //  see above
  /** switch for subsequent non-vertex tracking */
  Bool_t fDoNonVertex;                                             //  see above
  /** */
  Bool_t  fDoPP;                                                   //  see above
   /** */
  Bool_t  fDoPbPb;                                                 //  see above
  /** multiplicity estimate */
  Int_t fMultiplicity;                                             //  see above
  /** magnetic field */
  Double_t fBField;                                                //  see above

  Bool_t fnonvertextracking;   // enable NONVERTEX Tracking
  Bool_t fmainvertextracking;  // enable MAINVERTEX Tracking

  /** ParameterVariables for the trackeparameters */


  /** phi_segments:     Devide the space into phi_segments */
  Int_t fPhisegment;              //! transient    
  /** ets_segments:     Devide the space into eta_segments */
  Int_t fEtasegment;              //! transient
  /** trackletlength:   Number of hits a tracklet has to have */
  Int_t fTrackletlength;          //! transient
  /** tracklength:      Number of hits a track has to have */
  Int_t fTracklength;             //! transient
  /** rowscopetracklet: Search range of rows for a tracklet */
  Int_t fRowscopetracklet;        //! transient
  /** rowscopetrack:    Search range of rows for a track */
  Int_t fRowscopetrack;           //! transient
  /** min_pt_fit:       Cut for moment fit, use:SetMaxDca(min_pt_fit) */
  Double_t fMinPtFit;             //! transient
  /** maxangle:         AliHLTTPCTransform::Deg2Rad(10), max angle for the three point look aheand */
  Double_t fMaxangle;             //! transient
  /** goodDist:         Threshold distancs between two hits when building tracklets */
  Double_t fGoodDist;             //! transient
  /** hitChi2Cut:       Max chi2 of added hit to track */
  Double_t fHitChi2Cut;           //! transient
  /** goodHitChi2:      Stop looking for next hit to add if chi2 is less then goodHitChi2 */
  Double_t fGoodHitChi2;          //! transient
  /** trackChi2Cut:     Max chi2 for track after final fit */
  Double_t fTrackChi2Cut;         //! transient
  /** maxdist:          Maximum distance between two clusters when forming segments */
  Int_t fMaxdist;                 //! transient
  /** maxphi:           Max phi difference for neighboring hits */
  Double_t fMaxphi;               //! transient
  /** maxeta:           Max eta difference for neighboring hits */
  Double_t fMaxeta;               //! transient 
 
  /** merger object */
  AliHLTTPCInterMerger *fpInterMerger;                             //! transient

  ClassDef(AliHLTTPCSliceTrackerComponent, 0);

};
#endif
Commit	Line	Data
71d7c760	1	// XEmacs --C++--
	2	// @(#) $Id$
	3
	4	#ifndef ALIHLTTPCSLICETRACKERCOMPONENT_H
	5	#define ALIHLTTPCSLICETRACKERCOMPONENT_H
297174de	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 *
71d7c760	9
de554e07	10	/** @file AliHLTTPCSliceTrackerComponent.h
	11	@author Timm Steinbeck, Matthias Richter
	12	@date
	13	@brief The TPC conformal mapping tracker component.
	14	*/
71d7c760	15
71d7c760	16	#include "AliHLTProcessor.h"
71d7c760	17
a6c02c85	18	class AliHLTTPCConfMapper;
a6c02c85	19	class AliHLTTPCVertex;
ecefc48a	20	class AliHLTTPCInterMerger;
71d7c760	21
de554e07	22	/**
	23	* @class AliHLTTPCSliceTrackerComponent
	24	* The TPC conformal mapping tracker component.
	25	*
e6421c43	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
de554e07	32	*
e6421c43	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	*
2efb85be	61	* @ingroup alihlt_tpc_components
de554e07	62	*/
71d7c760	63	class AliHLTTPCSliceTrackerComponent : public AliHLTProcessor
6235cd38	64	{
	65	public:
	66	/** default constructor */
	67	AliHLTTPCSliceTrackerComponent();
6235cd38	68	/** destructor */
6235cd38	69	virtual ~AliHLTTPCSliceTrackerComponent();
71d7c760	70
5df0cbb9	71	// Public functions to implement AliHLTComponent's interface.
5df0cbb9	72	// These functions are required for the registration process
71d7c760	73
5df0cbb9	74	/** interface function, see @ref AliHLTComponent for description */
	75	const char* GetComponentID();
	76	/** interface function, see @ref AliHLTComponent for description */
7bcd6cad	77	void GetInputDataTypes(AliHLTComponentDataTypeList& list);
5df0cbb9	78	/** interface function, see @ref AliHLTComponent for description */
	79	AliHLTComponentDataType GetOutputDataType();
	80	/** interface function, see @ref AliHLTComponent for description */
	81	virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
	82	/** interface function, see @ref AliHLTComponent for description */
	83	AliHLTComponent* Spawn();
a655eae3	84
6235cd38	85	protected:
71d7c760	86
5df0cbb9	87	/**
	88	* Set Tracker parameters
	89	* Knowledge on that has been lost, so somebody has to insert more
	90	* documentation.
	91	*/
	92	void SetTrackerParam(Int_t phiSegments=50,Int_t etaSegments=100,
	93	Int_t trackletlength=3,Int_t tracklength=5,
	94	Int_t rowscopetracklet=2,Int_t rowscopetrack=3,
	95	Double_t minPtFit=0,Double_t maxangle=1.31,
	96	Double_t goodDist=5,Double_t hitChi2Cut=10,
	97	Double_t goodHitChi2=20,Double_t trackChi2Cut=50,
e6421c43	98	Int_t maxdist=50,Double_t maxphi=0.1,Double_t maxeta=0.1);
71d7c760	99
5df0cbb9	100	/**
	101	* Set Tracker parameters
	102	* Knowledge on that has been lost, so somebody has to insert more
	103	* documentation.
	104	*/
e6421c43	105	void SetTrackerParam( Bool_t doPP, Bool_t doPbPb, Int_t multiplicity,
	106	Double_t bField, Int_t etasegment, Double_t hitchi2cut,
	107	Int_t rowscopetracklet, Int_t rowscopetrack,
	108	Int_t trackletlength, Int_t tracklength );
5df0cbb9	109
	110	/**
	111	* Set default tracker parameters
	112	* Knowledge on that has been lost, so somebody has to insert more
	113	* documentation.
	114	*/
	115	void SetTrackerParam1();
	116
	117	// Protected functions to implement AliHLTComponent's interface.
	118	// These functions provide initialization as well as the actual processing
	119	// capabilities of the component.
	120
	121	/** interface function, see @ref AliHLTComponent for description */
	122	int DoInit( int argc, const char** argv );
	123	/** interface function, see @ref AliHLTComponent for description */
	124	int DoDeinit();
	125	/** interface function, see @ref AliHLTComponent for description */
	126	int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
	127	AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
7bcd6cad	128	AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks );
5d2abf3b	129
669159ae	130	int Reconfigure(const char* cdbEntry, const char* chainId);
669159ae	131
5d2abf3b	132	using AliHLTProcessor::DoEvent;
5df0cbb9	133
6235cd38	134	private:
cb703d46	135	/** copy constructor prohibited */
	136	AliHLTTPCSliceTrackerComponent(const AliHLTTPCSliceTrackerComponent&);
	137	/** assignment operator prohibited */
	138	AliHLTTPCSliceTrackerComponent& operator=(const AliHLTTPCSliceTrackerComponent&);
669159ae	139	/**
	140	* Configure the component.
	141	* Parse a string for the configuration arguments and set the component
	142	* properties.
	143	*/
	144	int Configure(const char* arguments);
71d7c760	145
6235cd38	146	/** instance of the tracker */
	147	AliHLTTPCConfMapper* fTracker; //! transient
	148	/** vertex object */
	149	AliHLTTPCVertex* fVertex; //! transient
	150	/** eta range */
	151	Float_t fEta[2]; // see above
	152	/** switch for subsequent non-vertex tracking */
	153	Bool_t fDoNonVertex; // see above
	154	/** */
	155	Bool_t fDoPP; // see above
e6421c43	156	/** */
e6421c43	157	Bool_t fDoPbPb; // see above
6235cd38	158	/** multiplicity estimate */
	159	Int_t fMultiplicity; // see above
	160	/** magnetic field */
	161	Double_t fBField; // see above
71d7c760	162
6235cd38	163	Bool_t fnonvertextracking; // enable NONVERTEX Tracking
6235cd38	164	Bool_t fmainvertextracking; // enable MAINVERTEX Tracking
738c049f	165
e6421c43	166	/** ParameterVariables for the trackeparameters */
	167
	168
	169	/** phi_segments: Devide the space into phi_segments */
	170	Int_t fPhisegment; //! transient
	171	/** ets_segments: Devide the space into eta_segments */
	172	Int_t fEtasegment; //! transient
	173	/** trackletlength: Number of hits a tracklet has to have */
	174	Int_t fTrackletlength; //! transient
	175	/** tracklength: Number of hits a track has to have */
	176	Int_t fTracklength; //! transient
	177	/** rowscopetracklet: Search range of rows for a tracklet */
	178	Int_t fRowscopetracklet; //! transient
	179	/** rowscopetrack: Search range of rows for a track */
	180	Int_t fRowscopetrack; //! transient
	181	/** min_pt_fit: Cut for moment fit, use:SetMaxDca(min_pt_fit) */
	182	Double_t fMinPtFit; //! transient
	183	/** maxangle: AliHLTTPCTransform::Deg2Rad(10), max angle for the three point look aheand */
	184	Double_t fMaxangle; //! transient
	185	/** goodDist: Threshold distancs between two hits when building tracklets */
	186	Double_t fGoodDist; //! transient
	187	/** hitChi2Cut: Max chi2 of added hit to track */
	188	Double_t fHitChi2Cut; //! transient
	189	/** goodHitChi2: Stop looking for next hit to add if chi2 is less then goodHitChi2 */
	190	Double_t fGoodHitChi2; //! transient
	191	/** trackChi2Cut: Max chi2 for track after final fit */
	192	Double_t fTrackChi2Cut; //! transient
	193	/** maxdist: Maximum distance between two clusters when forming segments */
	194	Int_t fMaxdist; //! transient
	195	/** maxphi: Max phi difference for neighboring hits */
	196	Double_t fMaxphi; //! transient
	197	/** maxeta: Max eta difference for neighboring hits */
	198	Double_t fMaxeta; //! transient
	199
ecefc48a	200	/** merger object */
	201	AliHLTTPCInterMerger *fpInterMerger; //! transient
	202
6235cd38	203	ClassDef(AliHLTTPCSliceTrackerComponent, 0);
71d7c760	204
6235cd38	205	};
71d7c760	206	#endif