[u/mrichter/AliRoot.git] / RAW / AliRawReaderChain.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.                  *
 **************************************************************************/

///////////////////////////////////////////////////////////////////////////////
///
/// This is a class for reading raw data from a root chain.
/// There are two constructors available - one from a text file containing the
/// list of root raw-data files to be processed and one directly from
/// TFileCollection.
///
/// cvetan.cheshkov@cern.ch 29/07/2008
///
///////////////////////////////////////////////////////////////////////////////

#include <TChain.h>
#include <TFileCollection.h>
#include <TEntryList.h>
#include "TGridCollection.h"
#include <TPluginManager.h>
#include <TROOT.h>
#include <TSystem.h>
#include <TFile.h>
#include <TKey.h>
#include <TGrid.h>
#include <TGridResult.h>

#include "AliRawReaderChain.h"
#include "AliRawVEvent.h"

ClassImp(AliRawReaderChain)

AliRawReaderChain::AliRawReaderChain() :
  AliRawReaderRoot(),
  fChain(NULL)
{
  // default constructor
}

AliRawReaderChain::AliRawReaderChain(const char* fileName) :
  AliRawReaderRoot(),
  fChain(NULL)
{
// create raw-reader objects which takes as an input a root chain
// either from the file list found in 'fileName' (IsCollection = true)
// or from entry list found in 'filename' (IsCollection = false)
// The entry-list syntax follows root convetion: filename.root/listname

  fChain = new TChain("RAW");

  TString fileNameStr = fileName;
  if (fileNameStr.EndsWith(".xml")) {

    TGridCollection *collection = NULL;
    TPluginManager* pluginManager = gROOT->GetPluginManager();
    TPluginHandler* pluginHandler = pluginManager->FindHandler("TGridCollection", "alice");
    if (!pluginHandler) {
      pluginManager->AddHandler("TGridCollection", "alice", 
				"AliXMLCollection", "ANALYSISalice", "AliXMLCollection(const char*)");
      pluginHandler = pluginManager->FindHandler("TGridCollection", "alice");
    }
    gSystem->Load("libANALYSIS");
    if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
      collection = (TGridCollection*)pluginHandler->ExecPlugin(1,fileNameStr.Data());
    }
    else {
      fIsValid = kFALSE;
      return;
    }
    collection->Reset();
    Bool_t elistsExist = kFALSE;
    TEntryList *elist = new TEntryList();
    while (collection->Next()) {
      fChain->Add(collection->GetTURL(""));
      TEntryList *list = (TEntryList *)collection->GetEntryList("");
      if (list) {
	list->SetTreeName("RAW");
	list->SetFileName(collection->GetTURL(""));
	elist->Add(list);
	elistsExist = kTRUE;
      }
    }
    if (elistsExist) {
      fChain->SetEntryList(elist,"ne");
    }
    else {
      Info("AliRawReaderChain", "no entry lists found in %s. Using all entries", fileNameStr.Data());
      delete elist;
    }
  }
  else if (fileNameStr.EndsWith(".root")) {

    TDirectory* dir = gDirectory;
    TFile *listFile = TFile::Open(fileNameStr.Data());
    dir->cd();
    if (!listFile || !listFile->IsOpen()) {
      Error("AliRawReaderChain", "could not open file %s", fileNameStr.Data());
      fIsValid = kFALSE;
      return;
    }

    TEntryList *elist = NULL;
    TKey *key = NULL;
    TIter nextkey(listFile->GetListOfKeys());
    while ((key=(TKey*)nextkey())){
      if (strcmp("TEntryList", key->GetClassName())==0){
        elist = (TEntryList*)key->ReadObj();
      }
    }
    if (!elist) {
      Error("AliRawReaderChain", "no TEntryList found in %s", fileNameStr.Data());
      fIsValid = kFALSE;
      return;
    }

    TEntryList *templist = NULL;
    TList *elists = elist->GetLists();
    TIter next(elists);
    while((templist = (TEntryList*)next())){
      Info("AliRawReaderChain", "%s added to the chain", templist->GetFileName());
      fChain->Add(templist->GetFileName());
    }
    fChain->SetEntryList(elist,"ne");
  }
  else {

    TFileCollection collection("RAW",
			       "Collection with raw-data files",
			       fileNameStr.Data());

    if (!fChain->AddFileInfoList((TCollection*)(collection.GetList()))) {
      Error("AliRawReaderChain","Bad file list in collection, the chain is empty");
      fIsValid = kFALSE;
      return;
    }
  }

  fChain->SetBranchStatus("*",1);
  fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
}

