[u/mrichter/AliRoot.git] / TPC / AliTPCMonitorDateFormat.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

/*
$Log$
Revision 1.2  2007/09/17 16:34:54  cvetan
The package was overwriting the rootcint flags. This was fixed by applying the necessary changes in the DATE-dependent parts of the code

Revision 1.1  2007/09/17 10:23:31  cvetan
New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.

*/ 


////////////////////////////////////////////////////////////////////////
//
// AliTPCMonitorDateFormat class
//
// Class for decoding raw data headers in DATE format
// Reads event and subevent header informations form DATE files
// 
// Authors: Roland Bramm, 
//          Stefan Kniege, IKF, Frankfurt
//       
/////////////////////////////////////////////////////////////////////////

#include "AliTPCMonitorDateFormat.h"
#include "event.h"
#include <iostream>
ClassImp(AliTPCMonitorDateFormat)
//____________________________________________________________________________
AliTPCMonitorDateFormat::AliTPCMonitorDateFormat(Char_t* data): 
  fdataPtr(data),
  fsubEventPtr(data),
  fcurrentPtr(data),
  event((struct eventHeaderStruct*) fdataPtr),
  subEvent(0),
  equipment(0)
{
  // Constructor
}


//____________________________________________________________________________
AliTPCMonitorDateFormat::AliTPCMonitorDateFormat(const AliTPCMonitorDateFormat &dateformat) :
  TNamed(dateformat.GetName(),dateformat.GetTitle()),
  fdataPtr(dateformat.fdataPtr),
  fsubEventPtr(dateformat.fsubEventPtr),
  fcurrentPtr(dateformat.fcurrentPtr),
  event((struct eventHeaderStruct*)dateformat.fdataPtr),
  subEvent(dateformat.subEvent),
  equipment(dateformat.equipment)
{
  // copy constructor
}

//____________________________________________________________________________
AliTPCMonitorDateFormat &AliTPCMonitorDateFormat:: operator= (const AliTPCMonitorDateFormat& dateformat)
{

  // assignment operator 
  if(this!=&dateformat)
    {
      fdataPtr=dateformat.fdataPtr;
      fsubEventPtr=dateformat.fsubEventPtr;
      fcurrentPtr=dateformat.fcurrentPtr;
      event=dateformat.event;
      subEvent=dateformat.subEvent;
      equipment=dateformat.equipment;
    }
  return *this;
}

