ROOT logo
/**************************************************************************
 * 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.                  *
 **************************************************************************/

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
///
/// This is a class for reading raw data from a root file.
///
/// The root file is expected to contain a tree of name "RAW" with
/// a branch of name "rawevent" which contains objects of type
/// AliRawVEvent.
/// 
/// The file name and the event number are arguments of the constructor
/// of AliRawReaderRoot.
///
///////////////////////////////////////////////////////////////////////////////

#include <TFile.h>
#include <TTree.h>
#include <TTreeIndex.h>
#include <TGrid.h>
#include "AliRawReaderRoot.h"
#include "AliRawVEvent.h"
#include "AliRawEventHeaderBase.h"
#include "AliRawVEquipment.h"
#include "AliRawEquipmentHeader.h"
#include "AliRawData.h"


ClassImp(AliRawReaderRoot)
Bool_t AliRawReaderRoot::fgUseOrder = kFALSE;


AliRawReaderRoot::AliRawReaderRoot() :
  fFile(NULL),
  fBranch(NULL),
  fEventIndex(-1),
  fEvent(NULL),
  fEventHeader(NULL),
  fSubEventIndex(0),
  fSubEvent(NULL),
  fEquipmentIndex(0),
  fEquipment(NULL),
  fRawData(NULL),
  fPosition(NULL),
  fEnd(NULL),
  fIndex(0x0)
{
// default constructor

}

AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber) :
  fFile(NULL),
  fBranch(NULL),
  fEventIndex(eventNumber),
  fEvent(NULL),
  fEventHeader(NULL),
  fSubEventIndex(0),
  fSubEvent(NULL),
  fEquipmentIndex(0),
  fEquipment(NULL),
  fRawData(NULL),
  fPosition(NULL),
  fEnd(NULL),
  fIndex(0x0)
{
// create an object to read digits from the given input file for the
// event with the given number

  TDirectory* dir = gDirectory;
  TString flStr = fileName;
  if (flStr.BeginsWith("alien://") && !gGrid) TGrid::Connect("alien://");
  fFile = TFile::Open(fileName);
  dir->cd();
  if (!fFile || !fFile->IsOpen()) {
    Error("AliRawReaderRoot", "could not open file %s", fileName);
    fIsValid = kFALSE;
    return;
  }
  TTree* tree = (TTree*) fFile->Get("RAW");
  if (!tree) {
    Error("AliRawReaderRoot", "no raw data tree found");
    fIsValid = kFALSE;
    return;
  }
  fBranch = tree->GetBranch("rawevent");
  if (!fBranch) {
    Error("AliRawReaderRoot", "no raw data branch found");
    fIsValid = kFALSE;
    return;
  }

  fBranch->SetAddress(&fEvent);
  if (fEventIndex >= 0) {
    if (fBranch->GetEntry(fEventIndex) <= 0) {
      Error("AliRawReaderRoot", "no event with number %d found", fEventIndex);
      fIsValid = kFALSE;
      return;
    }
    fEventHeader = fEvent->GetHeader();
  }
}

AliRawReaderRoot::AliRawReaderRoot(AliRawVEvent* event) :
  fFile(NULL),
  fBranch(NULL),
  fEventIndex(-1),
  fEvent(event),
  fEventHeader(event->GetHeader()),
  fSubEventIndex(0),
  fSubEvent(NULL),
  fEquipmentIndex(0),
  fEquipment(NULL),
  fRawData(NULL),
  fPosition(NULL),
  fEnd(NULL),
  fIndex(0x0)
{
// create an object to read digits from the given raw event
  if (!fEvent) fIsValid = kFALSE;
}

AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) :
  AliRawReader(rawReader),
  fFile(NULL),
  fBranch(NULL),
  fEventIndex(rawReader.fEventIndex),
  fEvent(NULL),
  fEventHeader(NULL),
  fSubEventIndex(rawReader.fSubEventIndex),
  fSubEvent(NULL),
  fEquipmentIndex(rawReader.fEquipmentIndex),
  fEquipment(NULL),
  fRawData(NULL),
  fPosition(NULL),
  fEnd(NULL),
  fIndex(0x0)
{
// copy constructor

  if (rawReader.fFile) {
    TDirectory* dir = gDirectory;    
    fFile = TFile::Open(rawReader.fFile->GetName());
    dir->cd();
    if (!fFile || !fFile->IsOpen()) {
      Error("AliRawReaderRoot", "could not open file %s", 
	    rawReader.fFile->GetName());
      fIsValid = kFALSE;
      return;
    }
    TTree* tree = (TTree*) fFile->Get("RAW");
    if (!tree) {
      Error("AliRawReaderRoot", "no raw data tree found");
      fIsValid = kFALSE;
      return;
    }
    fBranch = tree->GetBranch("rawevent");
    if (!fBranch) {
      Error("AliRawReaderRoot", "no raw data branch found");
      fIsValid = kFALSE;
      return;
    }

    fBranch->SetAddress(&fEvent);
    if (fEventIndex >= 0) {
      if (fBranch->GetEntry(fEventIndex) <= 0) {
	Error("AliRawReaderRoot", "no event with number %d found", 
	      fEventIndex);
	fIsValid = kFALSE;
	return;
      }
      fEventHeader = fEvent->GetHeader();
    }
  } else {
    fEvent = rawReader.fEvent;
    fEventHeader = rawReader.fEventHeader;
  }

  if (fSubEventIndex > 0) {
    fSubEvent = fEvent->GetSubEvent(fSubEventIndex-1);
    fEquipment = fSubEvent->GetEquipment(fEquipmentIndex);
    fRawData = fEquipment->GetRawData();
    fCount = 0;
    fHeader = (AliRawDataHeader*) ((UChar_t*) fRawData->GetBuffer() + 
      ((UChar_t*) rawReader.fHeader - 
       (UChar_t*) rawReader.fRawData->GetBuffer()));
    // Now check the version of the header
    UChar_t version = 2;
    if (fHeader) version = fHeader->GetVersion();
    if (version==3) {
      fHeader = NULL;
      fHeaderV3 = (AliRawDataHeaderV3*) ((UChar_t*) fRawData->GetBuffer() + 
      ((UChar_t*) rawReader.fHeaderV3 - 
       (UChar_t*) rawReader.fRawData->GetBuffer()));
    }
    fPosition = (UChar_t*) fRawData->GetBuffer() + 
      (rawReader.fPosition - (UChar_t*) rawReader.fRawData->GetBuffer());
    fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize();
  }
}

AliRawReaderRoot& AliRawReaderRoot::operator = (const AliRawReaderRoot& 
						rawReader)
{
// assignment operator

  this->~AliRawReaderRoot();
  new(this) AliRawReaderRoot(rawReader);
  return *this;
}

AliRawReaderRoot::~AliRawReaderRoot()
{
// delete objects and close root file

  if (fFile) {
    if (fEvent) delete fEvent;
    fFile->Close();
    delete fFile;
  }
}

const AliRawEventHeaderBase* AliRawReaderRoot::GetEventHeader() const
{
  // Get the even header
  // Return NULL in case of failure
  return fEventHeader;
}

UInt_t AliRawReaderRoot::GetType() const
{
// get the type from the event header

  if (!fEventHeader) return 0;
  return fEventHeader->Get("Type");
}

UInt_t AliRawReaderRoot::GetRunNumber() const
{
// get the run number from the event header

  if (!fEventHeader) return 0;
  return fEventHeader->Get("RunNb");
}