AliRawReaderChain::AliRawReaderChain(TFileCollection *collection) :
  AliRawReaderRoot(),
  fChain(NULL)
{
// create raw-reader objects which takes as an input a root chain
// from a root file collection

  fChain = new TChain("RAW");
  if (!fChain->AddFileInfoList((TCollection*)(collection->GetList()))) {
    Error("AliRawReaderChain","Bad file list in collection, the chain is empty");
    fIsValid = kFALSE;
    return;
  }

  fChain->SetBranchStatus("*",1);
  fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
}

AliRawReaderChain::AliRawReaderChain(TChain *chain) :
  AliRawReaderRoot(),
  fChain(chain)
{
// create raw-reader objects which takes as an input a root chain
// from a root file collection

  if (!fChain) {
    fIsValid = kFALSE;
    return;
  }

  fChain->SetBranchStatus("*",1);
  fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
}

AliRawReaderChain::AliRawReaderChain(TEntryList *elist) :
  AliRawReaderRoot(),
  fChain(NULL)
{
// create raw-reader objects which takes as an input a root chain
// from a root file collection

  if (!elist) {
    fIsValid = kFALSE;
    return;
  }

  fChain = new TChain("RAW");

  TEntryList *templist = NULL;
  TList *elists = elist->GetLists();
  TIter next(elists);
  while((templist = (TEntryList*)next())){
    fChain->Add(templist->GetFileName());
  }
  fChain->SetEntryList(elist,"ne");

  fChain->SetBranchStatus("*",1);
  fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
}

AliRawReaderChain::AliRawReaderChain(Int_t runNumber) :
  AliRawReaderRoot(),
  fChain(NULL)
{
// create raw-reader objects which takes as an input a root chain
// with the raw-data files for a given run
// It queries alien FC in order to do that and therefore
// it needs alien API to be enabled

  if (runNumber <= 0) {
    Error("AliRawReaderChain","Bad run number:%d",runNumber);
    fIsValid = kFALSE;
  }

  if (!gGrid) TGrid::Connect("alien://");
  if (!gGrid) {
    fIsValid = kFALSE;
    return;
  }

  TGridResult *res = gGrid->Query("/alice/data",Form("%09d/raw/*%09d*0.root",runNumber,runNumber));
  Int_t nFiles = res->GetEntries();
  if (!nFiles) {
    Error("AliRawReaderChain","No raw-data files found for run %d",runNumber);
    fIsValid = kFALSE;
    delete res;
    return;
  }

  fChain = new TChain("RAW");
  for (Int_t i = 0; i < nFiles; i++) {
    TString filename = res->GetKey(i, "turl");
    if(filename == "") continue;
    fChain->Add(filename.Data());
  }
  delete res;

  fChain->SetBranchStatus("*",1);
  fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
}


AliRawReaderChain::AliRawReaderChain(const AliRawReaderChain& rawReader) :
  AliRawReaderRoot(rawReader),
  fChain(rawReader.fChain)
{
// copy constructor
}

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

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

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

  if (fChain) {
    delete fChain;
    fChain = NULL;
  }
}

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

  if (!fChain || !fChain->GetListOfFiles()->GetEntriesFast()) return kFALSE;

  do {
    delete fEvent;
    fEvent = NULL;
    fEventHeader = NULL;
    Long64_t treeEntry = fChain->LoadTree(fEventIndex+1);
    if (!fBranch)
      return kFALSE;
    if (fBranch->GetEntry(treeEntry) <= 0)
      return kFALSE;
    fEventHeader = fEvent->GetHeader();
    fEventIndex++;
  } while (!IsEventSelected());
  fEventNumber++;
  return Reset();
}

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

  fEventIndex = -1;
  delete fEvent;
  fEvent = NULL;
  fEventHeader = NULL;
  fEventNumber = -1;
  return Reset();
}