//____________________________________________________________________________
AliTPCMonitorDateFormat::~AliTPCMonitorDateFormat()
{
  // Destructor
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventSize()
{
  // Return event size
  return (Int_t)event->eventSize;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventHeaderSize()
{
  // Return event header size
  return (Int_t)event->eventHeadSize;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventHeaderBaseSize()
{
  // Return event header base size
	return (Int_t)EVENT_HEAD_BASE_SIZE;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventID()
{
  // Return event ID
  return (Int_t)EVENT_ID_GET_NB_IN_RUN(event->eventId);
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventLDC()
{
  // Return event LDC
  return (Int_t)event->eventLdcId;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventGDC()
{
  // return event GDC
  return (Int_t)event->eventGdcId;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventRunID()
{
  // Return run ID
  return (Int_t)event->eventRunNb;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventVersion()
{
  // Return event version
  return (Int_t)event->eventVersion;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventVersionMajor()
{
  // retrun event version (16-32 bit)
  return (Int_t)(GetEventVersion()>>16);
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEventVersionMinor()
{
  // return event version (0-15 bit)
  return (Int_t)(GetEventVersion()&0x0000ffff);
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsEventSuperEvent()
{
  // Check if event ist super event
  Bool_t retval;
  if(TEST_SYSTEM_ATTRIBUTE( event->eventTypeAttribute, ATTR_SUPER_EVENT ) == 1)
    retval = true;
  else
    retval = false;
  return retval;
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsEventStartOfRun()
{
  // Check if event ist Start of Run
  Bool_t retval;
  if(event->eventType == START_OF_RUN)
    retval = true;
  else
    retval = false;
  return retval;
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsEventEndOfRun()
{
  // Check if event is End of Run
  Bool_t retval;
  if(event->eventType == END_OF_RUN)
    retval = true;
  else
    retval = false;
  return retval;
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsEventPhysicsEvent()
{
  // Check if event is Physics event
  Bool_t retval;
  if(event->eventType == PHYSICS_EVENT)
    retval = true;
  else
    retval = false;
  return retval;
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsEventSwapped()
{
  // Check if event is swapped
  Bool_t retval;
  if(TEST_SYSTEM_ATTRIBUTE( event->eventTypeAttribute, ATTR_EVENT_SWAPPED ) == 1)
    retval = true;
  else
    retval = false;
  return retval;
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsEventWrongEndian()
{
  // Check endian  
  Bool_t retval;
  if(EVENT_MAGIC_NUMBER == event->eventMagic)
    retval = false;
  else
    retval = true;
  return retval;
}


//____________________________________________________________________________
void AliTPCMonitorDateFormat::GotoSubEventHeader()
{
  // Set subevent Pointer to sub event
  if(IsEventSuperEvent() ==true){
    fsubEventPtr = fdataPtr+GetEventHeaderSize();
    subEvent = (struct eventHeaderStruct*) (fsubEventPtr);
  }else{
    fsubEventPtr = fdataPtr;
		subEvent = (struct eventHeaderStruct*) (fsubEventPtr);
  }
}

//____________________________________________________________________________
void AliTPCMonitorDateFormat::GotoNextSubEventHeader()
{
  // set subevent pointer to next  sub event 
  fsubEventPtr += GetSubEventSize();
  subEvent = (struct eventHeaderStruct*) (fsubEventPtr);
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsLastSubEventHeader()
{
  // Check if sub event is last sub event
  Bool_t retval;
  Int_t position;
  if(IsEventSuperEvent() ==true){
    position = fsubEventPtr - fdataPtr;
    if( (position+GetSubEventSize()) < GetEventSize() )
			retval = false;
    else
      retval = true;
  }else{
    position = fsubEventPtr - fdataPtr;
    if( (position+GetSubEventSize()) < GetEventSize() )
			retval = false;
    else
      retval = true;
  }
  return retval;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetSubEventSize()
{
  // Return sub event size
  return (Int_t)subEvent->eventSize;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetSubEventHeaderSize()
{
  // Return sub event header size
  return (Int_t)subEvent->eventHeadSize;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetSubEventLDC()
{
  // Return sub event LDC
  return (Int_t)subEvent->eventLdcId;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetSubEventGDC()
{
  // return sub event GDC
	return (Int_t)subEvent->eventGdcId;
}


//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsSubEventSuperEvent()
{
  // Check if sub event is super event
	Bool_t retval;
	if(TEST_SYSTEM_ATTRIBUTE( subEvent->eventTypeAttribute, ATTR_SUPER_EVENT ) == 1)
		retval = true;
	else
		retval = false;
	return retval;
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsSubEventStartOfRun()
{
  // Check if sub event is start of run
  Bool_t retval;
  if(subEvent->eventType == START_OF_RUN)
    retval = true;
  else
    retval = false;
  return retval;
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsSubEventEndOfRun()
{
  // Check if sub event is end of run
  Bool_t retval;
  if(subEvent->eventType == END_OF_RUN)
    retval = true;
  else
    retval = false;
  return retval;
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsSubEventPhysicsEvent()
{
  // Check if sub event is physics event
  Bool_t retval;
  if(subEvent->eventType == PHYSICS_EVENT)
    retval = true;
  else
    retval = false;
  return retval;
}

//____________________________________________________________________________
void AliTPCMonitorDateFormat::GotoFirstEquipment()
{
  // Set current pointer to first equipment
  fcurrentPtr = fsubEventPtr + GetSubEventHeaderSize();
  equipment = (struct equipmentHeaderStruct*) (fcurrentPtr);
}

//____________________________________________________________________________
void AliTPCMonitorDateFormat::GotoNextEquipment()
{
  // Set current pointer to next equipment
  fcurrentPtr += GetEquipmentSize();
  equipment = (struct equipmentHeaderStruct*) (fcurrentPtr);
}

//____________________________________________________________________________
Bool_t AliTPCMonitorDateFormat::IsLastEquipment()
{
  // Check if equipment is last equipment
  Bool_t retval;
  Int_t position;
  position = fcurrentPtr - fsubEventPtr;
  if( (position+GetEquipmentSize()) < GetSubEventSize() )
		  retval = false;
  else
    retval = true;
  return retval; 
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEquipmentSize()
{
  // Return equipment size
  return (Int_t)equipment->equipmentSize;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetPayloadSize()
{
  // Return payload slze
  Int_t retval = 0;
  if(GetEventVersion() < 196610){
    retval = (Int_t)equipment->equipmentSize;
  }else{
    retval = (Int_t)equipment->equipmentSize - GetEquipmentHeaderSize();
  }
  return retval;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEquipmentType()
{
  // Return equipment type
  return (Int_t)equipment->equipmentType;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEquipmentID()
{
  // Return equipment ID
  return (Int_t)equipment->equipmentId;
}

//____________________________________________________________________________
Int_t* AliTPCMonitorDateFormat::GetEquipmentTypeAttribute()
{
  // Return equipment type attribute
  return (Int_t*)equipment->equipmentTypeAttribute;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEquipmentBasicSize()
{
  // Return equipment basic size
  return (Int_t)equipment->equipmentBasicElementSize;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetEquipmentHeaderSize()
{
  // Return equipment header size
  return sizeof(struct equipmentHeaderStruct);
}


//____________________________________________________________________________
Char_t *AliTPCMonitorDateFormat::GetFirstDataPointer()
{
  // Return data pointer (after equipment header)
  Char_t *datapointer;
  if(GetEventVersion() < 196610){
    fcurrentPtr += GetEquipmentHeaderSize();
    datapointer = fcurrentPtr;
  }else{
    datapointer = fcurrentPtr + GetEquipmentHeaderSize();
  }
  return datapointer;
 
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetPosition()
{
  // Return current position relative to start of event
  Int_t retval = (Int_t) (fcurrentPtr - fdataPtr);
  return retval;
}

//____________________________________________________________________________
Int_t AliTPCMonitorDateFormat::GetPositionSubEvent()
{
  // Return subevent position  relative to start of event
  Int_t retval = (Int_t) (fsubEventPtr - fdataPtr);
  return retval;
}
Commit	Line	Data
48265b32	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/*
	17	$Log$
ca7b8371	18	Revision 1.2 2007/09/17 16:34:54 cvetan
	19	The package was overwriting the rootcint flags. This was fixed by applying the necessary changes in the DATE-dependent parts of the code
	20
33dc3c99	21	Revision 1.1 2007/09/17 10:23:31 cvetan
	22	New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.
	23
48265b32	24	*/
48265b32	25
ca7b8371	26
	27	////////////////////////////////////////////////////////////////////////
	28	//
	29	// AliTPCMonitorDateFormat class
	30	//
	31	// Class for decoding raw data headers in DATE format
	32	// Reads event and subevent header informations form DATE files
	33	//
	34	// Authors: Roland Bramm,
	35	// Stefan Kniege, IKF, Frankfurt
	36	//
	37	/////////////////////////////////////////////////////////////////////////
	38
48265b32	39	#include "AliTPCMonitorDateFormat.h"
33dc3c99	40	#include "event.h"
48265b32	41	#include <iostream>
	42	ClassImp(AliTPCMonitorDateFormat)
	43	//____________________________________________________________________________
ca7b8371	44	AliTPCMonitorDateFormat::AliTPCMonitorDateFormat(Char_t* data):
	45	fdataPtr(data),
	46	fsubEventPtr(data),
	47	fcurrentPtr(data),
	48	event((struct eventHeaderStruct*) fdataPtr),
	49	subEvent(0),
	50	equipment(0)
	51	{
48265b32	52	// Constructor
ca7b8371	53	}
	54
	55
	56	//____________________________________________________________________________
	57	AliTPCMonitorDateFormat::AliTPCMonitorDateFormat(const AliTPCMonitorDateFormat &dateformat) :
	58	TNamed(dateformat.GetName(),dateformat.GetTitle()),
	59	fdataPtr(dateformat.fdataPtr),
	60	fsubEventPtr(dateformat.fsubEventPtr),
	61	fcurrentPtr(dateformat.fcurrentPtr),
	62	event((struct eventHeaderStruct*)dateformat.fdataPtr),
	63	subEvent(dateformat.subEvent),
	64	equipment(dateformat.equipment)
	65	{
	66	// copy constructor
	67	}
	68
	69	//____________________________________________________________________________
	70	AliTPCMonitorDateFormat &AliTPCMonitorDateFormat:: operator= (const AliTPCMonitorDateFormat& dateformat)
	71	{
	72
	73	// assignment operator
	74	if(this!=&dateformat)
	75	{
	76	fdataPtr=dateformat.fdataPtr;
	77	fsubEventPtr=dateformat.fsubEventPtr;
	78	fcurrentPtr=dateformat.fcurrentPtr;
	79	event=dateformat.event;
	80	subEvent=dateformat.subEvent;
	81	equipment=dateformat.equipment;
	82	}
	83	return *this;
48265b32	84	}
	85
	86	//____________________________________________________________________________
	87	AliTPCMonitorDateFormat::~AliTPCMonitorDateFormat()
	88	{
	89	// Destructor
	90	}
	91
	92	//____________________________________________________________________________
	93	Int_t AliTPCMonitorDateFormat::GetEventSize()
	94	{
	95	// Return event size
	96	return (Int_t)event->eventSize;
	97	}
	98
	99	//____________________________________________________________________________
	100	Int_t AliTPCMonitorDateFormat::GetEventHeaderSize()
	101	{
	102	// Return event header size
	103	return (Int_t)event->eventHeadSize;
	104	}
	105
	106	//____________________________________________________________________________
	107	Int_t AliTPCMonitorDateFormat::GetEventHeaderBaseSize()
	108	{
	109	// Return event header base size
	110	return (Int_t)EVENT_HEAD_BASE_SIZE;
	111	}
	112
	113	//____________________________________________________________________________
	114	Int_t AliTPCMonitorDateFormat::GetEventID()
	115	{
	116	// Return event ID
	117	return (Int_t)EVENT_ID_GET_NB_IN_RUN(event->eventId);
	118	}
	119
	120	//____________________________________________________________________________
	121	Int_t AliTPCMonitorDateFormat::GetEventLDC()
	122	{
	123	// Return event LDC
	124	return (Int_t)event->eventLdcId;
	125	}
	126
	127	//____________________________________________________________________________
	128	Int_t AliTPCMonitorDateFormat::GetEventGDC()
	129	{
	130	// return event GDC
	131	return (Int_t)event->eventGdcId;
	132	}
	133
	134	//____________________________________________________________________________
	135	Int_t AliTPCMonitorDateFormat::GetEventRunID()
	136	{
	137	// Return run ID
	138	return (Int_t)event->eventRunNb;
	139	}
	140
	141	//____________________________________________________________________________
	142	Int_t AliTPCMonitorDateFormat::GetEventVersion()
	143	{
	144	// Return event version
	145	return (Int_t)event->eventVersion;
	146	}
	147
148	//____________________________________________________________________________
149	Int_t AliTPCMonitorDateFormat::GetEventVersionMajor()
150	{
151	// retrun event version (16-32 bit)
152	return (Int_t)(GetEventVersion()>>16);
153	}
154
155	//____________________________________________________________________________
156	Int_t AliTPCMonitorDateFormat::GetEventVersionMinor()
157	{
158	// return event version (0-15 bit)
159	return (Int_t)(GetEventVersion()&0x0000ffff);
160	}
161
162	//____________________________________________________________________________
163	Bool_t AliTPCMonitorDateFormat::IsEventSuperEvent()
164	{
165	// Check if event ist super event
166	Bool_t retval;
167	if(TEST_SYSTEM_ATTRIBUTE( event->eventTypeAttribute, ATTR_SUPER_EVENT ) == 1)
168	retval = true;
169	else
170	retval = false;
171	return retval;
172	}
173
174	//____________________________________________________________________________
175	Bool_t AliTPCMonitorDateFormat::IsEventStartOfRun()
176	{
177	// Check if event ist Start of Run
178	Bool_t retval;
179	if(event->eventType == START_OF_RUN)
180	retval = true;
181	else
182	retval = false;
183	return retval;
184	}
185
186	//____________________________________________________________________________
187	Bool_t AliTPCMonitorDateFormat::IsEventEndOfRun()
188	{
189	// Check if event is End of Run
190	Bool_t retval;
191	if(event->eventType == END_OF_RUN)
192	retval = true;
193	else
194	retval = false;
195	return retval;
196	}
197
198	//____________________________________________________________________________
199	Bool_t AliTPCMonitorDateFormat::IsEventPhysicsEvent()
200	{
201	// Check if event is Physics event
202	Bool_t retval;
203	if(event->eventType == PHYSICS_EVENT)
204	retval = true;
205	else
206	retval = false;
207	return retval;
208	}
209
210	//____________________________________________________________________________
211	Bool_t AliTPCMonitorDateFormat::IsEventSwapped()
212	{
213	// Check if event is swapped
214	Bool_t retval;
215	if(TEST_SYSTEM_ATTRIBUTE( event->eventTypeAttribute, ATTR_EVENT_SWAPPED ) == 1)
216	retval = true;
217	else
218	retval = false;
219	return retval;
220	}
221
222	//____________________________________________________________________________
223	Bool_t AliTPCMonitorDateFormat::IsEventWrongEndian()
224	{
225	// Check endian
226	Bool_t retval;
227	if(EVENT_MAGIC_NUMBER == event->eventMagic)
228	retval = false;
229	else
230	retval = true;
231	return retval;
232	}
233
234
235	//____________________________________________________________________________
236	void AliTPCMonitorDateFormat::GotoSubEventHeader()
237	{
238	// Set subevent Pointer to sub event
239	if(IsEventSuperEvent() ==true){
240	fsubEventPtr = fdataPtr+GetEventHeaderSize();
241	subEvent = (struct eventHeaderStruct*) (fsubEventPtr);
242	}else{
243	fsubEventPtr = fdataPtr;
244	subEvent = (struct eventHeaderStruct*) (fsubEventPtr);
245	}
246	}
247
248	//____________________________________________________________________________
249	void AliTPCMonitorDateFormat::GotoNextSubEventHeader()
250	{
251	// set subevent pointer to next sub event
252	fsubEventPtr += GetSubEventSize();
253	subEvent = (struct eventHeaderStruct*) (fsubEventPtr);
254	}
255
256	//____________________________________________________________________________
257	Bool_t AliTPCMonitorDateFormat::IsLastSubEventHeader()
258	{
259	// Check if sub event is last sub event
260	Bool_t retval;
261	Int_t position;
262	if(IsEventSuperEvent() ==true){
263	position = fsubEventPtr - fdataPtr;
264	if( (position+GetSubEventSize()) < GetEventSize() )
265	retval = false;
266	else
267	retval = true;
268	}else{
269	position = fsubEventPtr - fdataPtr;
270	if( (position+GetSubEventSize()) < GetEventSize() )
271	retval = false;
272	else
273	retval = true;
274	}
275	return retval;
276	}
277
278	//____________________________________________________________________________
279	Int_t AliTPCMonitorDateFormat::GetSubEventSize()
280	{
281	// Return sub event size
282	return (Int_t)subEvent->eventSize;
283	}
284
285	//____________________________________________________________________________
286	Int_t AliTPCMonitorDateFormat::GetSubEventHeaderSize()
287	{
288	// Return sub event header size
289	return (Int_t)subEvent->eventHeadSize;
290	}
291
292	//____________________________________________________________________________
293	Int_t AliTPCMonitorDateFormat::GetSubEventLDC()
294	{
295	// Return sub event LDC
296	return (Int_t)subEvent->eventLdcId;
297	}
298
299	//____________________________________________________________________________
300	Int_t AliTPCMonitorDateFormat::GetSubEventGDC()
301	{
302	// return sub event GDC
303	return (Int_t)subEvent->eventGdcId;
304	}
305
306
307	//____________________________________________________________________________
308	Bool_t AliTPCMonitorDateFormat::IsSubEventSuperEvent()
309	{
310	// Check if sub event is super event
311	Bool_t retval;
312	if(TEST_SYSTEM_ATTRIBUTE( subEvent->eventTypeAttribute, ATTR_SUPER_EVENT ) == 1)
313	retval = true;
314	else
315	retval = false;
316	return retval;
317	}
318
319	//____________________________________________________________________________
320	Bool_t AliTPCMonitorDateFormat::IsSubEventStartOfRun()
321	{
322	// Check if sub event is start of run
323	Bool_t retval;
324	if(subEvent->eventType == START_OF_RUN)
325	retval = true;
326	else
327	retval = false;
328	return retval;
329	}
330
331	//____________________________________________________________________________
332	Bool_t AliTPCMonitorDateFormat::IsSubEventEndOfRun()
333	{
334	// Check if sub event is end of run
335	Bool_t retval;
336	if(subEvent->eventType == END_OF_RUN)
337	retval = true;
338	else
339	retval = false;
340	return retval;
341	}
342
343	//____________________________________________________________________________
344	Bool_t AliTPCMonitorDateFormat::IsSubEventPhysicsEvent()
345	{
346	// Check if sub event is physics event
347	Bool_t retval;
348	if(subEvent->eventType == PHYSICS_EVENT)
349	retval = true;
350	else
351	retval = false;
352	return retval;
353	}
354
355	//____________________________________________________________________________
356	void AliTPCMonitorDateFormat::GotoFirstEquipment()
357	{
358	// Set current pointer to first equipment
359	fcurrentPtr = fsubEventPtr + GetSubEventHeaderSize();
360	equipment = (struct equipmentHeaderStruct*) (fcurrentPtr);
361	}
362
363	//____________________________________________________________________________
364	void AliTPCMonitorDateFormat::GotoNextEquipment()
365	{
366	// Set current pointer to next equipment
367	fcurrentPtr += GetEquipmentSize();
368	equipment = (struct equipmentHeaderStruct*) (fcurrentPtr);
369	}
370
371	//____________________________________________________________________________
372	Bool_t AliTPCMonitorDateFormat::IsLastEquipment()
373	{
374	// Check if equipment is last equipment
375	Bool_t retval;
376	Int_t position;
377	position = fcurrentPtr - fsubEventPtr;
378	if( (position+GetEquipmentSize()) < GetSubEventSize() )
379	retval = false;
380	else
381	retval = true;
382	return retval;
383	}
384
385	//____________________________________________________________________________
386	Int_t AliTPCMonitorDateFormat::GetEquipmentSize()
387	{
388	// Return equipment size
389	return (Int_t)equipment->equipmentSize;
390	}
391
392	//____________________________________________________________________________
393	Int_t AliTPCMonitorDateFormat::GetPayloadSize()
394	{
395	// Return payload slze
396	Int_t retval = 0;
397	if(GetEventVersion() < 196610){
398	retval = (Int_t)equipment->equipmentSize;
399	}else{
400	retval = (Int_t)equipment->equipmentSize - GetEquipmentHeaderSize();
401	}
402	return retval;
403	}
404
405	//____________________________________________________________________________
406	Int_t AliTPCMonitorDateFormat::GetEquipmentType()
407	{
408	// Return equipment type
409	return (Int_t)equipment->equipmentType;
410	}
411
412	//____________________________________________________________________________
413	Int_t AliTPCMonitorDateFormat::GetEquipmentID()
414	{
415	// Return equipment ID
416	return (Int_t)equipment->equipmentId;
417	}
418
419	//____________________________________________________________________________
420	Int_t* AliTPCMonitorDateFormat::GetEquipmentTypeAttribute()
421	{
422	// Return equipment type attribute
423	return (Int_t*)equipment->equipmentTypeAttribute;
424	}
425
426	//____________________________________________________________________________
427	Int_t AliTPCMonitorDateFormat::GetEquipmentBasicSize()
428	{
429	// Return equipment basic size
430	return (Int_t)equipment->equipmentBasicElementSize;
431	}
432
433	//____________________________________________________________________________
434	Int_t AliTPCMonitorDateFormat::GetEquipmentHeaderSize()
435	{
436	// Return equipment header size
437	return sizeof(struct equipmentHeaderStruct);
438	}
439
440
441	//____________________________________________________________________________
442	Char_t *AliTPCMonitorDateFormat::GetFirstDataPointer()
443	{
444	// Return data pointer (after equipment header)
445	Char_t *datapointer;
446	if(GetEventVersion() < 196610){
447	fcurrentPtr += GetEquipmentHeaderSize();
448	datapointer = fcurrentPtr;
449	}else{
450	datapointer = fcurrentPtr + GetEquipmentHeaderSize();
451	}
452	return datapointer;
453
454	}
455
456	//____________________________________________________________________________
457	Int_t AliTPCMonitorDateFormat::GetPosition()
458	{
459	// Return current position relative to start of event
460	Int_t retval = (Int_t) (fcurrentPtr - fdataPtr);
461	return retval;
462	}
463
464	//____________________________________________________________________________
465	Int_t AliTPCMonitorDateFormat::GetPositionSubEvent()
466	{
467	// Return subevent position relative to start of event
468	Int_t retval = (Int_t) (fsubEventPtr - fdataPtr);
469	return retval;
470	}
471