const UInt_t* AliRawReaderRoot::GetEventId() const
{
// get the event id from the event header

  if (!fEventHeader) return NULL;
  return fEventHeader->GetP("Id");
}

const UInt_t* AliRawReaderRoot::GetTriggerPattern() const
{
// get the trigger pattern from the event header

  if (!fEventHeader) return NULL;
  return fEventHeader->GetP("TriggerPattern");
}

const UInt_t* AliRawReaderRoot::GetDetectorPattern() const
{
// get the detector pattern from the event header

  if (!fEventHeader) return NULL;
  return fEventHeader->GetP("DetectorPattern");
}

const UInt_t* AliRawReaderRoot::GetAttributes() const
{
// get the type attributes from the event header

  if (!fEventHeader) return NULL;
  return fEventHeader->GetP("TypeAttribute");
}

const UInt_t* AliRawReaderRoot::GetSubEventAttributes() const
{
// get the type attributes from the sub event header

  if (!fSubEvent) return NULL;
  return fSubEvent->GetHeader()->GetP("TypeAttribute");
}

UInt_t AliRawReaderRoot::GetLDCId() const
{
// get the LDC Id from the event header

  if (!fEvent || !fSubEvent) return 0;
  return fSubEvent->GetHeader()->Get("LdcId");
}

UInt_t AliRawReaderRoot::GetGDCId() const
{
// get the GDC Id from the event header

  if (!fEventHeader) return 0;
  return fEventHeader->Get("GdcId");
}

UInt_t AliRawReaderRoot::GetTimestamp() const
{
  if (!fEventHeader) return 0;
  return fEventHeader->Get("Timestamp");
}

Int_t AliRawReaderRoot::GetEquipmentSize() const
{
// get the size of the equipment

  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
  return fEquipment->GetEquipmentHeader()->GetEquipmentSize();
}

Int_t AliRawReaderRoot::GetEquipmentType() const
{
// get the type from the equipment header

  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return -1;
  return fEquipment->GetEquipmentHeader()->GetEquipmentType();
}

Int_t AliRawReaderRoot::GetEquipmentId() const
{
// get the ID from the equipment header

  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return -1;
  return fEquipment->GetEquipmentHeader()->GetId();
}

const UInt_t* AliRawReaderRoot::GetEquipmentAttributes() const
{
// get the attributes from the equipment header

  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return NULL;
  return fEquipment->GetEquipmentHeader()->GetTypeAttribute();
}

Int_t AliRawReaderRoot::GetEquipmentElementSize() const
{
// get the basic element size from the equipment header

  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
  return fEquipment->GetEquipmentHeader()->GetBasicSizeType();
}

Int_t AliRawReaderRoot::GetEquipmentHeaderSize() const
{
// get the size of the equipment header (28 bytes by default)

  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
  return fEquipment->GetEquipmentHeader()->HeaderSize();
}

// _________________________________________________________________________
void AliRawReaderRoot::SwapData(const void* inbuf, const void* outbuf, UInt_t size) {
  // The method swaps the contents of the
  // raw-data event header
  UInt_t  intCount = (size+3)/sizeof(UInt_t);

  UInt_t* buf = (UInt_t*) inbuf;    // temporary integers buffer
  for (UInt_t i=0; i<intCount; i++, buf++) {
      UInt_t value = SwapWord(*buf);
      if (i==(intCount-1))
         memcpy((UInt_t*)outbuf+i, &value, size%sizeof(UInt_t));
      else
         memcpy((UInt_t*)outbuf+i, &value, sizeof(UInt_t));
  }
}
// _________________________________________________________________________

Bool_t AliRawReaderRoot::ReadHeader()
{
// read a data header at the current position
// returns kFALSE if the data header could not be read

  fErrorCode = 0;
  if (!fEvent) return kFALSE;

  do {
    // skip payload (if event was not selected)
    if (fCount > 0) fPosition += fCount;

    // get the first or the next equipment if at the end of an equipment
    if (!fEquipment || (fPosition >= fEnd)) {

      // get the first or the next sub event if at the end of a sub event
      if (!fSubEvent || (fEquipmentIndex >= fSubEvent->GetNEquipments())) {

	// check for end of event data
	if (fSubEventIndex >= fEvent->GetNSubEvents()) return kFALSE;
	fSubEvent = fEvent->GetSubEvent(fSubEventIndex++);

	// check the magic word of the sub event
	if (!fSubEvent->GetHeader()->IsValid()) {
	  Error("ReadHeader", "wrong magic number in sub event!");
	  fSubEvent->GetHeader()->Dump();
	  fErrorCode = kErrMagic;
	  return kFALSE;
	}

	fEquipmentIndex = 0;
	fEquipment = NULL;
	fRawData = NULL;
      }

      // get the next equipment and raw data
      fCount = 0;
      if (fEquipmentIndex >= fSubEvent->GetNEquipments()) {
	fEquipment = NULL;
	continue;
      }
      fEquipment = fSubEvent->GetEquipment(fEquipmentIndex++);
      if (!fEquipment) continue;
      if (!IsSelected()) {
	fPosition = fEnd;
	continue;
      }
      fRawData = fEquipment->GetRawData();
      if (!fRawData) {
	fPosition = fEnd;
	continue;
      }
      fPosition = (UChar_t*) fRawData->GetBuffer();
      fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize();
    }

    // continue with the next equipment if no data left in the payload
    if (fPosition >= fEnd) continue;

    if (fRequireHeader) {
      // check that there are enough bytes left for the data header
      if (fPosition + sizeof(AliRawDataHeader) > fEnd) {
	Error("ReadHeader", "could not read data header!");
	Warning("ReadHeader", "skipping %ld bytes", fEnd - fPosition);
	fEquipment->GetEquipmentHeader()->Dump();
	fCount = 0;
	fPosition = fEnd;
	fErrorCode = kErrNoDataHeader;
	continue;
      }

      // "read" the data header
      fHeader = (AliRawDataHeader*) fPosition;
      // Now check the version of the header
      UChar_t version = 2;
      if (fHeader) version=fHeader->GetVersion();
      if (version==2) {
 #ifndef R__BYTESWAP
	SwapData((void*) fHeader, (void*) fHeaderSwapped, sizeof(AliRawDataHeader));
	fHeader=fHeaderSwapped;
#endif
	if ((fPosition + fHeader->fSize) != fEnd) {
	  if (fHeader->fSize != 0xFFFFFFFF)
	    Warning("ReadHeader",
		    "Equipment %d : raw data size found in the header is wrong (%d != %ld)! Using the equipment size instead !",
		    fEquipment->GetEquipmentHeader()->GetId(),fHeader->fSize, fEnd - fPosition);
	  fHeader->fSize = fEnd - fPosition;
	}
	fPosition += sizeof(AliRawDataHeader);
	fHeaderV3 = 0;
      } else if (version==3) {
	fHeaderV3 = (AliRawDataHeaderV3*) fPosition;
#ifndef R__BYTESWAP
	SwapData((void*) fHeaderV3, (void*) fHeaderSwapped, sizeof(AliRawDataHeaderV3));
	fHeaderV3=fHeaderSwappedV3;
#endif
	if ((fPosition + fHeaderV3->fSize) != fEnd) {
	  if (fHeaderV3->fSize != 0xFFFFFFFF)
	    Warning("ReadHeader",
		    "Equipment %d : raw data size found in the header is wrong (%d != %ld)! Using the equipment size instead !",
		    fEquipment->GetEquipmentHeader()->GetId(),fHeader->fSize, fEnd - fPosition);
	  fHeaderV3->fSize = fEnd - fPosition;
	}
	fPosition += sizeof(AliRawDataHeaderV3);
	fHeader = 0;
      }
    }

    if (fHeader && (fHeader->fSize != 0xFFFFFFFF)) {
      fCount = fHeader->fSize - sizeof(AliRawDataHeader);

      // check consistency of data size in the header and in the sub event
      if (fPosition + fCount > fEnd) {  
	Error("ReadHeader", "size in data header exceeds event size!");
	Warning("ReadHeader", "skipping %ld bytes", fEnd - fPosition);
	fEquipment->GetEquipmentHeader()->Dump();
	fCount = 0;
	fPosition = fEnd;
	fErrorCode = kErrSize;
	continue;
      }
    } else if (fHeaderV3 && (fHeaderV3->fSize != 0xFFFFFFFF)) {
      fCount = fHeaderV3->fSize - sizeof(AliRawDataHeaderV3);

      // check consistency of data size in the header and in the sub event
      if (fPosition + fCount > fEnd) {  
	Error("ReadHeader", "size in data header exceeds event size!");
	Warning("ReadHeader", "skipping %ld bytes", fEnd - fPosition);
	fEquipment->GetEquipmentHeader()->Dump();
	fCount = 0;
	fPosition = fEnd;
	fErrorCode = kErrSize;
	continue;
      }

    } else {
      fCount = fEnd - fPosition;
    }

  } while (!IsSelected());

  return kTRUE;
}

