[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCDataCheckerComponent.cxx

// $Id: $
/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        *
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Artur Szostak <artursz@iafrica.com>                   *
 *                  for The ALICE HLT Project.                            *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/// @file   AliHLTTPCDataCheckerComponent.cxx
/// @author Artur Szostak <artursz@iafrica.com>
/// @date   9 Aug 2010
/// @brief  Implementation of the AliHLTTPCDataCheckerComponent class.
///
/// The AliHLTTPCDataCheckerComponent is used to perform data sanity and integrity
/// checks on the TPC data. This component should be used for testing and debugging.

#include "AliHLTTPCDataCheckerComponent.h"
#include "AliHLTTPCDefinitions.h"
#include "AliTPCRawStreamV3.h"
#include "AliRawReaderMemory.h"
#include <vector>
#include <cstring>
#include <cassert>

ClassImp(AliHLTTPCDataCheckerComponent)


AliHLTTPCDataCheckerComponent::AliHLTTPCDataCheckerComponent() :
	fRawStream(NULL),
	fRawReader(NULL),
	fForwardBadBlocks(false),
	fForwardGoodBlocks(false),
	fIgnoreType(false),
	fIgnoreOrigin(false),
	fIgnoreSpec(false),
	fHandleAllEvents(false)
{
	// Default constructor.
}


AliHLTTPCDataCheckerComponent::~AliHLTTPCDataCheckerComponent()
{
	// Default destructor.
	
	if (fRawStream != NULL) delete fRawStream;
	if (fRawReader != NULL) delete fRawReader;
}


const char* AliHLTTPCDataCheckerComponent::GetComponentID()
{
	// Returns the component ID.
	return "TPCDataChecker";
}


void AliHLTTPCDataCheckerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
{
	// Returns the list of input data types that are handled.
	list.push_back(kAliHLTAnyDataType | kAliHLTDataOriginTPC);
}


AliHLTComponentDataType AliHLTTPCDataCheckerComponent::GetOutputDataType()
{
	// Returns kAliHLTMultipleDataType.
	return kAliHLTMultipleDataType;
}


int AliHLTTPCDataCheckerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& list)
{
	// Returns the list of output data block types generated.
	list.push_back(kAliHLTAnyDataType);
	return int(list.size());
}


void AliHLTTPCDataCheckerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
{
	// Returns the buffer size requirements.
	constBase = 0;
	inputMultiplier = 0;
}


AliHLTComponent* AliHLTTPCDataCheckerComponent::Spawn()
{
	// Creates a new instance of the component.
	return new AliHLTTPCDataCheckerComponent;
}


Int_t AliHLTTPCDataCheckerComponent::DoInit(int argc, const char** argv)
{
	// Initialises the data checker component from the command line.
	
	HLTInfo("Starting TPC data checker component.");
	
	fForwardBadBlocks = true;
	fForwardGoodBlocks = true;
	fIgnoreType = false;
	fIgnoreOrigin = false;
	fIgnoreSpec = false;
	fHandleAllEvents = false;
	
	for (int i = 0; i < argc; ++i)
	{
		if (strcmp(argv[i], "-filter") == 0)
		{
			if (i+1 < argc)
			{
				if (strcmp(argv[i+1], "forwardbad") == 0)
				{
					fForwardBadBlocks = true;
					fForwardGoodBlocks = false;
					++i;
				}
				else if (strcmp(argv[i+1], "forwardgood") == 0)
				{
					fForwardBadBlocks = false;
					fForwardGoodBlocks = true;
					++i;
				}
			}
			fForwardBadBlocks = true;
			fForwardGoodBlocks = false;
			continue;
		}
		
		if (strcmp(argv[i], "-ignoretype") == 0)
		{
			fIgnoreType = true;
			continue;
		}
		
		if (strcmp(argv[i], "-ignoreorigin") == 0)
		{
			fIgnoreOrigin = true;
			continue;
		}
		
		if (strcmp(argv[i], "-ignorespec") == 0)
		{
			fIgnoreSpec = true;
			continue;
		}
		
		if (strcmp(argv[i], "-handle-all-events") == 0)
		{
			fHandleAllEvents = true;
			continue;
		}
		
		HLTError("Unknown option '%s'.", argv[i]);
		return -EINVAL;
	} // for loop
	
	if (fRawReader == NULL)
	{
		fRawReader = new AliRawReaderMemory();
		if (fRawReader == NULL)
		{
			HLTError("Could not allocate new AliRawReaderMemory object.");
			return -ENOMEM;
		}
	}
	if (fRawStream == NULL)
	{
		fRawStream = new AliTPCRawStreamV3(fRawReader);
		if (fRawStream == NULL)
		{
			HLTError("Could not allocate new AliTPCRawStreamV3 object.");
			return -ENOMEM;
		}
		fRawStream->SelectRawData("TPC");
	}
	
	return 0;
}


