[u/mrichter/AliRoot.git] / HLT / MUON / utils / AliHLTMUONRawDataHistoComponent.h

#ifndef AliHLTMUONRAWDATAHISTOCOMPONENT_H
#define AliHLTMUONRAWDATAHISTOCOMPONENT_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                               */

// $Id: $

///
///  @file   AliHLTMUONRawDataHistoComponent.h
///  @author Artur Szostak <artursz@iafrica.com>
///  @date   30 April 2008
///  @brief  Declaration of a component to generate basic monitoring histograms of raw data.
///

#include "AliHLTMUONProcessor.h"
#include "AliHLTMUONDataTypes.h"
#include "AliMUONTrackerDDLDecoder.h"
#include "AliMUONTriggerDDLDecoder.h"
#include "TH1D.h"

/**
 * @class AliHLTMUONRawDataHistoComponent
 * @brief Dimuon HLT component for generating basic monitoring histograms for raw data.
 *
 * This component is useful for performing basic monitoring tasks on the raw data
 * from the muon spectrometer. It will try and decode the data and histogram the
 * following information:
 * \li The distribution of signals per DDL.
 * \li The number of ADC values found per MANU for each DDL.
 * \li The error codes found by the decoders while trying to decode the data for each DDL.
 *
 * <h2>General properties:</h2>
 *
 * Component ID: \b MUONRawDataHistogrammer <br>
 * Library: \b libAliHLTMUON.so <br>
 * Input Data Types:  AliHLTMUONConstants::DDLRawDataType() = "DDL_RAW :MUON" <br>
 * Output Data Types: AliHLTMUONConstants::HistogramDataType() = "ROOTHIST:MUON" <br>
 *
 * <h2>Mandatory arguments:</h2>
 * None.
 *
 * <h2>Optional arguments:</h2>
 * \li -pubdelay <i>delay</i> <br>
 *      Indicates the number of seconds to wait between publishing the histograms.
 *      The default is zero seconds. <i>delay</i> must be a positive floating point
 *      number. <br>
 * \li -noemptyhists <br>
 *      If indicated then any histograms that are empty will not be published.
 *      By default all events are processed. <br>
 * \li -onlydataevents <br>
 *      If indicated then only data events are processed.
 *      By default all events are processed. <br>
 * \li -clearafterpub <br>
 *      If specified then all the internal histograms are cleared after they are
 *      published, so they will not accumilate statistics over the whole run.
 *      This is off by default. <br>
 * \li -tryrecover <br>
 *      This is a special option to the raw data decoder to turn on logic which will
 *      try and recover from corrupt raw DDL data. This is off by default. <br>
 *
 * <h2>Standard configuration:</h2>
 * There is no special configuration for this component.
 *
 * <h2>Default CDB entries:</h2>
 * None.
 *
 * <h2>Performance:</h2>
 * A few milliseconds per event.
 *
 * <h2>Memory consumption:</h2>
 * Minimal, under 1 MBytes.
 *
 * <h2>Output size:</h2>
 * A few kBytes.
 *
 * @ingroup alihlt_muon_components
 */
class AliHLTMUONRawDataHistoComponent : public AliHLTMUONProcessor
{
public:
	AliHLTMUONRawDataHistoComponent();
	virtual ~AliHLTMUONRawDataHistoComponent();

	// Public functions to implement the AliHLTProcessor interface.
	// These functions are required for the registration process.
	virtual const char* GetComponentID();
	virtual void GetInputDataTypes(AliHLTComponentDataTypeList& list);
	virtual AliHLTComponentDataType GetOutputDataType();
	virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
	virtual AliHLTComponent* Spawn();

protected:

	// Protected functions to implement the AliHLTProcessor interface.
	// These functions provide initialization as well as the actual processing
	// capabilities of the component.
	virtual int DoInit(int argc, const char** argv);
	virtual bool IgnoreArgument(const char* arg) const;
	virtual int DoDeinit();
	virtual int DoEvent(
			const AliHLTComponentEventData& evtData,
			AliHLTComponentTriggerData& trigData
		);
	
	using AliHLTProcessor::DoEvent;

private:

	class AliDecoderHandler : public AliHLTLogging
	{
	public:
	