Bool_t  AliRawReaderChain::GotoEvent(Int_t event)
{
  // go to a particular event
  // Uses the absolute event index inside the
  // chain with raw data

  if (!fChain || !fChain->GetListOfFiles()->GetEntriesFast()) return kFALSE;

  delete fEvent;
  fEvent = NULL;
  fEventHeader = NULL;
  Long64_t treeEntry = fChain->LoadTree(event);
   if (!fBranch)
    return kFALSE;
  if (fBranch->GetEntry(treeEntry) <= 0)
    return kFALSE;
  fEventHeader = fEvent->GetHeader();
  fEventIndex = event;
  fEventNumber++;
  return Reset();
}

Int_t AliRawReaderChain::GetNumberOfEvents() const
{
  // Get the total number of events in the chain
  // of raw-data files

  if (!fChain) return -1;

  return fChain->GetEntries();
}
Commit	Line	Data
6923e953	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	///
	18	/// This is a class for reading raw data from a root chain.
	19	/// There are two constructors available - one from a text file containing the
	20	/// list of root raw-data files to be processed and one directly from
	21	/// TFileCollection.
	22	///
	23	/// cvetan.cheshkov@cern.ch 29/07/2008
	24	///
	25	///////////////////////////////////////////////////////////////////////////////
	26
	27	#include <TChain.h>
	28	#include <TFileCollection.h>
3d456d99	29	#include <TEntryList.h>
	30	#include "TGridCollection.h"
	31	#include <TPluginManager.h>
	32	#include <TROOT.h>
	33	#include <TSystem.h>
	34	#include <TFile.h>
	35	#include <TKey.h>
bb0edcaf	36	#include <TGrid.h>
bb0edcaf	37	#include <TGridResult.h>
6923e953	38
6923e953	39	#include "AliRawReaderChain.h"
33314186	40	#include "AliRawVEvent.h"
6923e953	41
	42	ClassImp(AliRawReaderChain)
	43
	44	AliRawReaderChain::AliRawReaderChain() :
	45	AliRawReaderRoot(),
	46	fChain(NULL)
	47	{
	48	// default constructor
	49	}
	50