Bool_t AliRawReaderRoot::ReadNextData(UChar_t*& data)
{
// reads the next payload at the current position
// returns kFALSE if the data could not be read

  fErrorCode = 0;
  while (fCount == 0) {
    if (!ReadHeader()) return kFALSE;
  }
  data = fPosition;
  fPosition += fCount;  
  fCount = 0;
  return kTRUE;
}

Bool_t AliRawReaderRoot::ReadNext(UChar_t* data, Int_t size)
{
// reads the next block of data at the current position
// returns kFALSE if the data could not be read

  fErrorCode = 0;
  if (fPosition + size > fEnd) {
    Error("ReadNext", "could not read data!");
    fErrorCode = kErrOutOfBounds;
    return kFALSE;
  }
  memcpy(data, fPosition, size);

  fPosition += size;
  fCount -= size;
  return kTRUE;
}


Bool_t AliRawReaderRoot::Reset()
{
// reset the current position to the beginning of the event

  fSubEventIndex = 0;
  fSubEvent = NULL;
  fEquipmentIndex = 0;
  fEquipment = NULL;
  fRawData = NULL;
  fHeader = NULL;
  fHeaderV3 = NULL;

  fCount = 0;
  fPosition = fEnd = NULL;
  return kTRUE;
}


Bool_t AliRawReaderRoot::NextEvent()
{
// go to the next event in the root file

  if (!fBranch) return kFALSE;

  // check if it uses order or not
  if (fgUseOrder && !fIndex) MakeIndex();

  do {
    delete fEvent;
    fEvent = NULL;
    fEventHeader = NULL;
    fBranch->SetAddress(&fEvent);
    Int_t entryToGet = fEventIndex + 1;
    if (fgUseOrder 
	&& fIndex 
	&& entryToGet<fBranch->GetEntries()
	&& entryToGet>-1 ) entryToGet = fIndex[entryToGet];
    if (fBranch->GetEntry(entryToGet) <= 0)
      return kFALSE;
    fEventHeader = fEvent->GetHeader();
    fEventIndex++;
  } while (!IsEventSelected());
  fEventNumber++;
  return Reset();
}

Bool_t AliRawReaderRoot::RewindEvents()
{
// go back to the beginning of the root file

  if (!fBranch) return kFALSE;

  fEventIndex = -1;
  delete fEvent;
  fEvent = NULL;
  fEventHeader = NULL;
  fBranch->SetAddress(&fEvent);
  fEventNumber = -1;
  return Reset();
}

Bool_t  AliRawReaderRoot::GotoEvent(Int_t event)
{
  // go to a particular event
  // Uses the absolute event index inside the
  // raw-data file

  if (!fBranch) return kFALSE;

  // check if it uses order or not
  if (fgUseOrder && !fIndex) MakeIndex();

  delete fEvent;
  fEvent = NULL;
  fEventHeader = NULL;
  fBranch->SetAddress(&fEvent);
  Int_t entryToGet = event;
  if (fgUseOrder 
      && fIndex 
      && entryToGet<fBranch->GetEntries()
      && entryToGet>-1 ) entryToGet = fIndex[entryToGet];
  if (fBranch->GetEntry(entryToGet) <= 0)
    return kFALSE;
  fEventHeader = fEvent->GetHeader();
  fEventIndex = event;
  fEventNumber++;
  return Reset();
}

Int_t AliRawReaderRoot::GetNumberOfEvents() const
{
  // Get the total number of events in
  // the raw-data tree

  if (!fBranch) return -1;

  return fBranch->GetEntries();
}

Int_t AliRawReaderRoot::CheckData() const
{
// check the consistency of the data

  if (!fEvent) return 0;

  AliRawVEvent* subEvent = NULL;
  Int_t subEventIndex = 0;
  AliRawVEquipment* equipment = NULL;
  Int_t equipmentIndex = 0;
  UChar_t* position = 0;
  UChar_t* end = 0;
  Int_t result = 0;

  while (kTRUE) {
    // get the first or the next sub event if at the end of an equipment
    if (!subEvent || (equipmentIndex >= subEvent->GetNEquipments())) {

      // check for end of event data
      if (subEventIndex >= fEvent->GetNSubEvents()) return result;
      subEvent = fEvent->GetSubEvent(subEventIndex++);

      // check the magic word of the sub event
      if (fSubEvent && !fSubEvent->GetHeader()->IsValid()) {
	result |= kErrMagic;
	return result;
      }

      equipmentIndex = 0;
    }

    // get the next equipment and raw data
    if (equipmentIndex >= subEvent->GetNEquipments()) {
      equipment = NULL;
      continue;
    }
    equipment = subEvent->GetEquipment(equipmentIndex++);
    if (!equipment) continue;
    AliRawData* rawData = equipment->GetRawData();
    if (!rawData) continue;
    position = (UChar_t*) rawData->GetBuffer();
    end = ((UChar_t*) rawData->GetBuffer()) + rawData->GetSize();

    // continue with the next sub event if no data left in the payload
    if (position >= end) continue;

    if (fRequireHeader) {
    // check that there are enough bytes left for the data header
      if (position + sizeof(AliRawDataHeader) > end) {
	result |= kErrNoDataHeader;
	continue;
      }

      // Here we have to check if we have header v2 or v3
      // check consistency of data size in the header and in the equipment
      AliRawDataHeader* header = (AliRawDataHeader*) position;
      UChar_t version = header->GetVersion();
      if (version==2) {
	if ((position + header->fSize) != end) {
	  if (header->fSize != 0xFFFFFFFF)
	    Warning("CheckData",
		    "Equipment %d : raw data size found in the header V2 is wrong (%d != %ld)! Using the equipment size instead !",
		    equipment->GetEquipmentHeader()->GetId(),header->fSize, end - position);
	  header->fSize = end - position;
	  result |= kErrSize;
	}
      }
      else if (version==3) {

	AliRawDataHeaderV3 * headerV3 =  (AliRawDataHeaderV3*) position;
	if ((position + headerV3->fSize) != end) {
	  if (headerV3->fSize != 0xFFFFFFFF)
	    Warning("CheckData",
		    "Equipment %d : raw data size found in the header V3 is wrong (%d != %ld)! Using the equipment size instead !",
		    equipment->GetEquipmentHeader()->GetId(),headerV3->fSize, end - position);
	  headerV3->fSize = end - position;
	  result |= kErrSize;
	}
      }
      
    }
    position = end;
  };

  return result;
}