		AliDecoderHandler() : AliHLTLogging(), fErrorHist(NULL) {}
		virtual ~AliDecoderHandler() {}
		
		/// Returns the error codes histogram.
		TH1D* ErrorHist() const { return fErrorHist; }
		
		/// Sets the error codes histogram.
		void ErrorHist(TH1D* hist) { fErrorHist = hist; }
	
	protected:
	
		/// Fills the error histogram with the given error code.
		void FillErrorHist(Int_t code);
	
		TH1D* fErrorHist;   /// Histogram of error codes found.
		
	private:
	
		// Do not allow copying of this object.
		/// Not implemented.
		AliDecoderHandler(const AliDecoderHandler& obj);
		/// Not implemented.
		AliDecoderHandler& operator = (const AliDecoderHandler& obj);
	};

	class AliTrackerDecoderHandler :
		public AliMUONTrackerDDLDecoderEventHandler, public AliDecoderHandler
	{
	public:
		AliTrackerDecoderHandler() :
			AliMUONTrackerDDLDecoderEventHandler(),
			AliDecoderHandler(),
			fManuHist(NULL),
			fSignalHist(NULL)
		{}
		
		virtual ~AliTrackerDecoderHandler() {}
		
		/// Returns the signals per MANU histogram.
		TH1D* ManuHist() const { return fManuHist; }
		
		/// Sets the signals per MANU histogram.
		void ManuHist(TH1D* hist) { fManuHist = hist; }
		
		/// Returns the signals histogram.
		TH1D* SignalHist() const { return fSignalHist; }
		
		/// Sets the signals histogram.
		void SignalHist(TH1D* hist) { fSignalHist = hist; }
		
		// Methods inherited from AliMUONTrackerDDLDecoderEventHandler:
		
		/// Called for each new data word found.
		void OnData(UInt_t data, bool /*parityError*/);
		
		/// Fills the fErrorHist histogram with the error code received.
		void OnError(ErrorCode code, const void* /*location*/) { FillErrorHist(Int_t(code)); }
	
	private:
	
		// Do not allow copying of this object.
		/// Not implemented.
		AliTrackerDecoderHandler(const AliTrackerDecoderHandler& obj);
		/// Not implemented.
		AliTrackerDecoderHandler& operator = (const AliTrackerDecoderHandler& obj);
		
		TH1D* fManuHist;    /// Histogram of signal distribution per MANU.
		TH1D* fSignalHist;  /// Histogram of the ADC signal distribution.
	};
	
	class AliTriggerDecoderHandler :
		public AliMUONTriggerDDLDecoderEventHandler, public AliDecoderHandler
	{
	public:
		AliTriggerDecoderHandler() :
			AliMUONTriggerDDLDecoderEventHandler(),
			AliDecoderHandler()
		{}
		
		virtual ~AliTriggerDecoderHandler() {}
		
		// Methods inherited from AliMUONTriggerDDLDecoderEventHandler:
		
		/// Fills the fErrorHist histogram with the error code received.
		void OnError(ErrorCode code, const void* /*location*/) { FillErrorHist(Int_t(code)); }
	
	private:
	
		// Do not allow copying of this object.
		/// Not implemented.
		AliTriggerDecoderHandler(const AliTriggerDecoderHandler& obj);
		/// Not implemented.
		AliTriggerDecoderHandler& operator = (const AliTriggerDecoderHandler& obj);
	};

	// Do not allow copying of this class.
	AliHLTMUONRawDataHistoComponent(const AliHLTMUONRawDataHistoComponent& /*obj*/);
	AliHLTMUONRawDataHistoComponent& operator = (const AliHLTMUONRawDataHistoComponent& /*obj*/);

	/**
	 * Decodes the tracker DDL data block and fills the histograms.
	 * \param block  The data block to decode.
	 * \returns true if the block could be decoded and false if there was an error in the data.
	 */
	bool ProcessTrackerDDL(const AliHLTComponentBlockData* block);
	
	/**
	 * Decodes the trigger DDL data block and fills the histograms.
	 * \param block  The data block to decode.
	 * \returns true if the block could be decoded and false if there was an error in the data.
	 */
	bool ProcessTriggerDDL(const AliHLTComponentBlockData* block);
	
	/**
	 * Deletes all the histograms and resets the pointers.
	 */
	void FreeObjects();
	
