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

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

#ifndef ALIHLTTPCSLICETRACKERCOMPONENT_H
#define ALIHLTTPCSLICETRACKERCOMPONENT_H
/* Copyright(c) 1998-1999, 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.
*/

// see below for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

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