AliRawReader* AliRawReaderRoot::CloneSingleEvent() const
{
  // Clones the current event and
  // creates raw-reader for the cloned event
  // Can be used in order to make asynchronious
  // access to the current raw data within
  // several threads (online event display/reco)

  if (fEvent) {
    // Root formatted raw data
    AliRawVEvent *gdcRootEvent = (AliRawVEvent*)fEvent->Clone();
    for (Int_t ldcCounter=0; ldcCounter < gdcRootEvent->GetNSubEvents(); ldcCounter++) {
      AliRawVEvent *ldcRootEvent = gdcRootEvent->GetSubEvent(ldcCounter);
      AliRawVEvent *subEvent = fEvent->GetSubEvent(ldcCounter);
      for (Int_t eqCounter=0; eqCounter < ldcRootEvent->GetNEquipments(); eqCounter++) {
	AliRawVEquipment *equipment=ldcRootEvent->GetEquipment(eqCounter);
	AliRawVEquipment *eq = subEvent->GetEquipment(eqCounter);
	equipment->CloneRawData(eq->GetRawData());
      }
    }
    // Reset original event and newly
    // produced one
    gdcRootEvent->GetSubEvent(-1);
    fEvent->GetSubEvent(-1);
    return new AliRawReaderRoot(gdcRootEvent);
  }
  return NULL;
}