	AliMUONTrackerDDLDecoder<AliTrackerDecoderHandler> fTrackerDecoder;  // Raw data decoder for the tracker data.
	AliMUONTriggerDDLDecoder<AliTriggerDecoderHandler> fTriggerDecoder;  // Raw data decoder for the trigger data.
	
	double fLastPublishTime;  /// Timestamp for the last time we published data (seconds).
	double fCurrentEventTime;  /// Timestamp for the current event being processed (seconds).
	double fPublishDelay;  /// Delay in second to wait between publishing data.
	TH1D* fErrorHist[22]; /// Histograms for error codes per DDL.
	TH1D* fManuHist[20]; /// Histograms for MANU distributions per DDL.
	TH1D* fSignalHist[20]; /// Histograms for signal distributions per DDL.
	bool fSuppressEmptyHists;  /// Flag indicating if empty histograms should be published or not.
	bool fProcessDataEventsOnly;  /// Flag indicating if only data events should be processed.
	bool fClearAfterPublish;  /// Inficates if the histograms should be reset after being published.
	
	ClassDef(AliHLTMUONRawDataHistoComponent, 0);  // Trigger decision component for the dimuon HLT.
};

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

inline void AliHLTMUONRawDataHistoComponent::AliDecoderHandler::FillErrorHist(Int_t code)
{
	/// Fills the error code into the error code histogram.
	
	assert(fErrorHist != NULL);
	Int_t mincode = Int_t( fErrorHist->GetXaxis()->GetBinCenter(1) );
	Int_t maxcode = Int_t( fErrorHist->GetXaxis()->GetBinCenter(fErrorHist->GetNbinsX()) );
	if (code < mincode or maxcode < code)
	{
		HLTError("Filling an error code which is out of range."
			" Received code %d, but expected it to be in the range [%d..%d]",
			int(code), mincode, maxcode
		);
	}
	fErrorHist->Fill(code);
}


inline void AliHLTMUONRawDataHistoComponent::AliTrackerDecoderHandler::OnData(
		UInt_t data, bool /*parityError*/
	)
{
	/// Fills the signals histogram and also the signal per MANU histogram.

	UInt_t minadc = UInt_t( fSignalHist->GetXaxis()->GetBinCenter(1) );
	UInt_t maxadc = UInt_t( fSignalHist->GetXaxis()->GetBinCenter(fSignalHist->GetNbinsX()) );
	UInt_t minmanu = UInt_t( fManuHist->GetXaxis()->GetBinCenter(1) );
	UInt_t maxmanu = UInt_t( fManuHist->GetXaxis()->GetBinCenter(fManuHist->GetNbinsX()) );
	
	UShort_t manuId; UChar_t channelId; UShort_t adc;
	UnpackADC(data, manuId, channelId, adc);
	
	if (adc < minadc or maxadc < adc)
	{
		HLTError("Filling a signal value which is out of range. Received ADC value"
			" of %d channels, but expected it to be in the range [%d..%d]",
			int(adc), minadc, maxadc
		);
	}
	fSignalHist->Fill(adc);
	
	if (manuId < minmanu or maxmanu < manuId)
	{
		HLTError("Filling a MANU ID value which is out of range. Received"
			" value of %d, but expected it to be in the range [%d..%d]",
			int(manuId), minmanu, maxmanu
		);
	}
	fManuHist->Fill(manuId);
}

