[u/mrichter/AliRoot.git] / HLT / MUON / OnlineAnalysis / AliHLTMUONMansoTrackerComponent.h

#ifndef AliHLTMUONMANSOTRACKERCOMPONENT_H
#define AliHLTMUONMANSOTRACKERCOMPONENT_H
/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

/**
 *  @file   AliHLTMUONMansoTrackerComponent.h
 *  @author Artur Szostak <artursz@iafrica.com>
 *  @date   
 *  @brief  Tracker component implementing the Manso algorithm for the dimuon HLT.
 */

#include "AliHLTProcessor.h"
#include "AliHLTMUONConstants.h"
#include "AliHLTMUONMansoTracker.h"

/**
 * @class AliHLTMUONMansoTrackerComponent
 * @brief Manso tracker component
 */
class AliHLTMUONMansoTrackerComponent : public AliHLTProcessor
    {
    public:
	AliHLTMUONMansoTrackerComponent();
	virtual ~AliHLTMUONMansoTrackerComponent();

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

	const char* GetComponentID();
	void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
	AliHLTComponentDataType GetOutputDataType();
	virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
	AliHLTComponent* Spawn();
	
    protected:
	
	// Protected functions to implement AliHLTComponent's interface.
	// These functions provide initialization as well as the actual processing
	// capabilities of the component. 

	int DoInit( int argc, const char** argv );
	int DoDeinit();
	int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
		     AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
		     AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
	
    private:

	// The size of the output data produced, as a percentage of the input data's size.
	// Can be greater than 100 (%)
	unsigned fOutputPercentage;

	// For Tracking

	//TrackerCallback callback;
	AliHLTMUONMansoTracker* fTracker;

/* 	struct TriggerBlock */
/* 	{ */
/* 	  const AliHLTMUONCoreTriggerRecord *data; */
/* 	}; */

	AliHLTMUONCoreTriggerRecord *fTrigData;
	//std::vector<TriggerBlock> fTriggerBlocks;  // array of trigger record blocks
	
	ClassDef(AliHLTMUONMansoTrackerComponent, 0);

    };

#endif // AliHLTMUONMANSOTRACKERCOMPONENT_H
Commit	Line	Data
b0201cbe	1	#ifndef AliHLTMUONMANSOTRACKERCOMPONENT_H
	2	#define AliHLTMUONMANSOTRACKERCOMPONENT_H
	3	/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	/**
	9	* @file AliHLTMUONMansoTrackerComponent.h
b92524d0	10	* @author Artur Szostak <artursz@iafrica.com>
b0201cbe	11	* @date
	12	* @brief Tracker component implementing the Manso algorithm for the dimuon HLT.
	13	*/
	14
	15	#include "AliHLTProcessor.h"
b12fe461	16	#include "AliHLTMUONConstants.h"
b12fe461	17	#include "AliHLTMUONMansoTracker.h"
b0201cbe	18
	19	/**
	20	* @class AliHLTMUONMansoTrackerComponent
	21	* @brief Manso tracker component
	22	*/
	23	class AliHLTMUONMansoTrackerComponent : public AliHLTProcessor
	24	{
	25	public:
	26	AliHLTMUONMansoTrackerComponent();
	27	virtual ~AliHLTMUONMansoTrackerComponent();
	28
	29	// Public functions to implement AliHLTComponent's interface.
	30	// These functions are required for the registration process
	31
	32	const char* GetComponentID();
	33	void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
	34	AliHLTComponentDataType GetOutputDataType();
	35	virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
	36	AliHLTComponent* Spawn();
	37
	38	protected:
	39
	40	// Protected functions to implement AliHLTComponent's interface.
	41	// These functions provide initialization as well as the actual processing
	42	// capabilities of the component.
	43
	44	int DoInit( int argc, const char** argv );
	45	int DoDeinit();
	46	int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
	47	AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
	48	AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
	49
	50	private:
	51
	52	// The size of the output data produced, as a percentage of the input data's size.
	53	// Can be greater than 100 (%)
	54	unsigned fOutputPercentage;
	55
	56	// For Tracking
	57
	58	//TrackerCallback callback;
	59	AliHLTMUONMansoTracker* fTracker;
	60
	61	/* struct TriggerBlock */
	62	/* { */
	63	/* const AliHLTMUONCoreTriggerRecord data; /
	64	/* }; */
	65
	66	AliHLTMUONCoreTriggerRecord *fTrigData;
	67	//std::vector<TriggerBlock> fTriggerBlocks; // array of trigger record blocks
	68
	69	ClassDef(AliHLTMUONMansoTrackerComponent, 0);
	70
	71	};
	72
	73	#endif // AliHLTMUONMANSOTRACKERCOMPONENT_H