Int_t AliHLTTPCDataCheckerComponent::DoDeinit()
{
	// Cleans up the data checker component.
	HLTInfo("Stopping TPC data checker component.");
	if (fRawReader != NULL)
	{
		fRawReader->ClearBuffers();
		fRawReader->Reset();
	}
	if (fRawStream != NULL)
	{
		fRawStream->Reset();
	}
	return 0;
}


int AliHLTTPCDataCheckerComponent::DoEvent(
		const AliHLTComponentEventData& evtData,
		const AliHLTComponentBlockData* blocks, 
		AliHLTComponentTriggerData& trigData,
		AliHLTUInt8_t* outputPtr, 
		AliHLTUInt32_t& size,
		AliHLTComponentBlockDataList& outputBlocks
	)
{
	// Check all the input data blocks.
	
	if (fRawReader == NULL)
	{
		HLTError("The raw reader is not set.");
		size = 0;
		return -ENOENT;
	}
	if (fRawStream == NULL)
	{
		HLTError("The TPC raw stream is not set.");
		size = 0;
		return -ENOENT;
	}
	
	if (not IsDataEvent() and not fHandleAllEvents)
	{
		// Forward all data blocks if we are not supposed to handle this event.
		for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; ++n)
		{
			Forward(blocks + n);
		}
		size = 0;
		return 0;
	}
	
	AliHLTEventID_t event = evtData.fEventID;
	
	// Setup the markers indicating the bad blocks.
	std::vector<bool> badBlock(evtData.fBlockCnt, false);
	
	for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; ++n)
	{
		char ddltype[kAliHLTComponentDataTypefIDsize] = kAliHLTDDLRawDataTypeID;
		if (memcmp(&(blocks[n].fDataType.fID), &ddltype, sizeof(ddltype)) == 0)
		{
			badBlock[n] = not CheckRawDataBlock(event, n, blocks + n);
		}
		else if (not fIgnoreType)
		{
			HLTError("Received raw data block %d in event %lld that we do not know how to handle."
				" The data block has data type '%s' and specification 0x%8.8X.",
				n, event, DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fSpecification
			);
		}
	}
	
	// Forward the different blocks.
	for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; ++n)
	{
		if (badBlock[n] and fForwardBadBlocks)
		{
			//int result = Forward(blocks + n);
			int result = Forward(blocks + n);
			if (result != 0)
			{
				size = 0;
				return result;
			}
		}
		if (not badBlock[n] and fForwardGoodBlocks)
		{
			int result = Forward(blocks + n);
			if (result != 0)
			{
				size = 0;
				return result;
			}
		}
	}
	
	size = 0;
	return 0;
}