3d456d99	51	AliRawReaderChain::AliRawReaderChain(const char* fileName) :
6923e953	52	AliRawReaderRoot(),
	53	fChain(NULL)
	54	{
	55	// create raw-reader objects which takes as an input a root chain
3d456d99	56	// either from the file list found in 'fileName' (IsCollection = true)
	57	// or from entry list found in 'filename' (IsCollection = false)
	58	// The entry-list syntax follows root convetion: filename.root/listname
6923e953	59
acce5036	60	fChain = new TChain("RAW");
3d456d99	61
	62	TString fileNameStr = fileName;
	63	if (fileNameStr.EndsWith(".xml")) {
	64
	65	TGridCollection *collection = NULL;
	66	TPluginManager* pluginManager = gROOT->GetPluginManager();
	67	TPluginHandler* pluginHandler = pluginManager->FindHandler("TGridCollection", "alice");
	68	if (!pluginHandler) {
	69	pluginManager->AddHandler("TGridCollection", "alice",
	70	"AliXMLCollection", "ANALYSISalice", "AliXMLCollection(const char*)");
	71	pluginHandler = pluginManager->FindHandler("TGridCollection", "alice");
	72	}
	73	gSystem->Load("libANALYSIS");
	74	if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
	75	collection = (TGridCollection*)pluginHandler->ExecPlugin(1,fileNameStr.Data());
	76	}
	77	else {
	78	fIsValid = kFALSE;
	79	return;
	80	}
	81	collection->Reset();
	82	Bool_t elistsExist = kFALSE;
	83	TEntryList *elist = new TEntryList();
	84	while (collection->Next()) {
	85	fChain->Add(collection->GetTURL(""));
	86	TEntryList list = (TEntryList )collection->GetEntryList("");
	87	if (list) {
	88	list->SetTreeName("RAW");
	89	list->SetFileName(collection->GetTURL(""));
	90	elist->Add(list);
	91	elistsExist = kTRUE;
	92	}
	93	}
	94	if (elistsExist) {
	95	fChain->SetEntryList(elist,"ne");
	96	}
	97	else {
	98	Info("AliRawReaderChain", "no entry lists found in %s. Using all entries", fileNameStr.Data());
	99	delete elist;
	100	}
	101	}
	102	else if (fileNameStr.EndsWith(".root")) {
	103
	104	TDirectory* dir = gDirectory;
	105	TFile *listFile = TFile::Open(fileNameStr.Data());
	106	dir->cd();
	107	if (!listFile \|\| !listFile->IsOpen()) {
	108	Error("AliRawReaderChain", "could not open file %s", fileNameStr.Data());
	109	fIsValid = kFALSE;
	110	return;
	111	}
	112
	113	TEntryList *elist = NULL;
	114	TKey *key = NULL;
	115	TIter nextkey(listFile->GetListOfKeys());
	116	while ((key=(TKey*)nextkey())){
	117	if (strcmp("TEntryList", key->GetClassName())==0){
	118	elist = (TEntryList*)key->ReadObj();
	119	}
	120	}
	121	if (!elist) {
	122	Error("AliRawReaderChain", "no TEntryList found in %s", fileNameStr.Data());
	123	fIsValid = kFALSE;
	124	return;
125	}
126
127	TEntryList *templist = NULL;
128	TList *elists = elist->GetLists();
129	TIter next(elists);
130	while((templist = (TEntryList*)next())){
131	Info("AliRawReaderChain", "%s added to the chain", templist->GetFileName());
132	fChain->Add(templist->GetFileName());
133	}
134	fChain->SetEntryList(elist,"ne");
135	}
136	else {
137
138	TFileCollection collection("RAW",
139	"Collection with raw-data files",
140	fileNameStr.Data());
141
142	if (!fChain->AddFileInfoList((TCollection*)(collection.GetList()))) {
143	Error("AliRawReaderChain","Bad file list in collection, the chain is empty");
144	fIsValid = kFALSE;
145	return;
146	}
6923e953	147	}
6923e953	148
636c1780	149	fChain->SetBranchStatus("*",1);
4ebdfbcc	150	fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
6923e953	151	}
	152
	153	AliRawReaderChain::AliRawReaderChain(TFileCollection *collection) :
	154	AliRawReaderRoot(),
	155	fChain(NULL)
	156	{
	157	// create raw-reader objects which takes as an input a root chain
	158	// from a root file collection
	159
acce5036	160	fChain = new TChain("RAW");
6923e953	161	if (!fChain->AddFileInfoList((TCollection*)(collection->GetList()))) {
6923e953	162	Error("AliRawReaderChain","Bad file list in collection, the chain is empty");
a97af23d	163	fIsValid = kFALSE;
6923e953	164	return;
	165	}
	166
636c1780	167	fChain->SetBranchStatus("*",1);
4ebdfbcc	168	fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
636c1780	169	}
	170
	171	AliRawReaderChain::AliRawReaderChain(TChain *chain) :
	172	AliRawReaderRoot(),
	173	fChain(chain)
	174	{
	175	// create raw-reader objects which takes as an input a root chain
	176	// from a root file collection
	177
68d8e599	178	if (!fChain) {
	179	fIsValid = kFALSE;
	180	return;
	181	}
a97af23d	182
636c1780	183	fChain->SetBranchStatus("*",1);
4ebdfbcc	184	fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
6923e953	185	}
6923e953	186
3d456d99	187	AliRawReaderChain::AliRawReaderChain(TEntryList *elist) :
	188	AliRawReaderRoot(),
	189	fChain(NULL)
	190	{
	191	// create raw-reader objects which takes as an input a root chain
	192	// from a root file collection
	193
68d8e599	194	if (!elist) {
	195	fIsValid = kFALSE;
	196	return;
	197	}
3d456d99	198
	199	fChain = new TChain("RAW");
	200
	201	TEntryList *templist = NULL;
	202	TList *elists = elist->GetLists();
	203	TIter next(elists);
	204	while((templist = (TEntryList*)next())){
	205	fChain->Add(templist->GetFileName());
	206	}
	207	fChain->SetEntryList(elist,"ne");
	208
	209	fChain->SetBranchStatus("*",1);
	210	fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
	211	}
	212