void AliRawReaderRoot::MakeIndex() {
  // Make index
  if (fBranch) {
    TTree * rawTree = fBranch->GetTree();
    if (rawTree) {
      rawTree->BuildIndex("-fEvtHdrs[0].fSize"); // Minus sign to get largest first
      TTreeIndex * treeInd = (TTreeIndex*)rawTree->GetTreeIndex();
      if (treeInd) fIndex = treeInd->GetIndex();
    }
  }
}
 AliRawReaderRoot.cxx:1
 AliRawReaderRoot.cxx:2
 AliRawReaderRoot.cxx:3
 AliRawReaderRoot.cxx:4
 AliRawReaderRoot.cxx:5
 AliRawReaderRoot.cxx:6
 AliRawReaderRoot.cxx:7
 AliRawReaderRoot.cxx:8
 AliRawReaderRoot.cxx:9
 AliRawReaderRoot.cxx:10
 AliRawReaderRoot.cxx:11
 AliRawReaderRoot.cxx:12
 AliRawReaderRoot.cxx:13
 AliRawReaderRoot.cxx:14
 AliRawReaderRoot.cxx:15
 AliRawReaderRoot.cxx:16
 AliRawReaderRoot.cxx:17
 AliRawReaderRoot.cxx:18
 AliRawReaderRoot.cxx:19
 AliRawReaderRoot.cxx:20
 AliRawReaderRoot.cxx:21
 AliRawReaderRoot.cxx:22
 AliRawReaderRoot.cxx:23
 AliRawReaderRoot.cxx:24
 AliRawReaderRoot.cxx:25
 AliRawReaderRoot.cxx:26
 AliRawReaderRoot.cxx:27
 AliRawReaderRoot.cxx:28
 AliRawReaderRoot.cxx:29
 AliRawReaderRoot.cxx:30
 AliRawReaderRoot.cxx:31
 AliRawReaderRoot.cxx:32
 AliRawReaderRoot.cxx:33
 AliRawReaderRoot.cxx:34
 AliRawReaderRoot.cxx:35
 AliRawReaderRoot.cxx:36
 AliRawReaderRoot.cxx:37
 AliRawReaderRoot.cxx:38
 AliRawReaderRoot.cxx:39
 AliRawReaderRoot.cxx:40
 AliRawReaderRoot.cxx:41
 AliRawReaderRoot.cxx:42
 AliRawReaderRoot.cxx:43
 AliRawReaderRoot.cxx:44
 AliRawReaderRoot.cxx:45
 AliRawReaderRoot.cxx:46
 AliRawReaderRoot.cxx:47
 AliRawReaderRoot.cxx:48
 AliRawReaderRoot.cxx:49
 AliRawReaderRoot.cxx:50
 AliRawReaderRoot.cxx:51
 AliRawReaderRoot.cxx:52
 AliRawReaderRoot.cxx:53
 AliRawReaderRoot.cxx:54
 AliRawReaderRoot.cxx:55
 AliRawReaderRoot.cxx:56
 AliRawReaderRoot.cxx:57
 AliRawReaderRoot.cxx:58
 AliRawReaderRoot.cxx:59
 AliRawReaderRoot.cxx:60
 AliRawReaderRoot.cxx:61
 AliRawReaderRoot.cxx:62
 AliRawReaderRoot.cxx:63
 AliRawReaderRoot.cxx:64
 AliRawReaderRoot.cxx:65
 AliRawReaderRoot.cxx:66
 AliRawReaderRoot.cxx:67
 AliRawReaderRoot.cxx:68
 AliRawReaderRoot.cxx:69
 AliRawReaderRoot.cxx:70
 AliRawReaderRoot.cxx:71
 AliRawReaderRoot.cxx:72
 AliRawReaderRoot.cxx:73
 AliRawReaderRoot.cxx:74
 AliRawReaderRoot.cxx:75
 AliRawReaderRoot.cxx:76
 AliRawReaderRoot.cxx:77
 AliRawReaderRoot.cxx:78
 AliRawReaderRoot.cxx:79
 AliRawReaderRoot.cxx:80
 AliRawReaderRoot.cxx:81
 AliRawReaderRoot.cxx:82
 AliRawReaderRoot.cxx:83
 AliRawReaderRoot.cxx:84
 AliRawReaderRoot.cxx:85
 AliRawReaderRoot.cxx:86
 AliRawReaderRoot.cxx:87
 AliRawReaderRoot.cxx:88
 AliRawReaderRoot.cxx:89
 AliRawReaderRoot.cxx:90
 AliRawReaderRoot.cxx:91
 AliRawReaderRoot.cxx:92
 AliRawReaderRoot.cxx:93
 AliRawReaderRoot.cxx:94
 AliRawReaderRoot.cxx:95
 AliRawReaderRoot.cxx:96
 AliRawReaderRoot.cxx:97
 AliRawReaderRoot.cxx:98
 AliRawReaderRoot.cxx:99
 AliRawReaderRoot.cxx:100
 AliRawReaderRoot.cxx:101
 AliRawReaderRoot.cxx:102
 AliRawReaderRoot.cxx:103
 AliRawReaderRoot.cxx:104
 AliRawReaderRoot.cxx:105
 AliRawReaderRoot.cxx:106
 AliRawReaderRoot.cxx:107
 AliRawReaderRoot.cxx:108
 AliRawReaderRoot.cxx:109
 AliRawReaderRoot.cxx:110
 AliRawReaderRoot.cxx:111
 AliRawReaderRoot.cxx:112
 AliRawReaderRoot.cxx:113
 AliRawReaderRoot.cxx:114
 AliRawReaderRoot.cxx:115
 AliRawReaderRoot.cxx:116
 AliRawReaderRoot.cxx:117
 AliRawReaderRoot.cxx:118
 AliRawReaderRoot.cxx:119
 AliRawReaderRoot.cxx:120
 AliRawReaderRoot.cxx:121
 AliRawReaderRoot.cxx:122
 AliRawReaderRoot.cxx:123
 AliRawReaderRoot.cxx:124
 AliRawReaderRoot.cxx:125
 AliRawReaderRoot.cxx:126
 AliRawReaderRoot.cxx:127
 AliRawReaderRoot.cxx:128
 AliRawReaderRoot.cxx:129
 AliRawReaderRoot.cxx:130
 AliRawReaderRoot.cxx:131
 AliRawReaderRoot.cxx:132
 AliRawReaderRoot.cxx:133
 AliRawReaderRoot.cxx:134
 AliRawReaderRoot.cxx:135
 AliRawReaderRoot.cxx:136
 AliRawReaderRoot.cxx:137
 AliRawReaderRoot.cxx:138
 AliRawReaderRoot.cxx:139
 AliRawReaderRoot.cxx:140
 AliRawReaderRoot.cxx:141
 AliRawReaderRoot.cxx:142
 AliRawReaderRoot.cxx:143
 AliRawReaderRoot.cxx:144
 AliRawReaderRoot.cxx:145
 AliRawReaderRoot.cxx:146
 AliRawReaderRoot.cxx:147
 AliRawReaderRoot.cxx:148
 AliRawReaderRoot.cxx:149
 AliRawReaderRoot.cxx:150
 AliRawReaderRoot.cxx:151
 AliRawReaderRoot.cxx:152
 AliRawReaderRoot.cxx:153
 AliRawReaderRoot.cxx:154
 AliRawReaderRoot.cxx:155
 AliRawReaderRoot.cxx:156
 AliRawReaderRoot.cxx:157
 AliRawReaderRoot.cxx:158
 AliRawReaderRoot.cxx:159
 AliRawReaderRoot.cxx:160
 AliRawReaderRoot.cxx:161
 AliRawReaderRoot.cxx:162
 AliRawReaderRoot.cxx:163
 AliRawReaderRoot.cxx:164
 AliRawReaderRoot.cxx:165
 AliRawReaderRoot.cxx:166
 AliRawReaderRoot.cxx:167
 AliRawReaderRoot.cxx:168
 AliRawReaderRoot.cxx:169
 AliRawReaderRoot.cxx:170
 AliRawReaderRoot.cxx:171
 AliRawReaderRoot.cxx:172
 AliRawReaderRoot.cxx:173
 AliRawReaderRoot.cxx:174
 AliRawReaderRoot.cxx:175
 AliRawReaderRoot.cxx:176
 AliRawReaderRoot.cxx:177
 AliRawReaderRoot.cxx:178
 AliRawReaderRoot.cxx:179
 AliRawReaderRoot.cxx:180
 AliRawReaderRoot.cxx:181
 AliRawReaderRoot.cxx:182
 AliRawReaderRoot.cxx:183
 AliRawReaderRoot.cxx:184
 AliRawReaderRoot.cxx:185
 AliRawReaderRoot.cxx:186
 AliRawReaderRoot.cxx:187
 AliRawReaderRoot.cxx:188
 AliRawReaderRoot.cxx:189
 AliRawReaderRoot.cxx:190
 AliRawReaderRoot.cxx:191
 AliRawReaderRoot.cxx:192
 AliRawReaderRoot.cxx:193
 AliRawReaderRoot.cxx:194
 AliRawReaderRoot.cxx:195
 AliRawReaderRoot.cxx:196
 AliRawReaderRoot.cxx:197
 AliRawReaderRoot.cxx:198
 AliRawReaderRoot.cxx:199
 AliRawReaderRoot.cxx:200
 AliRawReaderRoot.cxx:201
 AliRawReaderRoot.cxx:202
 AliRawReaderRoot.cxx:203
 AliRawReaderRoot.cxx:204
 AliRawReaderRoot.cxx:205
 AliRawReaderRoot.cxx:206
 AliRawReaderRoot.cxx:207
 AliRawReaderRoot.cxx:208
 AliRawReaderRoot.cxx:209
 AliRawReaderRoot.cxx:210
 AliRawReaderRoot.cxx:211
 AliRawReaderRoot.cxx:212
 AliRawReaderRoot.cxx:213
 AliRawReaderRoot.cxx:214
 AliRawReaderRoot.cxx:215
 AliRawReaderRoot.cxx:216
 AliRawReaderRoot.cxx:217
 AliRawReaderRoot.cxx:218
 AliRawReaderRoot.cxx:219
 AliRawReaderRoot.cxx:220
 AliRawReaderRoot.cxx:221
 AliRawReaderRoot.cxx:222
 AliRawReaderRoot.cxx:223
 AliRawReaderRoot.cxx:224
 AliRawReaderRoot.cxx:225
 AliRawReaderRoot.cxx:226
 AliRawReaderRoot.cxx:227
 AliRawReaderRoot.cxx:228
 AliRawReaderRoot.cxx:229
 AliRawReaderRoot.cxx:230
 AliRawReaderRoot.cxx:231
 AliRawReaderRoot.cxx:232
 AliRawReaderRoot.cxx:233
 AliRawReaderRoot.cxx:234
 AliRawReaderRoot.cxx:235
 AliRawReaderRoot.cxx:236
 AliRawReaderRoot.cxx:237
 AliRawReaderRoot.cxx:238
 AliRawReaderRoot.cxx:239
 AliRawReaderRoot.cxx:240
 AliRawReaderRoot.cxx:241
 AliRawReaderRoot.cxx:242
 AliRawReaderRoot.cxx:243
 AliRawReaderRoot.cxx:244
 AliRawReaderRoot.cxx:245
 AliRawReaderRoot.cxx:246
 AliRawReaderRoot.cxx:247
 AliRawReaderRoot.cxx:248
 AliRawReaderRoot.cxx:249
 AliRawReaderRoot.cxx:250
 AliRawReaderRoot.cxx:251
 AliRawReaderRoot.cxx:252
 AliRawReaderRoot.cxx:253
 AliRawReaderRoot.cxx:254
 AliRawReaderRoot.cxx:255
 AliRawReaderRoot.cxx:256
 AliRawReaderRoot.cxx:257
 AliRawReaderRoot.cxx:258
 AliRawReaderRoot.cxx:259
 AliRawReaderRoot.cxx:260
 AliRawReaderRoot.cxx:261
 AliRawReaderRoot.cxx:262
 AliRawReaderRoot.cxx:263
 AliRawReaderRoot.cxx:264
 AliRawReaderRoot.cxx:265
 AliRawReaderRoot.cxx:266
 AliRawReaderRoot.cxx:267
 AliRawReaderRoot.cxx:268
 AliRawReaderRoot.cxx:269
 AliRawReaderRoot.cxx:270
 AliRawReaderRoot.cxx:271
 AliRawReaderRoot.cxx:272
 AliRawReaderRoot.cxx:273
 AliRawReaderRoot.cxx:274
 AliRawReaderRoot.cxx:275
 AliRawReaderRoot.cxx:276
 AliRawReaderRoot.cxx:277
 AliRawReaderRoot.cxx:278
 AliRawReaderRoot.cxx:279
 AliRawReaderRoot.cxx:280
 AliRawReaderRoot.cxx:281
 AliRawReaderRoot.cxx:282
 AliRawReaderRoot.cxx:283
 AliRawReaderRoot.cxx:284
 AliRawReaderRoot.cxx:285
 AliRawReaderRoot.cxx:286
 AliRawReaderRoot.cxx:287
 AliRawReaderRoot.cxx:288
 AliRawReaderRoot.cxx:289
 AliRawReaderRoot.cxx:290
 AliRawReaderRoot.cxx:291
 AliRawReaderRoot.cxx:292
 AliRawReaderRoot.cxx:293
 AliRawReaderRoot.cxx:294
 AliRawReaderRoot.cxx:295
 AliRawReaderRoot.cxx:296
 AliRawReaderRoot.cxx:297
 AliRawReaderRoot.cxx:298
 AliRawReaderRoot.cxx:299
 AliRawReaderRoot.cxx:300
 AliRawReaderRoot.cxx:301
 AliRawReaderRoot.cxx:302
 AliRawReaderRoot.cxx:303
 AliRawReaderRoot.cxx:304
 AliRawReaderRoot.cxx:305
 AliRawReaderRoot.cxx:306
 AliRawReaderRoot.cxx:307
 AliRawReaderRoot.cxx:308
 AliRawReaderRoot.cxx:309
 AliRawReaderRoot.cxx:310
 AliRawReaderRoot.cxx:311
 AliRawReaderRoot.cxx:312
 AliRawReaderRoot.cxx:313
 AliRawReaderRoot.cxx:314
 AliRawReaderRoot.cxx:315
 AliRawReaderRoot.cxx:316
 AliRawReaderRoot.cxx:317
 AliRawReaderRoot.cxx:318
 AliRawReaderRoot.cxx:319
 AliRawReaderRoot.cxx:320
 AliRawReaderRoot.cxx:321
 AliRawReaderRoot.cxx:322
 AliRawReaderRoot.cxx:323
 AliRawReaderRoot.cxx:324
 AliRawReaderRoot.cxx:325
 AliRawReaderRoot.cxx:326
 AliRawReaderRoot.cxx:327
 AliRawReaderRoot.cxx:328
 AliRawReaderRoot.cxx:329
 AliRawReaderRoot.cxx:330
 AliRawReaderRoot.cxx:331
 AliRawReaderRoot.cxx:332
 AliRawReaderRoot.cxx:333
 AliRawReaderRoot.cxx:334
 AliRawReaderRoot.cxx:335
 AliRawReaderRoot.cxx:336
 AliRawReaderRoot.cxx:337
 AliRawReaderRoot.cxx:338
 AliRawReaderRoot.cxx:339
 AliRawReaderRoot.cxx:340
 AliRawReaderRoot.cxx:341
 AliRawReaderRoot.cxx:342
 AliRawReaderRoot.cxx:343
 AliRawReaderRoot.cxx:344
 AliRawReaderRoot.cxx:345
 AliRawReaderRoot.cxx:346
 AliRawReaderRoot.cxx:347
 AliRawReaderRoot.cxx:348
 AliRawReaderRoot.cxx:349
 AliRawReaderRoot.cxx:350
 AliRawReaderRoot.cxx:351
 AliRawReaderRoot.cxx:352
 AliRawReaderRoot.cxx:353
 AliRawReaderRoot.cxx:354
 AliRawReaderRoot.cxx:355
 AliRawReaderRoot.cxx:356
 AliRawReaderRoot.cxx:357
 AliRawReaderRoot.cxx:358
 AliRawReaderRoot.cxx:359
 AliRawReaderRoot.cxx:360
 AliRawReaderRoot.cxx:361
 AliRawReaderRoot.cxx:362
 AliRawReaderRoot.cxx:363
 AliRawReaderRoot.cxx:364
 AliRawReaderRoot.cxx:365
 AliRawReaderRoot.cxx:366
 AliRawReaderRoot.cxx:367
 AliRawReaderRoot.cxx:368
 AliRawReaderRoot.cxx:369
 AliRawReaderRoot.cxx:370
 AliRawReaderRoot.cxx:371
 AliRawReaderRoot.cxx:372
 AliRawReaderRoot.cxx:373
 AliRawReaderRoot.cxx:374
 AliRawReaderRoot.cxx:375
 AliRawReaderRoot.cxx:376
 AliRawReaderRoot.cxx:377
 AliRawReaderRoot.cxx:378
 AliRawReaderRoot.cxx:379
 AliRawReaderRoot.cxx:380
 AliRawReaderRoot.cxx:381
 AliRawReaderRoot.cxx:382
 AliRawReaderRoot.cxx:383
 AliRawReaderRoot.cxx:384
 AliRawReaderRoot.cxx:385
 AliRawReaderRoot.cxx:386
 AliRawReaderRoot.cxx:387
 AliRawReaderRoot.cxx:388
 AliRawReaderRoot.cxx:389
 AliRawReaderRoot.cxx:390
 AliRawReaderRoot.cxx:391
 AliRawReaderRoot.cxx:392
 AliRawReaderRoot.cxx:393
 AliRawReaderRoot.cxx:394
 AliRawReaderRoot.cxx:395
 AliRawReaderRoot.cxx:396
 AliRawReaderRoot.cxx:397
 AliRawReaderRoot.cxx:398
 AliRawReaderRoot.cxx:399
 AliRawReaderRoot.cxx:400
 AliRawReaderRoot.cxx:401
 AliRawReaderRoot.cxx:402
 AliRawReaderRoot.cxx:403
 AliRawReaderRoot.cxx:404
 AliRawReaderRoot.cxx:405
 AliRawReaderRoot.cxx:406
 AliRawReaderRoot.cxx:407
 AliRawReaderRoot.cxx:408
 AliRawReaderRoot.cxx:409
 AliRawReaderRoot.cxx:410
 AliRawReaderRoot.cxx:411
 AliRawReaderRoot.cxx:412
 AliRawReaderRoot.cxx:413
 AliRawReaderRoot.cxx:414
 AliRawReaderRoot.cxx:415
 AliRawReaderRoot.cxx:416
 AliRawReaderRoot.cxx:417
 AliRawReaderRoot.cxx:418
 AliRawReaderRoot.cxx:419
 AliRawReaderRoot.cxx:420
 AliRawReaderRoot.cxx:421
 AliRawReaderRoot.cxx:422
 AliRawReaderRoot.cxx:423
 AliRawReaderRoot.cxx:424
 AliRawReaderRoot.cxx:425
 AliRawReaderRoot.cxx:426
 AliRawReaderRoot.cxx:427
 AliRawReaderRoot.cxx:428
 AliRawReaderRoot.cxx:429
 AliRawReaderRoot.cxx:430
 AliRawReaderRoot.cxx:431
 AliRawReaderRoot.cxx:432
 AliRawReaderRoot.cxx:433
 AliRawReaderRoot.cxx:434
 AliRawReaderRoot.cxx:435
 AliRawReaderRoot.cxx:436
 AliRawReaderRoot.cxx:437
 AliRawReaderRoot.cxx:438
 AliRawReaderRoot.cxx:439
 AliRawReaderRoot.cxx:440
 AliRawReaderRoot.cxx:441
 AliRawReaderRoot.cxx:442
 AliRawReaderRoot.cxx:443
 AliRawReaderRoot.cxx:444
 AliRawReaderRoot.cxx:445
 AliRawReaderRoot.cxx:446
 AliRawReaderRoot.cxx:447
 AliRawReaderRoot.cxx:448
 AliRawReaderRoot.cxx:449
 AliRawReaderRoot.cxx:450
 AliRawReaderRoot.cxx:451
 AliRawReaderRoot.cxx:452
 AliRawReaderRoot.cxx:453
 AliRawReaderRoot.cxx:454
 AliRawReaderRoot.cxx:455
 AliRawReaderRoot.cxx:456
 AliRawReaderRoot.cxx:457
 AliRawReaderRoot.cxx:458
 AliRawReaderRoot.cxx:459
 AliRawReaderRoot.cxx:460
 AliRawReaderRoot.cxx:461
 AliRawReaderRoot.cxx:462
 AliRawReaderRoot.cxx:463
 AliRawReaderRoot.cxx:464
 AliRawReaderRoot.cxx:465
 AliRawReaderRoot.cxx:466
 AliRawReaderRoot.cxx:467
 AliRawReaderRoot.cxx:468
 AliRawReaderRoot.cxx:469
 AliRawReaderRoot.cxx:470
 AliRawReaderRoot.cxx:471
 AliRawReaderRoot.cxx:472
 AliRawReaderRoot.cxx:473
 AliRawReaderRoot.cxx:474
 AliRawReaderRoot.cxx:475
 AliRawReaderRoot.cxx:476
 AliRawReaderRoot.cxx:477
 AliRawReaderRoot.cxx:478
 AliRawReaderRoot.cxx:479
 AliRawReaderRoot.cxx:480
 AliRawReaderRoot.cxx:481
 AliRawReaderRoot.cxx:482
 AliRawReaderRoot.cxx:483
 AliRawReaderRoot.cxx:484
 AliRawReaderRoot.cxx:485
 AliRawReaderRoot.cxx:486
 AliRawReaderRoot.cxx:487
 AliRawReaderRoot.cxx:488
 AliRawReaderRoot.cxx:489
 AliRawReaderRoot.cxx:490
 AliRawReaderRoot.cxx:491
 AliRawReaderRoot.cxx:492
 AliRawReaderRoot.cxx:493
 AliRawReaderRoot.cxx:494
 AliRawReaderRoot.cxx:495
 AliRawReaderRoot.cxx:496
 AliRawReaderRoot.cxx:497
 AliRawReaderRoot.cxx:498
 AliRawReaderRoot.cxx:499
 AliRawReaderRoot.cxx:500
 AliRawReaderRoot.cxx:501
 AliRawReaderRoot.cxx:502
 AliRawReaderRoot.cxx:503
 AliRawReaderRoot.cxx:504
 AliRawReaderRoot.cxx:505
 AliRawReaderRoot.cxx:506
 AliRawReaderRoot.cxx:507
 AliRawReaderRoot.cxx:508
 AliRawReaderRoot.cxx:509
 AliRawReaderRoot.cxx:510
 AliRawReaderRoot.cxx:511
 AliRawReaderRoot.cxx:512
 AliRawReaderRoot.cxx:513
 AliRawReaderRoot.cxx:514
 AliRawReaderRoot.cxx:515
 AliRawReaderRoot.cxx:516
 AliRawReaderRoot.cxx:517
 AliRawReaderRoot.cxx:518
 AliRawReaderRoot.cxx:519
 AliRawReaderRoot.cxx:520
 AliRawReaderRoot.cxx:521
 AliRawReaderRoot.cxx:522
 AliRawReaderRoot.cxx:523
 AliRawReaderRoot.cxx:524
 AliRawReaderRoot.cxx:525
 AliRawReaderRoot.cxx:526
 AliRawReaderRoot.cxx:527
 AliRawReaderRoot.cxx:528
 AliRawReaderRoot.cxx:529
 AliRawReaderRoot.cxx:530
 AliRawReaderRoot.cxx:531
 AliRawReaderRoot.cxx:532
 AliRawReaderRoot.cxx:533
 AliRawReaderRoot.cxx:534
 AliRawReaderRoot.cxx:535
 AliRawReaderRoot.cxx:536
 AliRawReaderRoot.cxx:537
 AliRawReaderRoot.cxx:538
 AliRawReaderRoot.cxx:539
 AliRawReaderRoot.cxx:540
 AliRawReaderRoot.cxx:541
 AliRawReaderRoot.cxx:542
 AliRawReaderRoot.cxx:543
 AliRawReaderRoot.cxx:544
 AliRawReaderRoot.cxx:545
 AliRawReaderRoot.cxx:546
 AliRawReaderRoot.cxx:547
 AliRawReaderRoot.cxx:548
 AliRawReaderRoot.cxx:549
 AliRawReaderRoot.cxx:550
 AliRawReaderRoot.cxx:551
 AliRawReaderRoot.cxx:552
 AliRawReaderRoot.cxx:553
 AliRawReaderRoot.cxx:554
 AliRawReaderRoot.cxx:555
 AliRawReaderRoot.cxx:556
 AliRawReaderRoot.cxx:557
 AliRawReaderRoot.cxx:558
 AliRawReaderRoot.cxx:559
 AliRawReaderRoot.cxx:560
 AliRawReaderRoot.cxx:561
 AliRawReaderRoot.cxx:562
 AliRawReaderRoot.cxx:563
 AliRawReaderRoot.cxx:564
 AliRawReaderRoot.cxx:565
 AliRawReaderRoot.cxx:566
 AliRawReaderRoot.cxx:567
 AliRawReaderRoot.cxx:568
 AliRawReaderRoot.cxx:569
 AliRawReaderRoot.cxx:570
 AliRawReaderRoot.cxx:571
 AliRawReaderRoot.cxx:572
 AliRawReaderRoot.cxx:573
 AliRawReaderRoot.cxx:574
 AliRawReaderRoot.cxx:575
 AliRawReaderRoot.cxx:576
 AliRawReaderRoot.cxx:577
 AliRawReaderRoot.cxx:578
 AliRawReaderRoot.cxx:579
 AliRawReaderRoot.cxx:580
 AliRawReaderRoot.cxx:581
 AliRawReaderRoot.cxx:582
 AliRawReaderRoot.cxx:583
 AliRawReaderRoot.cxx:584
 AliRawReaderRoot.cxx:585
 AliRawReaderRoot.cxx:586
 AliRawReaderRoot.cxx:587
 AliRawReaderRoot.cxx:588
 AliRawReaderRoot.cxx:589
 AliRawReaderRoot.cxx:590
 AliRawReaderRoot.cxx:591
 AliRawReaderRoot.cxx:592
 AliRawReaderRoot.cxx:593
 AliRawReaderRoot.cxx:594
 AliRawReaderRoot.cxx:595
 AliRawReaderRoot.cxx:596
 AliRawReaderRoot.cxx:597
 AliRawReaderRoot.cxx:598
 AliRawReaderRoot.cxx:599
 AliRawReaderRoot.cxx:600
 AliRawReaderRoot.cxx:601
 AliRawReaderRoot.cxx:602
 AliRawReaderRoot.cxx:603
 AliRawReaderRoot.cxx:604
 AliRawReaderRoot.cxx:605
 AliRawReaderRoot.cxx:606
 AliRawReaderRoot.cxx:607
 AliRawReaderRoot.cxx:608
 AliRawReaderRoot.cxx:609
 AliRawReaderRoot.cxx:610
 AliRawReaderRoot.cxx:611
 AliRawReaderRoot.cxx:612
 AliRawReaderRoot.cxx:613
 AliRawReaderRoot.cxx:614
 AliRawReaderRoot.cxx:615
 AliRawReaderRoot.cxx:616
 AliRawReaderRoot.cxx:617
 AliRawReaderRoot.cxx:618
 AliRawReaderRoot.cxx:619
 AliRawReaderRoot.cxx:620
 AliRawReaderRoot.cxx:621
 AliRawReaderRoot.cxx:622
 AliRawReaderRoot.cxx:623
 AliRawReaderRoot.cxx:624
 AliRawReaderRoot.cxx:625
 AliRawReaderRoot.cxx:626
 AliRawReaderRoot.cxx:627
 AliRawReaderRoot.cxx:628
 AliRawReaderRoot.cxx:629
 AliRawReaderRoot.cxx:630
 AliRawReaderRoot.cxx:631
 AliRawReaderRoot.cxx:632
 AliRawReaderRoot.cxx:633
 AliRawReaderRoot.cxx:634
 AliRawReaderRoot.cxx:635
 AliRawReaderRoot.cxx:636
 AliRawReaderRoot.cxx:637
 AliRawReaderRoot.cxx:638
 AliRawReaderRoot.cxx:639
 AliRawReaderRoot.cxx:640
 AliRawReaderRoot.cxx:641
 AliRawReaderRoot.cxx:642
 AliRawReaderRoot.cxx:643
 AliRawReaderRoot.cxx:644
 AliRawReaderRoot.cxx:645
 AliRawReaderRoot.cxx:646
 AliRawReaderRoot.cxx:647
 AliRawReaderRoot.cxx:648
 AliRawReaderRoot.cxx:649
 AliRawReaderRoot.cxx:650
 AliRawReaderRoot.cxx:651
 AliRawReaderRoot.cxx:652
 AliRawReaderRoot.cxx:653
 AliRawReaderRoot.cxx:654
 AliRawReaderRoot.cxx:655
 AliRawReaderRoot.cxx:656
 AliRawReaderRoot.cxx:657
 AliRawReaderRoot.cxx:658
 AliRawReaderRoot.cxx:659
 AliRawReaderRoot.cxx:660
 AliRawReaderRoot.cxx:661
 AliRawReaderRoot.cxx:662
 AliRawReaderRoot.cxx:663
 AliRawReaderRoot.cxx:664
 AliRawReaderRoot.cxx:665
 AliRawReaderRoot.cxx:666
 AliRawReaderRoot.cxx:667
 AliRawReaderRoot.cxx:668
 AliRawReaderRoot.cxx:669
 AliRawReaderRoot.cxx:670
 AliRawReaderRoot.cxx:671
 AliRawReaderRoot.cxx:672
 AliRawReaderRoot.cxx:673
 AliRawReaderRoot.cxx:674
 AliRawReaderRoot.cxx:675
 AliRawReaderRoot.cxx:676
 AliRawReaderRoot.cxx:677
 AliRawReaderRoot.cxx:678
 AliRawReaderRoot.cxx:679
 AliRawReaderRoot.cxx:680
 AliRawReaderRoot.cxx:681
 AliRawReaderRoot.cxx:682
 AliRawReaderRoot.cxx:683
 AliRawReaderRoot.cxx:684
 AliRawReaderRoot.cxx:685
 AliRawReaderRoot.cxx:686
 AliRawReaderRoot.cxx:687
 AliRawReaderRoot.cxx:688
 AliRawReaderRoot.cxx:689
 AliRawReaderRoot.cxx:690
 AliRawReaderRoot.cxx:691
 AliRawReaderRoot.cxx:692
 AliRawReaderRoot.cxx:693
 AliRawReaderRoot.cxx:694
 AliRawReaderRoot.cxx:695
 AliRawReaderRoot.cxx:696
 AliRawReaderRoot.cxx:697
 AliRawReaderRoot.cxx:698
 AliRawReaderRoot.cxx:699
 AliRawReaderRoot.cxx:700
 AliRawReaderRoot.cxx:701
 AliRawReaderRoot.cxx:702
 AliRawReaderRoot.cxx:703
 AliRawReaderRoot.cxx:704
 AliRawReaderRoot.cxx:705
 AliRawReaderRoot.cxx:706
 AliRawReaderRoot.cxx:707
 AliRawReaderRoot.cxx:708
 AliRawReaderRoot.cxx:709
 AliRawReaderRoot.cxx:710
 AliRawReaderRoot.cxx:711
 AliRawReaderRoot.cxx:712
 AliRawReaderRoot.cxx:713
 AliRawReaderRoot.cxx:714
 AliRawReaderRoot.cxx:715
 AliRawReaderRoot.cxx:716
 AliRawReaderRoot.cxx:717
 AliRawReaderRoot.cxx:718
 AliRawReaderRoot.cxx:719
 AliRawReaderRoot.cxx:720
 AliRawReaderRoot.cxx:721
 AliRawReaderRoot.cxx:722
 AliRawReaderRoot.cxx:723
 AliRawReaderRoot.cxx:724
 AliRawReaderRoot.cxx:725
 AliRawReaderRoot.cxx:726
 AliRawReaderRoot.cxx:727
 AliRawReaderRoot.cxx:728
 AliRawReaderRoot.cxx:729
 AliRawReaderRoot.cxx:730
 AliRawReaderRoot.cxx:731
 AliRawReaderRoot.cxx:732
 AliRawReaderRoot.cxx:733
 AliRawReaderRoot.cxx:734
 AliRawReaderRoot.cxx:735
 AliRawReaderRoot.cxx:736
 AliRawReaderRoot.cxx:737
 AliRawReaderRoot.cxx:738
 AliRawReaderRoot.cxx:739
 AliRawReaderRoot.cxx:740
 AliRawReaderRoot.cxx:741
 AliRawReaderRoot.cxx:742
 AliRawReaderRoot.cxx:743
 AliRawReaderRoot.cxx:744
 AliRawReaderRoot.cxx:745
 AliRawReaderRoot.cxx:746
 AliRawReaderRoot.cxx:747
 AliRawReaderRoot.cxx:748
 AliRawReaderRoot.cxx:749
 AliRawReaderRoot.cxx:750
 AliRawReaderRoot.cxx:751
 AliRawReaderRoot.cxx:752
 AliRawReaderRoot.cxx:753
 AliRawReaderRoot.cxx:754
 AliRawReaderRoot.cxx:755
 AliRawReaderRoot.cxx:756
 AliRawReaderRoot.cxx:757
 AliRawReaderRoot.cxx:758
 AliRawReaderRoot.cxx:759
 AliRawReaderRoot.cxx:760
 AliRawReaderRoot.cxx:761
 AliRawReaderRoot.cxx:762
 AliRawReaderRoot.cxx:763
 AliRawReaderRoot.cxx:764
 AliRawReaderRoot.cxx:765
 AliRawReaderRoot.cxx:766
 AliRawReaderRoot.cxx:767
 AliRawReaderRoot.cxx:768
 AliRawReaderRoot.cxx:769
 AliRawReaderRoot.cxx:770
 AliRawReaderRoot.cxx:771
 AliRawReaderRoot.cxx:772
 AliRawReaderRoot.cxx:773
 AliRawReaderRoot.cxx:774
 AliRawReaderRoot.cxx:775
 AliRawReaderRoot.cxx:776
 AliRawReaderRoot.cxx:777
 AliRawReaderRoot.cxx:778
 AliRawReaderRoot.cxx:779
 AliRawReaderRoot.cxx:780
 AliRawReaderRoot.cxx:781
 AliRawReaderRoot.cxx:782
 AliRawReaderRoot.cxx:783
 AliRawReaderRoot.cxx:784
 AliRawReaderRoot.cxx:785
 AliRawReaderRoot.cxx:786
 AliRawReaderRoot.cxx:787
 AliRawReaderRoot.cxx:788
 AliRawReaderRoot.cxx:789
 AliRawReaderRoot.cxx:790