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

//-*- Mode: C++ -*-
// $Id$
#ifndef ALIHLTTPCEVENTSTATISTICSPRODUCERCOMPONENT_H
#define ALIHLTTPCEVENTSTATISTICSPRODUCERCOMPONENT_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   AliHLTTPCEventStatisticsProducerComponent.h
    @author Jochen Thaeder
    @date   
    @brief  Component for the @see AliHLTTPCEventStatisticsProducer class
*/

// 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"

#include "AliHLTTPCEventStatistics.h"
#include "AliHLTTPCTrackArray.h"
#include "AliESDEvent.h"
#include "TTree.h"

/**
 * @class  AliHLTTPCEventStatisticsProducerComponent
 * @brief  Component for the @see AliHLTTPCEventStatisticsProducer class
 *
 *
 * @ingroup alihlt_run_statistics alihlt_trigger
 */

class AliHLTTPCEventStatisticsProducerComponent : public AliHLTProcessor {
  
public:
  
  /** constructor */
  AliHLTTPCEventStatisticsProducerComponent();
  /** destructor */
  virtual ~AliHLTTPCEventStatisticsProducerComponent();

  // Public functions to implement AliHLTComponent's interface.
  // These functions are required for the registration process
  
  const char* GetComponentID();
  void GetInputDataTypes( AliHLTComponentDataTypeList& list );

  AliHLTComponentDataType GetOutputDataType();

  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
  AliHLTComponent* Spawn();

 protected:

  using AliHLTProcessor::DoEvent;

  // Protected functions to implement AliHLTComponent's interface.
  // These functions provide initialization as well as the actual processing
  // capabilities of the component. 
  
  /** Initialize the trigger component. */
  Int_t DoInit( int argc, const char** argv );

  /** DeInitialize the trigger component. */
  Int_t DoDeinit();
  
  /** Process the data in the trigger component */
  Int_t DoEvent( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);

  // ------------------------------------------------------------------------------------------

  /** Initialize for next event */
  void InitializeEvent();                  

  /** Add new cluster block 
   * @param ptr   Pointer to data block
   * @param size  Size of data block
   * @param slice Slice
   * @param patch Patch
   */
  void AddClusters( void* ptr, Int_t slice, Int_t patch );

  /** Add new tracks block
   * @param ptr   Pointer to data block
   * @param size  Size of data block
   * @param slice Slice, default is -1 for GlobalMerger tracks
   */
  void AddTracks( void* ptr, Int_t slice=-1 );     

  /** Add ESD
   * @param esdEvent Pointer to AliESDEvent
   */
  void AddESD( TTree* esdTree );     

  /** Process even -> get process statistics */
  void ProcessEvent();                          

  /** Fill tracks per slice ( @see fNTracksPerSlice ), if global tracks */
  void FillTracksPerSlice();    

  /** Get ptr to @see AliHLTTPCEventStatistics, is a TObject */
  AliHLTTPCEventStatistics* GetEventStatistics() { return fEvStat; }    

private:
 
  /** copy constructor prohibited */
  AliHLTTPCEventStatisticsProducerComponent (const AliHLTTPCEventStatisticsProducerComponent&);

  /** assignment operator prohibited */
  AliHLTTPCEventStatisticsProducerComponent& operator= (const AliHLTTPCEventStatisticsProducerComponent&);

  /** Threshold for long tracks */
  Int_t fClusterThreshold;                                                                           // see above

  /** Event Statistics class*/
  AliHLTTPCEventStatistics* fEvStat;                                                                 //! transient

  /** Tracks per slice */
  Int_t fNTracksPerSlice[36];                                                                        // see above

  /** Track container of class @see AliHLTTPCTrackArray */
  AliHLTTPCTrackArray *fTracks;                                                                      //! transient

  /** If tracks in global coordinates @see fTracksPerSlice has still to be filled */
  Bool_t fGlobalTracks;                                                                              // see above

  /** Number of slices with tracks */
  Int_t fNSlice;                                                                                     // see above

  ClassDef(AliHLTTPCEventStatisticsProducerComponent, 0);

};
#endif
Commit	Line	Data
2ff24e4c	1	//-- Mode: C++ --
	2	// $Id$
	3	#ifndef ALIHLTTPCEVENTSTATISTICSPRODUCERCOMPONENT_H
	4	#define ALIHLTTPCEVENTSTATISTICSPRODUCERCOMPONENT_H
	5
	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 AliHLTTPCEventStatisticsProducerComponent.h
	11	@author Jochen Thaeder
	12	@date
	13	@brief Component for the @see AliHLTTPCEventStatisticsProducer class
	14	*/
	15
	16	// see below for class documentation
	17	// or
	18	// refer to README to build package
	19	// or
	20	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	21
	22	#include "AliHLTProcessor.h"
	23
	24	#include "AliHLTTPCEventStatistics.h"
	25	#include "AliHLTTPCTrackArray.h"