bb0edcaf	213	AliRawReaderChain::AliRawReaderChain(Int_t runNumber) :
	214	AliRawReaderRoot(),
	215	fChain(NULL)
	216	{
	217	// create raw-reader objects which takes as an input a root chain
	218	// with the raw-data files for a given run
	219	// It queries alien FC in order to do that and therefore
	220	// it needs alien API to be enabled
	221
	222	if (runNumber <= 0) {
	223	Error("AliRawReaderChain","Bad run number:%d",runNumber);
	224	fIsValid = kFALSE;
	225	}
	226
	227	if (!gGrid) TGrid::Connect("alien://");
	228	if (!gGrid) {
	229	fIsValid = kFALSE;
	230	return;
	231	}
	232
	233	TGridResult res = gGrid->Query("/alice/data",Form("%09d/raw/%09d*0.root",runNumber,runNumber));
	234	Int_t nFiles = res->GetEntries();
	235	if (!nFiles) {
	236	Error("AliRawReaderChain","No raw-data files found for run %d",runNumber);
	237	fIsValid = kFALSE;
	238	delete res;
	239	return;
	240	}
	241
	242	fChain = new TChain("RAW");
	243	for (Int_t i = 0; i < nFiles; i++) {
	244	TString filename = res->GetKey(i, "turl");
	245	if(filename == "") continue;
	246	fChain->Add(filename.Data());
	247	}
	248	delete res;
	249
	250	fChain->SetBranchStatus("*",1);
	251	fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
	252	}
	253
	254
6923e953	255	AliRawReaderChain::AliRawReaderChain(const AliRawReaderChain& rawReader) :
	256	AliRawReaderRoot(rawReader),
	257	fChain(rawReader.fChain)
	258	{
	259	// copy constructor
	260	}
	261
	262	AliRawReaderChain& AliRawReaderChain::operator = (const AliRawReaderChain&
	263	rawReader)
	264	{
	265	// assignment operator
	266
	267	this->~AliRawReaderChain();
	268	new(this) AliRawReaderChain(rawReader);
	269	return *this;
	270	}
	271
	272	AliRawReaderChain::~AliRawReaderChain()
	273	{
	274	// delete objects and close root file
	275
	276	if (fChain) {
	277	delete fChain;
	278	fChain = NULL;
	279	}
	280	}
	281
	282	Bool_t AliRawReaderChain::NextEvent()
	283	{
	284	// go to the next event in the root file
	285
	286	if (!fChain \|\| !fChain->GetListOfFiles()->GetEntriesFast()) return kFALSE;
	287
	288	do {
	289	delete fEvent;
33314186	290	fEvent = NULL;
33314186	291	fEventHeader = NULL;
4ebdfbcc	292	Long64_t treeEntry = fChain->LoadTree(fEventIndex+1);
4ebdfbcc	293	if (!fBranch)
636c1780	294	return kFALSE;
4ebdfbcc	295	if (fBranch->GetEntry(treeEntry) <= 0)
6923e953	296	return kFALSE;
33314186	297	fEventHeader = fEvent->GetHeader();
6923e953	298	fEventIndex++;
	299	} while (!IsEventSelected());
	300	fEventNumber++;
	301	return Reset();
	302	}
	303
	304	Bool_t AliRawReaderChain::RewindEvents()
	305	{
	306	// go back to the beginning of the root file
	307
	308	fEventIndex = -1;
	309	delete fEvent;
33314186	310	fEvent = NULL;
33314186	311	fEventHeader = NULL;
6923e953	312	fEventNumber = -1;
	313	return Reset();
	314	}
636c1780	315
	316	Bool_t AliRawReaderChain::GotoEvent(Int_t event)
	317	{
	318	// go to a particular event
	319	// Uses the absolute event index inside the
	320	// chain with raw data
	321
	322	if (!fChain \|\| !fChain->GetListOfFiles()->GetEntriesFast()) return kFALSE;
	323
	324	delete fEvent;
33314186	325	fEvent = NULL;
33314186	326	fEventHeader = NULL;
4ebdfbcc	327	Long64_t treeEntry = fChain->LoadTree(event);
4ebdfbcc	328	if (!fBranch)
636c1780	329	return kFALSE;
4ebdfbcc	330	if (fBranch->GetEntry(treeEntry) <= 0)
636c1780	331	return kFALSE;
33314186	332	fEventHeader = fEvent->GetHeader();
636c1780	333	fEventIndex = event;
	334	fEventNumber++;
	335	return Reset();
	336	}
25e82ff5	337
	338	Int_t AliRawReaderChain::GetNumberOfEvents() const
	339	{
	340	// Get the total number of events in the chain
	341	// of raw-data files
	342
	343	if (!fChain) return -1;
	344
	345	return fChain->GetEntries();
	346	}