#endif // AliHLTMUONRAWDATAHISTOCOMPONENT_H
Commit	Line	Data
a63da6d6	1	#ifndef AliHLTMUONRAWDATAHISTOCOMPONENT_H
	2	#define AliHLTMUONRAWDATAHISTOCOMPONENT_H
	3	/* This file is property of and copyright by the ALICE HLT Project *
	4	* ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
1d8ae082	7	// $Id: $
a63da6d6	8
	9	///
	10	/// @file AliHLTMUONRawDataHistoComponent.h
	11	/// @author Artur Szostak <artursz@iafrica.com>
	12	/// @date 30 April 2008
	13	/// @brief Declaration of a component to generate basic monitoring histograms of raw data.
	14	///
	15
	16	#include "AliHLTMUONProcessor.h"
	17	#include "AliHLTMUONDataTypes.h"
7989fd8e	18	#include "AliMUONTrackerDDLDecoder.h"
	19	#include "AliMUONTriggerDDLDecoder.h"
	20	#include "TH1D.h"
a63da6d6	21
	22	/**
	23	* @class AliHLTMUONRawDataHistoComponent
	24	* @brief Dimuon HLT component for generating basic monitoring histograms for raw data.
1d8ae082	25	*
	26	* This component is useful for performing basic monitoring tasks on the raw data
	27	* from the muon spectrometer. It will try and decode the data and histogram the
	28	* following information:
	29	* \li The distribution of signals per DDL.
	30	* \li The number of ADC values found per MANU for each DDL.
	31	* \li The error codes found by the decoders while trying to decode the data for each DDL.
	32	*
	33	* <h2>General properties:</h2>
	34	*
	35	* Component ID: \b MUONRawDataHistogrammer <br>
	36	* Library: \b libAliHLTMUON.so <br>
	37	* Input Data Types: AliHLTMUONConstants::DDLRawDataType() = "DDL_RAW :MUON" <br>
	38	* Output Data Types: AliHLTMUONConstants::HistogramDataType() = "ROOTHIST:MUON" <br>
	39	*
	40	* <h2>Mandatory arguments:</h2>
	41	* None.
	42	*
	43	* <h2>Optional arguments:</h2>
	44	* \li -pubdelay <i>delay</i> <br>
	45	* Indicates the number of seconds to wait between publishing the histograms.
	46	* The default is zero seconds. <i>delay</i> must be a positive floating point
	47	* number. <br>
	48	* \li -noemptyhists <br>
	49	* If indicated then any histograms that are empty will not be published.
	50	* By default all events are processed. <br>
	51	* \li -onlydataevents <br>
	52	* If indicated then only data events are processed.
	53	* By default all events are processed. <br>
	54	* \li -clearafterpub <br>
	55	* If specified then all the internal histograms are cleared after they are
	56	* published, so they will not accumilate statistics over the whole run.
	57	* This is off by default. <br>
	58	* \li -tryrecover <br>
	59	* This is a special option to the raw data decoder to turn on logic which will
	60	* try and recover from corrupt raw DDL data. This is off by default. <br>
	61	*
	62	* <h2>Standard configuration:</h2>
	63	* There is no special configuration for this component.
	64	*
	65	* <h2>Default CDB entries:</h2>
	66	* None.
	67	*
	68	* <h2>Performance:</h2>
	69	* A few milliseconds per event.
	70	*
	71	* <h2>Memory consumption:</h2>
	72	* Minimal, under 1 MBytes.
	73	*
	74	* <h2>Output size:</h2>
	75	* A few kBytes.
	76	*
ebf7a8e8	77	* @ingroup alihlt_muon_components
a63da6d6	78	*/
	79	class AliHLTMUONRawDataHistoComponent : public AliHLTMUONProcessor
	80	{
	81	public:
	82	AliHLTMUONRawDataHistoComponent();
	83	virtual ~AliHLTMUONRawDataHistoComponent();
	84
	85	// Public functions to implement the AliHLTProcessor interface.
	86	// These functions are required for the registration process.
	87	virtual const char* GetComponentID();
	88	virtual void GetInputDataTypes(AliHLTComponentDataTypeList& list);
	89	virtual AliHLTComponentDataType GetOutputDataType();
	90	virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
	91	virtual AliHLTComponent* Spawn();
	92
	93	protected:
	94
	95	// Protected functions to implement the AliHLTProcessor interface.
	96	// These functions provide initialization as well as the actual processing
	97	// capabilities of the component.
	98	virtual int DoInit(int argc, const char** argv);
	99	virtual bool IgnoreArgument(const char* arg) const;
	100	virtual int DoDeinit();
	101	virtual int DoEvent(
	102	const AliHLTComponentEventData& evtData,
	103	AliHLTComponentTriggerData& trigData
	104	);
	105
	106	using AliHLTProcessor::DoEvent;
	107
	108	private:
	109
7989fd8e	110	class AliDecoderHandler : public AliHLTLogging
	111	{
	112	public:
	113
	114	AliDecoderHandler() : AliHLTLogging(), fErrorHist(NULL) {}
	115	virtual ~AliDecoderHandler() {}
	116
	117	/// Returns the error codes histogram.
	118	TH1D* ErrorHist() const { return fErrorHist; }
	119
	120	/// Sets the error codes histogram.
	121	void ErrorHist(TH1D* hist) { fErrorHist = hist; }
	122
	123	protected:
	124
	125	/// Fills the error histogram with the given error code.
	126	void FillErrorHist(Int_t code);
	127
	128	TH1D* fErrorHist; /// Histogram of error codes found.
	129
	130	private:
	131
	132	// Do not allow copying of this object.
	133	/// Not implemented.
	134	AliDecoderHandler(const AliDecoderHandler& obj);
	135	/// Not implemented.
	136	AliDecoderHandler& operator = (const AliDecoderHandler& obj);
	137	};
	138
	139	class AliTrackerDecoderHandler :
	140	public AliMUONTrackerDDLDecoderEventHandler, public AliDecoderHandler
	141	{
	142	public:
	143	AliTrackerDecoderHandler() :
	144	AliMUONTrackerDDLDecoderEventHandler(),
	145	AliDecoderHandler(),
	146	fManuHist(NULL),
	147	fSignalHist(NULL)
	148	{}
	149
	150	virtual ~AliTrackerDecoderHandler() {}
	151
	152	/// Returns the signals per MANU histogram.
	153	TH1D* ManuHist() const { return fManuHist; }
	154
	155	/// Sets the signals per MANU histogram.
	156	void ManuHist(TH1D* hist) { fManuHist = hist; }
	157
	158	/// Returns the signals histogram.
	159	TH1D* SignalHist() const { return fSignalHist; }
	160
	161	/// Sets the signals histogram.
	162	void SignalHist(TH1D* hist) { fSignalHist = hist; }
	163
	164	// Methods inherited from AliMUONTrackerDDLDecoderEventHandler:
	165
	166	/// Called for each new data word found.
	167	void OnData(UInt_t data, bool /parityError/);
	168
	169	/// Fills the fErrorHist histogram with the error code received.
	170	void OnError(ErrorCode code, const void* /location/) { FillErrorHist(Int_t(code)); }
	171
	172	private:
	173
174	// Do not allow copying of this object.
175	/// Not implemented.
176	AliTrackerDecoderHandler(const AliTrackerDecoderHandler& obj);
177	/// Not implemented.
178	AliTrackerDecoderHandler& operator = (const AliTrackerDecoderHandler& obj);
179
180	TH1D* fManuHist; /// Histogram of signal distribution per MANU.
181	TH1D* fSignalHist; /// Histogram of the ADC signal distribution.
182	};
183
184	class AliTriggerDecoderHandler :
185	public AliMUONTriggerDDLDecoderEventHandler, public AliDecoderHandler
186	{
187	public:
188	AliTriggerDecoderHandler() :
189	AliMUONTriggerDDLDecoderEventHandler(),
190	AliDecoderHandler()
191	{}
192
193	virtual ~AliTriggerDecoderHandler() {}
194
195	// Methods inherited from AliMUONTriggerDDLDecoderEventHandler:
196
197	/// Fills the fErrorHist histogram with the error code received.
198	void OnError(ErrorCode code, const void* /location/) { FillErrorHist(Int_t(code)); }
199
200	private:
201
202	// Do not allow copying of this object.
203	/// Not implemented.
204	AliTriggerDecoderHandler(const AliTriggerDecoderHandler& obj);
205	/// Not implemented.
206	AliTriggerDecoderHandler& operator = (const AliTriggerDecoderHandler& obj);
207	};
208
a63da6d6	209	// Do not allow copying of this class.
	210	AliHLTMUONRawDataHistoComponent(const AliHLTMUONRawDataHistoComponent& /obj/);
	211	AliHLTMUONRawDataHistoComponent& operator = (const AliHLTMUONRawDataHistoComponent& /obj/);
	212
1d8ae082	213	/**
	214	* Decodes the tracker DDL data block and fills the histograms.
	215	* \param block The data block to decode.
	216	* \returns true if the block could be decoded and false if there was an error in the data.
	217	*/
	218	bool ProcessTrackerDDL(const AliHLTComponentBlockData* block);
	219
	220	/**
	221	* Decodes the trigger DDL data block and fills the histograms.
	222	* \param block The data block to decode.
	223	* \returns true if the block could be decoded and false if there was an error in the data.
	224	*/
	225	bool ProcessTriggerDDL(const AliHLTComponentBlockData* block);
	226
	227	/**
	228	* Deletes all the histograms and resets the pointers.
	229	*/
a63da6d6	230	void FreeObjects();
a63da6d6	231
7989fd8e	232	AliMUONTrackerDDLDecoder<AliTrackerDecoderHandler> fTrackerDecoder; // Raw data decoder for the tracker data.
	233	AliMUONTriggerDDLDecoder<AliTriggerDecoderHandler> fTriggerDecoder; // Raw data decoder for the trigger data.
	234
a63da6d6	235	double fLastPublishTime; /// Timestamp for the last time we published data (seconds).
	236	double fCurrentEventTime; /// Timestamp for the current event being processed (seconds).
	237	double fPublishDelay; /// Delay in second to wait between publishing data.
	238	TH1D* fErrorHist[22]; /// Histograms for error codes per DDL.
	239	TH1D* fManuHist[20]; /// Histograms for MANU distributions per DDL.
	240	TH1D* fSignalHist[20]; /// Histograms for signal distributions per DDL.
7989fd8e	241	bool fSuppressEmptyHists; /// Flag indicating if empty histograms should be published or not.
7989fd8e	242	bool fProcessDataEventsOnly; /// Flag indicating if only data events should be processed.
a35ef960	243	bool fClearAfterPublish; /// Inficates if the histograms should be reset after being published.
a63da6d6	244
	245	ClassDef(AliHLTMUONRawDataHistoComponent, 0); // Trigger decision component for the dimuon HLT.
	246	};
	247