1d229444	26	#include "AliESDEvent.h"
1d229444	27	#include "TTree.h"
2ff24e4c	28
	29	/**
	30	* @class AliHLTTPCEventStatisticsProducerComponent
	31	* @brief Component for the @see AliHLTTPCEventStatisticsProducer class
	32	*
	33	*
	34	* @ingroup alihlt_run_statistics alihlt_trigger
	35	*/
	36
	37	class AliHLTTPCEventStatisticsProducerComponent : public AliHLTProcessor {
	38
	39	public:
	40
	41	/** constructor */
	42	AliHLTTPCEventStatisticsProducerComponent();
	43	/** destructor */
	44	virtual ~AliHLTTPCEventStatisticsProducerComponent();
	45
	46	// Public functions to implement AliHLTComponent's interface.
	47	// These functions are required for the registration process
	48
	49	const char* GetComponentID();
	50	void GetInputDataTypes( AliHLTComponentDataTypeList& list );
	51
	52	AliHLTComponentDataType GetOutputDataType();
2ff24e4c	53
	54	virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
	55	AliHLTComponent* Spawn();
	56
	57	protected:
	58
	59	using AliHLTProcessor::DoEvent;
	60
	61	// Protected functions to implement AliHLTComponent's interface.
	62	// These functions provide initialization as well as the actual processing
	63	// capabilities of the component.
	64
	65	/** Initialize the trigger component. */
	66	Int_t DoInit( int argc, const char** argv );
	67
	68	/** DeInitialize the trigger component. */
	69	Int_t DoDeinit();
	70
	71	/** Process the data in the trigger component */
	72	Int_t DoEvent( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);
	73
	74	// ------------------------------------------------------------------------------------------
	75
	76	/** Initialize for next event */
	77	void InitializeEvent();
	78
	79	/** Add new cluster block
	80	* @param ptr Pointer to data block
	81	* @param size Size of data block
	82	* @param slice Slice
	83	* @param patch Patch
	84	*/
5eefc803	85	void AddClusters( void* ptr, Int_t slice, Int_t patch );
2ff24e4c	86
	87	/** Add new tracks block
	88	* @param ptr Pointer to data block
	89	* @param size Size of data block
	90	* @param slice Slice, default is -1 for GlobalMerger tracks
	91	*/
5eefc803	92	void AddTracks( void* ptr, Int_t slice=-1 );
2ff24e4c	93
1d229444	94	/** Add ESD
	95	* @param esdEvent Pointer to AliESDEvent
	96	*/
	97	void AddESD( TTree* esdTree );
	98
2ff24e4c	99	/** Process even -> get process statistics */
	100	void ProcessEvent();
	101
	102	/** Fill tracks per slice ( @see fNTracksPerSlice ), if global tracks */
	103	void FillTracksPerSlice();
	104
	105	/** Get ptr to @see AliHLTTPCEventStatistics, is a TObject */
	106	AliHLTTPCEventStatistics* GetEventStatistics() { return fEvStat; }
	107
	108	private:
	109
	110	/** copy constructor prohibited */
	111	AliHLTTPCEventStatisticsProducerComponent (const AliHLTTPCEventStatisticsProducerComponent&);
	112
	113	/** assignment operator prohibited */
	114	AliHLTTPCEventStatisticsProducerComponent& operator= (const AliHLTTPCEventStatisticsProducerComponent&);
	115
	116	/** Threshold for long tracks */
	117	Int_t fClusterThreshold; // see above
	118
	119	/** Event Statistics class*/
	120	AliHLTTPCEventStatistics* fEvStat; //! transient
	121
	122	/** Tracks per slice */
	123	Int_t fNTracksPerSlice[36]; // see above
	124
	125	/** Track container of class @see AliHLTTPCTrackArray */
	126	AliHLTTPCTrackArray *fTracks; //! transient
	127
	128	/** If tracks in global coordinates @see fTracksPerSlice has still to be filled */
	129	Bool_t fGlobalTracks; // see above
	130
	131	/** Number of slices with tracks */
	132	Int_t fNSlice; // see above
	133
	134	ClassDef(AliHLTTPCEventStatisticsProducerComponent, 0);
	135
	136	};
	137	#endif
	138