[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;

  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;

  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
a97af23d	178	if (!fChain) fIsValid = kFALSE;
a97af23d	179
636c1780	180	fChain->SetBranchStatus("*",1);
4ebdfbcc	181	fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
6923e953	182	}
6923e953	183
3d456d99	184	AliRawReaderChain::AliRawReaderChain(TEntryList *elist) :
	185	AliRawReaderRoot(),
	186	fChain(NULL)
	187	{
	188	// create raw-reader objects which takes as an input a root chain
	189	// from a root file collection
	190
	191	if (!elist) fIsValid = kFALSE;
	192
	193	fChain = new TChain("RAW");
	194
	195	TEntryList *templist = NULL;
	196	TList *elists = elist->GetLists();
	197	TIter next(elists);
	198	while((templist = (TEntryList*)next())){
	199	fChain->Add(templist->GetFileName());
	200	}
	201	fChain->SetEntryList(elist,"ne");
	202
	203	fChain->SetBranchStatus("*",1);
	204	fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
	205	}
	206
bb0edcaf	207	AliRawReaderChain::AliRawReaderChain(Int_t runNumber) :
	208	AliRawReaderRoot(),
	209	fChain(NULL)
	210	{
	211	// create raw-reader objects which takes as an input a root chain
	212	// with the raw-data files for a given run
	213	// It queries alien FC in order to do that and therefore
	214	// it needs alien API to be enabled
	215
	216	if (runNumber <= 0) {
	217	Error("AliRawReaderChain","Bad run number:%d",runNumber);
	218	fIsValid = kFALSE;
	219	}
	220
	221	if (!gGrid) TGrid::Connect("alien://");
	222	if (!gGrid) {
	223	fIsValid = kFALSE;
	224	return;
	225	}
	226
	227	TGridResult res = gGrid->Query("/alice/data",Form("%09d/raw/%09d*0.root",runNumber,runNumber));
	228	Int_t nFiles = res->GetEntries();
	229	if (!nFiles) {
	230	Error("AliRawReaderChain","No raw-data files found for run %d",runNumber);
	231	fIsValid = kFALSE;
	232	delete res;
	233	return;
	234	}
	235
	236	fChain = new TChain("RAW");
	237	for (Int_t i = 0; i < nFiles; i++) {
	238	TString filename = res->GetKey(i, "turl");
	239	if(filename == "") continue;
	240	fChain->Add(filename.Data());
	241	}
	242	delete res;
	243
	244	fChain->SetBranchStatus("*",1);
	245	fChain->SetBranchAddress("rawevent",&fEvent,&fBranch);
	246	}
	247
	248
6923e953	249	AliRawReaderChain::AliRawReaderChain(const AliRawReaderChain& rawReader) :
	250	AliRawReaderRoot(rawReader),
	251	fChain(rawReader.fChain)
	252	{
	253	// copy constructor
	254	}
	255
	256	AliRawReaderChain& AliRawReaderChain::operator = (const AliRawReaderChain&
	257	rawReader)
	258	{
	259	// assignment operator
	260
	261	this->~AliRawReaderChain();
	262	new(this) AliRawReaderChain(rawReader);
	263	return *this;
	264	}
	265
	266	AliRawReaderChain::~AliRawReaderChain()
	267	{
	268	// delete objects and close root file
	269
	270	if (fChain) {
	271	delete fChain;
	272	fChain = NULL;
	273	}
	274	}
	275
	276	Bool_t AliRawReaderChain::NextEvent()
	277	{
	278	// go to the next event in the root file
	279
	280	if (!fChain \|\| !fChain->GetListOfFiles()->GetEntriesFast()) return kFALSE;
	281
	282	do {
	283	delete fEvent;
33314186	284	fEvent = NULL;
33314186	285	fEventHeader = NULL;
4ebdfbcc	286	Long64_t treeEntry = fChain->LoadTree(fEventIndex+1);
4ebdfbcc	287	if (!fBranch)
636c1780	288	return kFALSE;
4ebdfbcc	289	if (fBranch->GetEntry(treeEntry) <= 0)
6923e953	290	return kFALSE;
33314186	291	fEventHeader = fEvent->GetHeader();
6923e953	292	fEventIndex++;
	293	} while (!IsEventSelected());
	294	fEventNumber++;
	295	return Reset();
	296	}
	297
	298	Bool_t AliRawReaderChain::RewindEvents()
	299	{
	300	// go back to the beginning of the root file
	301
	302	fEventIndex = -1;
	303	delete fEvent;
33314186	304	fEvent = NULL;
33314186	305	fEventHeader = NULL;
6923e953	306	fEventNumber = -1;
	307	return Reset();
	308	}
636c1780	309
	310	Bool_t AliRawReaderChain::GotoEvent(Int_t event)
	311	{
	312	// go to a particular event
	313	// Uses the absolute event index inside the
	314	// chain with raw data
	315
	316	if (!fChain \|\| !fChain->GetListOfFiles()->GetEntriesFast()) return kFALSE;
	317
	318	delete fEvent;
33314186	319	fEvent = NULL;
33314186	320	fEventHeader = NULL;
4ebdfbcc	321	Long64_t treeEntry = fChain->LoadTree(event);
4ebdfbcc	322	if (!fBranch)
636c1780	323	return kFALSE;
4ebdfbcc	324	if (fBranch->GetEntry(treeEntry) <= 0)
636c1780	325	return kFALSE;
33314186	326	fEventHeader = fEvent->GetHeader();
636c1780	327	fEventIndex = event;
	328	fEventNumber++;
	329	return Reset();
	330	}
25e82ff5	331
	332	Int_t AliRawReaderChain::GetNumberOfEvents() const
	333	{
	334	// Get the total number of events in the chain
	335	// of raw-data files
	336
	337	if (!fChain) return -1;
	338
	339	return fChain->GetEntries();
	340	}