7989fd8e	248	//-----------------------------------------------------------------------------
	249
	250	inline void AliHLTMUONRawDataHistoComponent::AliDecoderHandler::FillErrorHist(Int_t code)
	251	{
	252	/// Fills the error code into the error code histogram.
	253
	254	assert(fErrorHist != NULL);
	255	Int_t mincode = Int_t( fErrorHist->GetXaxis()->GetBinCenter(1) );
	256	Int_t maxcode = Int_t( fErrorHist->GetXaxis()->GetBinCenter(fErrorHist->GetNbinsX()) );
	257	if (code < mincode or maxcode < code)
	258	{
	259	HLTError("Filling an error code which is out of range."
	260	" Received code %d, but expected it to be in the range [%d..%d]",
	261	int(code), mincode, maxcode
	262	);
	263	}
	264	fErrorHist->Fill(code);
	265	}
	266
	267
	268	inline void AliHLTMUONRawDataHistoComponent::AliTrackerDecoderHandler::OnData(
	269	UInt_t data, bool /parityError/
	270	)
	271	{
	272	/// Fills the signals histogram and also the signal per MANU histogram.
	273
	274	UInt_t minadc = UInt_t( fSignalHist->GetXaxis()->GetBinCenter(1) );
	275	UInt_t maxadc = UInt_t( fSignalHist->GetXaxis()->GetBinCenter(fSignalHist->GetNbinsX()) );
	276	UInt_t minmanu = UInt_t( fManuHist->GetXaxis()->GetBinCenter(1) );
	277	UInt_t maxmanu = UInt_t( fManuHist->GetXaxis()->GetBinCenter(fManuHist->GetNbinsX()) );
	278
	279	UShort_t manuId; UChar_t channelId; UShort_t adc;
	280	UnpackADC(data, manuId, channelId, adc);
	281
	282	if (adc < minadc or maxadc < adc)
	283	{
	284	HLTError("Filling a signal value which is out of range. Received ADC value"
	285	" of %d channels, but expected it to be in the range [%d..%d]",
	286	int(adc), minadc, maxadc
	287	);
	288	}
	289	fSignalHist->Fill(adc);
	290
	291	if (manuId < minmanu or maxmanu < manuId)
	292	{
	293	HLTError("Filling a MANU ID value which is out of range. Received"
	294	" value of %d, but expected it to be in the range [%d..%d]",
	295	int(manuId), minmanu, maxmanu
	296	);
	297	}
	298	fManuHist->Fill(manuId);
	299	}
	300
a63da6d6	301	#endif // AliHLTMUONRAWDATAHISTOCOMPONENT_H
7989fd8e	302