bool AliHLTTPCDataCheckerComponent::CheckRawDataBlock(
		AliHLTEventID_t event, AliHLTUInt32_t index,
		const AliHLTComponentBlockData* block
	)
{
	// Checks TPC raw DDL data blocks.
	
	assert(fRawReader != NULL);
	assert(fRawStream != NULL);
	
	// Check the origin field of the data block.
	if (not fIgnoreOrigin and
	    memcmp(&(block->fDataType.fOrigin), &kAliHLTDataOriginTPC, sizeof(kAliHLTDataOriginTPC)) != 0
	   )
	{
		char origin[kAliHLTComponentDataTypefOriginSize+1];
		char expectedOrigin[kAliHLTComponentDataTypefOriginSize+1];
		memcpy(&origin, &(block->fDataType.fOrigin), kAliHLTComponentDataTypefOriginSize);
		memcpy(&expectedOrigin, &(kAliHLTDataOriginTPC), kAliHLTComponentDataTypefOriginSize);
		origin[kAliHLTComponentDataTypefOriginSize] = '\0'; // remember the NULL character for the ANSI string.
		expectedOrigin[kAliHLTComponentDataTypefOriginSize] = '\0';
		HLTError("Received raw DDL data block %d in event %lld which has an origin '%s', but expected '%s'.",
			index, event, origin, expectedOrigin
		);
		return false;
	}
	
	// Decode and check the specification bits.
	AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(block->fSpecification);
	AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr(block->fSpecification);
	Int_t ddlid = AliHLTTPCDefinitions::SlicePatchToDDLId(slice, patch);
	if (slice != AliHLTTPCDefinitions::GetMaxSliceNr(block->fSpecification))
	{
		HLTError("Received raw DDL data block %d in event %lld which has a"
			" different minimum and maximum slice number (%d verse %d).",
			index, event, int(slice), int(AliHLTTPCDefinitions::GetMaxSliceNr(block->fSpecification))
		);
		return false;
	}
	if (patch != AliHLTTPCDefinitions::GetMaxPatchNr(block->fSpecification))
	{
		HLTError("Received raw DDL data block %d in event %lld which has a"
			" different minimum and maximum patch number (%d verse %d).",
			index, event, int(patch), int(AliHLTTPCDefinitions::GetMaxPatchNr(block->fSpecification))
		);
		return false;
	}
	if (ddlid == -1)
	{
		HLTError("Received raw DDL data block %d in event %lld which has an"
			" invalid specification 0x%8.8X. Cannot decode the DDL ID number.",
			index, event, block->fSpecification
		);
		return false;
	}
	
	// Now try decode the DDL data. Do it in a try catch block in case
	// the decoder segfaults. We want to know about this and log it.
	bool result = false;
	try
	{
		fRawReader->ClearBuffers();
		fRawReader->Reset();
		fRawStream->Reset();
		fRawReader->AddBuffer(reinterpret_cast<UChar_t*>(block->fPtr), block->fSize, ddlid);
		if (fRawStream->NextDDL())
		{
			while (fRawStream->NextChannel())
			{
				while (fRawStream->NextBunch())
				{
					Int_t bunchLength = fRawStream->GetBunchLength();
					const UShort_t* bunchData = fRawStream->GetSignals();
					for (Int_t i = 0; i < bunchLength; ++i)
					{
						if (bunchData[i] <= 0)
						{
							HLTWarning("Data signal %d in sector %d row %d pad %d is a strange value %d,"
								" for data block %d (DDL ID = %d) in event %lld.",
								i, fRawStream->GetSector(), fRawStream->GetRow(),
								fRawStream->GetPad(), bunchData[i], index, ddlid, event
							);
						}
					}
				}
			}
			result = true;
		}
		else
		{
			HLTError("Cannot decode the raw DDL data (DDL ID = %d) from"
				" data block %d in event %lld.",
				ddlid, index, event
			);
		}
	}
	catch (...)
	{
		HLTError("Caught an exception when processing raw DDL data (DDL ID = %d)"
			" from data block %d in event %lld.",
			ddlid, index, event
		);
	}
	return result;
}
Commit	Line	Data
098c0d28	1	// $Id: $
	2	/**************************************************************************
	3	* This file is property of and copyright by the ALICE HLT Project *
	4	* ALICE Experiment at CERN, All rights reserved. *
	5	* *
	6	* Primary Authors: Artur Szostak <artursz@iafrica.com> *
	7	* for The ALICE HLT Project. *
	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	/// @file AliHLTTPCDataCheckerComponent.cxx
	19	/// @author Artur Szostak <artursz@iafrica.com>
	20	/// @date 9 Aug 2010
	21	/// @brief Implementation of the AliHLTTPCDataCheckerComponent class.
	22	///
	23	/// The AliHLTTPCDataCheckerComponent is used to perform data sanity and integrity
	24	/// checks on the TPC data. This component should be used for testing and debugging.
	25
	26	#include "AliHLTTPCDataCheckerComponent.h"
	27	#include "AliHLTTPCDefinitions.h"
	28	#include "AliTPCRawStreamV3.h"
	29	#include "AliRawReaderMemory.h"
	30	#include <vector>
	31	#include <cstring>
	32	#include <cassert>
	33
	34	ClassImp(AliHLTTPCDataCheckerComponent)
	35
	36
	37	AliHLTTPCDataCheckerComponent::AliHLTTPCDataCheckerComponent() :
	38	fRawStream(NULL),
	39	fRawReader(NULL),
	40	fForwardBadBlocks(false),
	41	fForwardGoodBlocks(false),
	42	fIgnoreType(false),
	43	fIgnoreOrigin(false),
	44	fIgnoreSpec(false),
	45	fHandleAllEvents(false)
	46	{
	47	// Default constructor.
	48	}
	49
	50
	51	AliHLTTPCDataCheckerComponent::~AliHLTTPCDataCheckerComponent()
	52	{
	53	// Default destructor.
	54
	55	if (fRawStream != NULL) delete fRawStream;
	56	if (fRawReader != NULL) delete fRawReader;
	57	}
	58
	59
	60	const char* AliHLTTPCDataCheckerComponent::GetComponentID()
	61	{
	62	// Returns the component ID.
	63	return "TPCDataChecker";
	64	}
65
66
67	void AliHLTTPCDataCheckerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
68	{
69	// Returns the list of input data types that are handled.
70	list.push_back(kAliHLTAnyDataType \| kAliHLTDataOriginTPC);
71	}
72
73
74	AliHLTComponentDataType AliHLTTPCDataCheckerComponent::GetOutputDataType()
75	{
76	// Returns kAliHLTMultipleDataType.
77	return kAliHLTMultipleDataType;
78	}
79
80
81	int AliHLTTPCDataCheckerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& list)
82	{
83	// Returns the list of output data block types generated.
84	list.push_back(kAliHLTAnyDataType);
85	return int(list.size());
86	}
87
88
89	void AliHLTTPCDataCheckerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
90	{
91	// Returns the buffer size requirements.
92	constBase = 0;
93	inputMultiplier = 0;
94	}
95
96
97	AliHLTComponent* AliHLTTPCDataCheckerComponent::Spawn()
98	{
99	// Creates a new instance of the component.
100	return new AliHLTTPCDataCheckerComponent;
101	}
102
103
104	Int_t AliHLTTPCDataCheckerComponent::DoInit(int argc, const char** argv)
105	{
106	// Initialises the data checker component from the command line.
107
108	HLTInfo("Starting TPC data checker component.");
109
110	fForwardBadBlocks = true;
111	fForwardGoodBlocks = true;
112	fIgnoreType = false;
113	fIgnoreOrigin = false;
114	fIgnoreSpec = false;
115	fHandleAllEvents = false;
116
117	for (int i = 0; i < argc; ++i)
118	{
119	if (strcmp(argv[i], "-filter") == 0)
120	{
121	if (i+1 < argc)
122	{
123	if (strcmp(argv[i+1], "forwardbad") == 0)
124	{
125	fForwardBadBlocks = true;
126	fForwardGoodBlocks = false;
127	++i;
128	}
129	else if (strcmp(argv[i+1], "forwardgood") == 0)
130	{
131	fForwardBadBlocks = false;
132	fForwardGoodBlocks = true;
133	++i;
134	}
135	}
136	fForwardBadBlocks = true;
137	fForwardGoodBlocks = false;
138	continue;
139	}
140
141	if (strcmp(argv[i], "-ignoretype") == 0)
142	{
143	fIgnoreType = true;
144	continue;
145	}
146
147	if (strcmp(argv[i], "-ignoreorigin") == 0)
148	{
149	fIgnoreOrigin = true;
150	continue;
151	}
152
153	if (strcmp(argv[i], "-ignorespec") == 0)
154	{
155	fIgnoreSpec = true;
156	continue;
157	}
158
159	if (strcmp(argv[i], "-handle-all-events") == 0)
160	{
161	fHandleAllEvents = true;
162	continue;
163	}
164
165	HLTError("Unknown option '%s'.", argv[i]);
166	return -EINVAL;
167	} // for loop
168
169	if (fRawReader == NULL)
170	{
171	fRawReader = new AliRawReaderMemory();
172	if (fRawReader == NULL)
173	{
174	HLTError("Could not allocate new AliRawReaderMemory object.");
175	return -ENOMEM;
176	}
177	}
178	if (fRawStream == NULL)
179	{
180	fRawStream = new AliTPCRawStreamV3(fRawReader);
181	if (fRawStream == NULL)
182	{
183	HLTError("Could not allocate new AliTPCRawStreamV3 object.");
184	return -ENOMEM;
185	}
186	fRawStream->SelectRawData("TPC");
187	}
188
189	return 0;
190	}
191
192
193	Int_t AliHLTTPCDataCheckerComponent::DoDeinit()
194	{
195	// Cleans up the data checker component.
196	HLTInfo("Stopping TPC data checker component.");
197	if (fRawReader != NULL)
198	{
199	fRawReader->ClearBuffers();
200	fRawReader->Reset();
201	}
202	if (fRawStream != NULL)
203	{
204	fRawStream->Reset();
205	}
206	return 0;
207	}
208
209
210	int AliHLTTPCDataCheckerComponent::DoEvent(
211	const AliHLTComponentEventData& evtData,
212	const AliHLTComponentBlockData* blocks,
213	AliHLTComponentTriggerData& trigData,
214	AliHLTUInt8_t* outputPtr,
215	AliHLTUInt32_t& size,
216	AliHLTComponentBlockDataList& outputBlocks
217	)
218	{
219	// Check all the input data blocks.
220
221	if (fRawReader == NULL)
222	{
223	HLTError("The raw reader is not set.");
224	size = 0;
225	return -ENOENT;
226	}
227	if (fRawStream == NULL)
228	{
229	HLTError("The TPC raw stream is not set.");
230	size = 0;
231	return -ENOENT;
232	}
233
234	if (not IsDataEvent() and not fHandleAllEvents)
235	{
236	// Forward all data blocks if we are not supposed to handle this event.
237	for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; ++n)
238	{
239	Forward(blocks + n);
240	}
241	size = 0;
242	return 0;
243	}
244
245	AliHLTEventID_t event = evtData.fEventID;
246
247	// Setup the markers indicating the bad blocks.
248	std::vector<bool> badBlock(evtData.fBlockCnt, false);
249
250	for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; ++n)
251	{
252	char ddltype[kAliHLTComponentDataTypefIDsize] = kAliHLTDDLRawDataTypeID;
253	if (memcmp(&(blocks[n].fDataType.fID), &ddltype, sizeof(ddltype)) == 0)
254	{
255	badBlock[n] = not CheckRawDataBlock(event, n, blocks + n);
256	}
257	else if (not fIgnoreType)
258	{
259	HLTError("Received raw data block %d in event %lld that we do not know how to handle."
260	" The data block has data type '%s' and specification 0x%8.8X.",
261	n, event, DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fSpecification
262	);
263	}
264	}
265
266	// Forward the different blocks.
267	for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; ++n)
268	{
269	if (badBlock[n] and fForwardBadBlocks)
270	{
271	//int result = Forward(blocks + n);
272	int result = Forward(blocks + n);
273	if (result != 0)
274	{
275	size = 0;
276	return result;
277	}
278	}
279	if (not badBlock[n] and fForwardGoodBlocks)
280	{
281	int result = Forward(blocks + n);
282	if (result != 0)
283	{
284	size = 0;
285	return result;
286	}
287	}
288	}
289
290	size = 0;
291	return 0;
292	}
293
294
295	bool AliHLTTPCDataCheckerComponent::CheckRawDataBlock(
296	AliHLTEventID_t event, AliHLTUInt32_t index,
297	const AliHLTComponentBlockData* block
298	)
299	{
300	// Checks TPC raw DDL data blocks.
301
302	assert(fRawReader != NULL);
303	assert(fRawStream != NULL);
304
305	// Check the origin field of the data block.
306	if (not fIgnoreOrigin and
307	memcmp(&(block->fDataType.fOrigin), &kAliHLTDataOriginTPC, sizeof(kAliHLTDataOriginTPC)) != 0
308	)
309	{
310	char origin[kAliHLTComponentDataTypefOriginSize+1];
311	char expectedOrigin[kAliHLTComponentDataTypefOriginSize+1];
312	memcpy(&origin, &(block->fDataType.fOrigin), kAliHLTComponentDataTypefOriginSize);
313	memcpy(&expectedOrigin, &(kAliHLTDataOriginTPC), kAliHLTComponentDataTypefOriginSize);
314	origin[kAliHLTComponentDataTypefOriginSize] = '\0'; // remember the NULL character for the ANSI string.
315	expectedOrigin[kAliHLTComponentDataTypefOriginSize] = '\0';
316	HLTError("Received raw DDL data block %d in event %lld which has an origin '%s', but expected '%s'.",
317	index, event, origin, expectedOrigin
318	);
319	return false;
320	}
321
322	// Decode and check the specification bits.
323	AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(block->fSpecification);
324	AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr(block->fSpecification);
325	Int_t ddlid = AliHLTTPCDefinitions::SlicePatchToDDLId(slice, patch);
326	if (slice != AliHLTTPCDefinitions::GetMaxSliceNr(block->fSpecification))
327	{
328	HLTError("Received raw DDL data block %d in event %lld which has a"
329	" different minimum and maximum slice number (%d verse %d).",
330	index, event, int(slice), int(AliHLTTPCDefinitions::GetMaxSliceNr(block->fSpecification))
331	);
332	return false;
333	}
334	if (patch != AliHLTTPCDefinitions::GetMaxPatchNr(block->fSpecification))
335	{
336	HLTError("Received raw DDL data block %d in event %lld which has a"
337	" different minimum and maximum patch number (%d verse %d).",
338	index, event, int(patch), int(AliHLTTPCDefinitions::GetMaxPatchNr(block->fSpecification))
339	);
340	return false;
341	}
342	if (ddlid == -1)
343	{
344	HLTError("Received raw DDL data block %d in event %lld which has an"
345	" invalid specification 0x%8.8X. Cannot decode the DDL ID number.",
346	index, event, block->fSpecification
347	);
348	return false;
349	}
350
351	// Now try decode the DDL data. Do it in a try catch block in case
352	// the decoder segfaults. We want to know about this and log it.
353	bool result = false;
354	try
355	{
356	fRawReader->ClearBuffers();
357	fRawReader->Reset();
358	fRawStream->Reset();
359	fRawReader->AddBuffer(reinterpret_cast<UChar_t*>(block->fPtr), block->fSize, ddlid);
360	if (fRawStream->NextDDL())
361	{
362	while (fRawStream->NextChannel())
363	{
364	while (fRawStream->NextBunch())
365	{
098c0d28	366	Int_t bunchLength = fRawStream->GetBunchLength();
098c0d28	367	const UShort_t* bunchData = fRawStream->GetSignals();
098c0d28	368	for (Int_t i = 0; i < bunchLength; ++i)
098c0d28	369	{
6a644371	370	if (bunchData[i] <= 0)
	371	{
	372	HLTWarning("Data signal %d in sector %d row %d pad %d is a strange value %d,"
	373	" for data block %d (DDL ID = %d) in event %lld.",
	374	i, fRawStream->GetSector(), fRawStream->GetRow(),
	375	fRawStream->GetPad(), bunchData[i], index, ddlid, event
	376	);
	377	}
098c0d28	378	}
	379	}
	380	}
	381	result = true;
	382	}
	383	else
	384	{
	385	HLTError("Cannot decode the raw DDL data (DDL ID = %d) from"
	386	" data block %d in event %lld.",
	387	ddlid, index, event
	388	);
	389	}
	390	}
	391	catch (...)
	392	{
	393	HLTError("Caught an exception when processing raw DDL data (DDL ID = %d)"
	394	" from data block %d in event %lld.",
	395	ddlid, index, event
	396	);
	397	}
	398	return result;
	399	}
	400