[u/mrichter/AliRoot.git] / PWGLF / FORWARD / analysis2 / AliMCAuxHandler.cxx

#include "AliMCAuxHandler.h"
#include "AliAnalysisManager.h"
#include <TError.h>
#include <AliLog.h>
#include <TFile.h>
#include <TClonesArray.h>
#include <TROOT.h>
#include <TSystem.h>
#include <AliStack.h>
#include <AliMCEvent.h>

ClassImp(AliMCAuxHandler)
#if 0 // For Emacs - do not remove
;
#endif

//____________________________________________________________________
AliMCAuxHandler::AliMCAuxHandler(const char* name,
				       const char* what,
				       AliMCEventHandler* parent)
  : AliMCEventHandler(name, what),
    fParent(parent), 
    fFile(0),
    fTree(0),
    fDir(0),
    fArray(0),
    fNEvents(0), 
    fNEventsPerFile(0),
    fNEventsInContainer(0),
    fEvent(0), 
    fFileNumber(0),
    fTreeName(""),
    fFileBase("")
{
  // Constructor 
  // 
  // Parameters: 
  //   name The name 
}

//____________________________________________________________________
TString*
AliMCAuxHandler::GetParentPath() const
{
  if (!fParent) { 
    AliWarning("No parent");
    return 0;
  }
  return fParent->GetInputPath();
}

//____________________________________________________________________
Bool_t
AliMCAuxHandler::Init(Option_t* opt)
{
  // Initialize the input
  // 
  // @param opt Options 
  // 
  // @return true on success 
  AliDebugF(10,"AliMCAuxHandler::Init(\"%s\")", opt);
  // Info("","AliMCAuxHandler::Init(\"%s\") - detector: %s, class: %s", 
  //      opt, GetName(), GetTitle());

  TString option(opt);
  if (option.EqualTo("proof") || 
      option.EqualTo("local") || 
      option.EqualTo("lite")) return true;

  TString t = "Tree";
  TString b = "";
  TClass* cl = gROOT->GetClass(GetTitle());
  if (cl) { 
    if (cl->InheritsFrom("AliHit")) { 
      t += "H";
      b =  "Hits";
    }
    else if (cl->InheritsFrom("AliSDigit")) {
      t += "S";
      b =  "SDigits";
    }
    else if (cl->InheritsFrom("AliDigit")) {
      t += "D";
      b =  "Digits";
    }
    else 
      t = "";
  }
  else {
    AliWarningF("Couldn't get the class description of %s", GetTitle());
    AliWarning("The list of loaded libraries is");
    gSystem->ListLibraries("");
    return false;
  }
      
  // Info("Init", "Tree-name: %s, file-base: %s", t.Data(), b.Data());
  if (!t.IsNull()) fTreeName = t;
  if (!b.IsNull()) fFileBase = b;


  fArray = new TClonesArray(GetTitle());
  
  TTree* treeE = fParent->GetTree();
  if (!treeE) { 
    AliError("Parent does not have an events tree");
    return false;
  }

  // Get number of events in this directory 
  fNEventsPerFile = -1;
  fNEvents        = treeE->GetEntries();
  fEvent          = 0;
  fFileNumber     = 0;

  if (!OpenFile(fFileNumber)) return false;

  return true;
}
//____________________________________________________________________
Bool_t
AliMCAuxHandler::BeginEvent(Long64_t entry)
{
  // Called at the beginning of an event 
  // 
  // @param entry Entry in tree 
  // 
  // @return true on success
  AliDebugF(10,"AliMCAuxHandler::BeginEvent(%lld)", entry);
  // Info("","AliMCAuxHandler::BeginEvent(%lld)", entry);

  if (entry == -1) 
    fEvent++;
  else 
    fEvent = entry;

  if (fEvent >= fNEvents) { 
    AliWarningF("Event number out of range %d/%d", fEvent, fNEvents);
    return false;
  }

  if (fNEventsPerFile < 0) {
    TTree* treeK = fParent->TreeK();
    if (!treeK) { 
      AliError("Parent does not have a kinematics tree");
      return false;
    }
  
    TFile* fileK = treeK->GetCurrentFile();
    if (!fileK) { 
      AliError("Kinematics tree has no associated file");
      return false;
    }
    // Get the number of events per file 
    fNEventsPerFile = fileK->GetNkeys() - fileK->GetNProcessIDs();
  }
  return LoadEvent(fEvent);
}
//____________________________________________________________________
Bool_t
AliMCAuxHandler::Notify(const char* path)
{
  // Called when the input file is changed 
  // 
  // @param path New path 
  //
  // @return true on success
  AliDebugF(10,"AliMCAuxHandler::Notify(\"%s\")", path);
  // Info("","AliMCAuxHandler::Notify(\"%s\")", path);
  return true;
}
//____________________________________________________________________
Bool_t
AliMCAuxHandler::FinishEvent()
{
  // Called at the end of an event 
  // 
  // @return true on success
  // AliDebug(10,"AliMCAuxHandler::FinishEvent()");
  return true;
}
//____________________________________________________________________
Bool_t
AliMCAuxHandler::Terminate()
{
  // Called at the end of a job 
  // 
  // @return true on success 
  AliDebug(10,"AliMCAuxHandler::Terminate()");
  return true;
}
//____________________________________________________________________
Bool_t
AliMCAuxHandler::TerminateIO()
{
  // Called at the end of a sub-job
  // 
  // @return true on success
  AliDebug(10,"AliMCAuxHandler::TerminateIO()");
  return true;
}

//____________________________________________________________________
void
AliMCAuxHandler::ResetIO()
{
  // Reset the I/O
  // 
  //
  AliDebug(10,"AliMCAuxHandler::ResetIO()");

  TString* path = GetParentPath();
  AliDebugF(10,"Got parent path %s", path ? path->Data() : "null");
  // Info("ResetIO","Got parent path %s", path ? path->Data() : "null");

  if (fFile) { 
    delete fFile;
    fFile = 0;
  }
}
//____________________________________________________________________
Bool_t
AliMCAuxHandler::OpenFile(Int_t fileNo)
{
  TString* path = GetParentPath();
  AliDebugF(10,"Got parent path %s", path ? path->Data() : "null");
  // Info("OpenFile","Got parent path %s", path ? path->Data() : "null");
  if (!path) return false;

  TString ext("");
  if (fileNo > 0) ext = TString::Format("%d", fileNo);

  TString w(GetTitle());
  if (w.EndsWith("s")) w.Chop();
    
  TString fn = TString::Format("%s%s.%s%s.root", 
			       path->Data(), GetName(), 
			       fFileBase.Data(), ext.Data());
  AliDebugF(10,"Opening %s", fn.Data());
  // Info("OpenFile", "Opening %s", fn.Data());
  fFile = TFile::Open(fn, "READ");
  if (!fFile) { 
    AliErrorF("Failed to open %s", fn.Data());
    return false;
  }

  return true;
}

//____________________________________________________________________
Bool_t
AliMCAuxHandler::LoadEvent(Int_t iev)
{
  // Load an event 
  // 
  // @param iev Event number 
  // 
  // @return true on success 
  AliDebugF(10,"AliMCAuxHandler::LoadEvent(%d)", iev);
  // Info("","AliMCAuxHandler::LoadEvent(%d)", iev);

  Int_t iNew = iev / fNEventsPerFile;
  if (iNew != fFileNumber) { 
    fFileNumber = iNew;
    if (!OpenFile(fFileNumber)) return false;
  }
  if (!fFile) return false;

  TString folder = TString::Format("Event%d", iev);
  fFile->GetObject(folder, fDir);
  if (!fDir) { 
    AliWarningF("Folder %s not found in file", folder.Data());
    return false;
  }

  fDir->GetObject(fTreeName, fTree);
  if (!fTree) { 
    AliWarningF("Folder %s does not contain the %s tree %s", 
		folder.Data(), GetTitle(), fTreeName.Data());
    return false;
  }

  fTree->SetBranchAddress(GetName(), &fArray);
  return true;
}

//____________________________________________________________________
Int_t
AliMCAuxHandler::GetNEntry() const
{
  if (!fTree) return 0;
  return fTree->GetEntries();
}

//____________________________________________________________________
TClonesArray*
AliMCAuxHandler::GetEntryArray(Int_t entry)
{
  if (!fTree) return 0;
  if (!fArray) return 0;
  if (entry < 0 || entry >= fTree->GetEntries()) { 
    AliErrorF("Entry # %d out of bounds [0,%lld]", 
	      entry, fTree->GetEntries());
    return 0;
  }
  fArray->Clear();
  
  if (fTree->GetEntry(entry) <= 0) return 0;

  return fArray;
}
  

//____________________________________________________________________
AliMCAuxHandler*
AliMCAuxHandler::Create(const char* name, const char* what)
{
  AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) { 
    ::Error("AliMCAuxHandler::Create", "No analysis manager");
    return 0;
  }
  
  AliVEventHandler* vmc = mgr->GetMCtruthEventHandler();
  if (!vmc) { 
    ::Error("AliMCAuxHandler::Create", "No MC truth handler");
    return 0;
  }
  
  AliMCEventHandler* mc = dynamic_cast<AliMCEventHandler*>(vmc);
  if (!mc) { 
    ::Error("AliMCAuxHandler::Create", 
	    "MC truth handler not a AliMCEventHandler, but %s", 
	    vmc->ClassName());
    return 0;
  }

  AliMCAuxHandler* ret = new AliMCAuxHandler(name, what, mc);
  mc->AddSubsidiaryHandler(ret);
  
  return ret;
}

//____________________________________________________________________
TClonesArray*
AliMCAuxHandler::GetParticleArray(AliMCAuxHandler* handler, 
				     Int_t particle)
{
  if (!handler) { 
    ::Error("AliMCAuxHandler::GetArray", "No handler passed");
    return 0;
  }

  AliMCEventHandler* mc = handler->GetParent();
  if (!mc) {
    ::Error("AliMCAuxHandler::GetArray", "Handler has no parent");
    return 0;
  }
  
  AliMCEvent* event = mc->MCEvent();
  if (!event) { 
    ::Error("AliMCAuxHandler::GetArray", "No MC event");
    return 0;
  }
  
  AliStack* stack = event->Stack();
  if (!stack) { 
    ::Error("AliMCAuxHandler::GetArray", "Event has no stack");
    return 0;
  }

  handler->GetArray()->Clear();
  TTree* tree = handler->GetTree();
  if (!tree) {
    ::Error("AliMCAuxHandler::GetArray", "Handler has no tree");
    return 0;
  }
    
  Int_t treeIdx = stack->TreeKEntry(particle);
  if (treeIdx < 0 || treeIdx >= tree->GetEntries()) { 
    ::Error("AliMCAuxHandler::GetArray", 
	    "Index %d of %d out of bounds [0,%lld]", treeIdx, particle, 
	    tree->GetEntries()-1);
    return 0;
  }
  
  tree->GetEntry(treeIdx);
  
  return handler->GetArray();
}

  
//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
2e658fb9	1	#include "AliMCAuxHandler.h"
	2	#include "AliAnalysisManager.h"
	3	#include <TError.h>
	4	#include <AliLog.h>
	5	#include <TFile.h>
	6	#include <TClonesArray.h>
	7	#include <TROOT.h>
0b7de667	8	#include <TSystem.h>
2e658fb9	9	#include <AliStack.h>
	10	#include <AliMCEvent.h>
	11
	12	ClassImp(AliMCAuxHandler)
	13	#if 0 // For Emacs - do not remove
	14	;
	15	#endif
	16
	17	//____________________________________________________________________
	18	AliMCAuxHandler::AliMCAuxHandler(const char* name,
	19	const char* what,
	20	AliMCEventHandler* parent)
	21	: AliMCEventHandler(name, what),
	22	fParent(parent),
	23	fFile(0),
	24	fTree(0),
	25	fDir(0),
	26	fArray(0),
	27	fNEvents(0),
	28	fNEventsPerFile(0),
	29	fNEventsInContainer(0),
	30	fEvent(0),
	31	fFileNumber(0),
	32	fTreeName(""),
	33	fFileBase("")
	34	{
	35	// Constructor
	36	//
	37	// Parameters:
	38	// name The name
	39	}
	40
	41	//____________________________________________________________________
	42	TString*
	43	AliMCAuxHandler::GetParentPath() const
	44	{
	45	if (!fParent) {
	46	AliWarning("No parent");
	47	return 0;
	48	}
	49	return fParent->GetInputPath();
	50	}
	51
	52	//____________________________________________________________________
	53	Bool_t
	54	AliMCAuxHandler::Init(Option_t* opt)
	55	{
	56	// Initialize the input
	57	//
	58	// @param opt Options
	59	//
	60	// @return true on success
	61	AliDebugF(10,"AliMCAuxHandler::Init(\"%s\")", opt);
0b7de667	62	// Info("","AliMCAuxHandler::Init(\"%s\") - detector: %s, class: %s",
0b7de667	63	// opt, GetName(), GetTitle());
2e658fb9	64
2e658fb9	65	TString option(opt);
0b7de667	66	if (option.EqualTo("proof") \|\|
	67	option.EqualTo("local") \|\|
	68	option.EqualTo("lite")) return true;
2e658fb9	69
	70	TString t = "Tree";
	71	TString b = "";
	72	TClass* cl = gROOT->GetClass(GetTitle());
	73	if (cl) {
	74	if (cl->InheritsFrom("AliHit")) {
	75	t += "H";
	76	b = "Hits";
	77	}
	78	else if (cl->InheritsFrom("AliSDigit")) {
	79	t += "S";
	80	b = "SDigits";
	81	}
	82	else if (cl->InheritsFrom("AliDigit")) {
	83	t += "D";
	84	b = "Digits";
	85	}
	86	else
	87	t = "";
	88	}
0b7de667	89	else {
	90	AliWarningF("Couldn't get the class description of %s", GetTitle());
	91	AliWarning("The list of loaded libraries is");
	92	gSystem->ListLibraries("");
	93	return false;
	94	}
	95
	96	// Info("Init", "Tree-name: %s, file-base: %s", t.Data(), b.Data());
2e658fb9	97	if (!t.IsNull()) fTreeName = t;
	98	if (!b.IsNull()) fFileBase = b;
	99
	100
	101	fArray = new TClonesArray(GetTitle());
	102
	103	TTree* treeE = fParent->GetTree();
	104	if (!treeE) {
	105	AliError("Parent does not have an events tree");
	106	return false;
	107	}
	108
	109	// Get number of events in this directory
	110	fNEventsPerFile = -1;
	111	fNEvents = treeE->GetEntries();
	112	fEvent = 0;
	113	fFileNumber = 0;
	114
	115	if (!OpenFile(fFileNumber)) return false;
	116
	117	return true;
	118	}
	119	//____________________________________________________________________
	120	Bool_t
	121	AliMCAuxHandler::BeginEvent(Long64_t entry)
	122	{
	123	// Called at the beginning of an event
	124	//
	125	// @param entry Entry in tree
	126	//
	127	// @return true on success
	128	AliDebugF(10,"AliMCAuxHandler::BeginEvent(%lld)", entry);
0b7de667	129	// Info("","AliMCAuxHandler::BeginEvent(%lld)", entry);
2e658fb9	130
	131	if (entry == -1)
	132	fEvent++;
	133	else
	134	fEvent = entry;
	135
	136	if (fEvent >= fNEvents) {
	137	AliWarningF("Event number out of range %d/%d", fEvent, fNEvents);
	138	return false;
	139	}
	140
	141	if (fNEventsPerFile < 0) {
	142	TTree* treeK = fParent->TreeK();
	143	if (!treeK) {
	144	AliError("Parent does not have a kinematics tree");
	145	return false;
	146	}
	147
	148	TFile* fileK = treeK->GetCurrentFile();
	149	if (!fileK) {
	150	AliError("Kinematics tree has no associated file");
	151	return false;
	152	}
	153	// Get the number of events per file
	154	fNEventsPerFile = fileK->GetNkeys() - fileK->GetNProcessIDs();
	155	}
	156	return LoadEvent(fEvent);
	157	}
	158	//____________________________________________________________________
	159	Bool_t
	160	AliMCAuxHandler::Notify(const char* path)
	161	{
	162	// Called when the input file is changed
	163	//
	164	// @param path New path
	165	//
	166	// @return true on success
	167	AliDebugF(10,"AliMCAuxHandler::Notify(\"%s\")", path);
0b7de667	168	// Info("","AliMCAuxHandler::Notify(\"%s\")", path);
2e658fb9	169	return true;
	170	}
	171	//____________________________________________________________________
	172	Bool_t
	173	AliMCAuxHandler::FinishEvent()
	174	{
	175	// Called at the end of an event
	176	//
	177	// @return true on success
0b7de667	178	// AliDebug(10,"AliMCAuxHandler::FinishEvent()");
2e658fb9	179	return true;
	180	}
	181	//____________________________________________________________________
	182	Bool_t
	183	AliMCAuxHandler::Terminate()
	184	{
	185	// Called at the end of a job
	186	//
	187	// @return true on success
	188	AliDebug(10,"AliMCAuxHandler::Terminate()");
	189	return true;
	190	}
	191	//____________________________________________________________________
	192	Bool_t
	193	AliMCAuxHandler::TerminateIO()
	194	{
	195	// Called at the end of a sub-job
	196	//
	197	// @return true on success
	198	AliDebug(10,"AliMCAuxHandler::TerminateIO()");
	199	return true;
	200	}
	201
	202	//____________________________________________________________________
	203	void
	204	AliMCAuxHandler::ResetIO()
	205	{
	206	// Reset the I/O
	207	//
	208	//
	209	AliDebug(10,"AliMCAuxHandler::ResetIO()");
	210
	211	TString* path = GetParentPath();
	212	AliDebugF(10,"Got parent path %s", path ? path->Data() : "null");
0b7de667	213	// Info("ResetIO","Got parent path %s", path ? path->Data() : "null");
2e658fb9	214
	215	if (fFile) {
	216	delete fFile;
	217	fFile = 0;
	218	}
	219	}
	220	//____________________________________________________________________
	221	Bool_t
	222	AliMCAuxHandler::OpenFile(Int_t fileNo)
	223	{
	224	TString* path = GetParentPath();
	225	AliDebugF(10,"Got parent path %s", path ? path->Data() : "null");
0b7de667	226	// Info("OpenFile","Got parent path %s", path ? path->Data() : "null");
2e658fb9	227	if (!path) return false;
	228
	229	TString ext("");
	230	if (fileNo > 0) ext = TString::Format("%d", fileNo);
	231
	232	TString w(GetTitle());
	233	if (w.EndsWith("s")) w.Chop();
	234
	235	TString fn = TString::Format("%s%s.%s%s.root",
	236	path->Data(), GetName(),
	237	fFileBase.Data(), ext.Data());
0b7de667	238	AliDebugF(10,"Opening %s", fn.Data());
0b7de667	239	// Info("OpenFile", "Opening %s", fn.Data());
2e658fb9	240	fFile = TFile::Open(fn, "READ");
	241	if (!fFile) {
	242	AliErrorF("Failed to open %s", fn.Data());
	243	return false;
	244	}
	245
	246	return true;
	247	}
	248
	249	//____________________________________________________________________
	250	Bool_t
	251	AliMCAuxHandler::LoadEvent(Int_t iev)
	252	{
	253	// Load an event
	254	//
	255	// @param iev Event number
	256	//
	257	// @return true on success
	258	AliDebugF(10,"AliMCAuxHandler::LoadEvent(%d)", iev);
0b7de667	259	// Info("","AliMCAuxHandler::LoadEvent(%d)", iev);
2e658fb9	260
	261	Int_t iNew = iev / fNEventsPerFile;
	262	if (iNew != fFileNumber) {
	263	fFileNumber = iNew;
	264	if (!OpenFile(fFileNumber)) return false;
	265	}
	266	if (!fFile) return false;
	267
	268	TString folder = TString::Format("Event%d", iev);
	269	fFile->GetObject(folder, fDir);
	270	if (!fDir) {
	271	AliWarningF("Folder %s not found in file", folder.Data());
	272	return false;
	273	}
	274
	275	fDir->GetObject(fTreeName, fTree);
	276	if (!fTree) {
	277	AliWarningF("Folder %s does not contain the %s tree %s",
	278	folder.Data(), GetTitle(), fTreeName.Data());
	279	return false;
	280	}
	281
	282	fTree->SetBranchAddress(GetName(), &fArray);
	283	return true;
	284	}
	285
	286	//____________________________________________________________________
	287	Int_t
	288	AliMCAuxHandler::GetNEntry() const
	289	{
	290	if (!fTree) return 0;
	291	return fTree->GetEntries();
	292	}
	293
	294	//____________________________________________________________________
	295	TClonesArray*
	296	AliMCAuxHandler::GetEntryArray(Int_t entry)
	297	{
	298	if (!fTree) return 0;
	299	if (!fArray) return 0;
	300	if (entry < 0 \|\| entry >= fTree->GetEntries()) {
	301	AliErrorF("Entry # %d out of bounds [0,%lld]",
	302	entry, fTree->GetEntries());
	303	return 0;
	304	}
	305	fArray->Clear();
	306
	307	if (fTree->GetEntry(entry) <= 0) return 0;
	308
	309	return fArray;
	310	}
	311
	312
	313	//____________________________________________________________________
	314	AliMCAuxHandler*
	315	AliMCAuxHandler::Create(const char* name, const char* what)
	316	{
	317	AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
	318	if (!mgr) {
	319	::Error("AliMCAuxHandler::Create", "No analysis manager");
	320	return 0;
	321	}
	322
	323	AliVEventHandler* vmc = mgr->GetMCtruthEventHandler();
324	if (!vmc) {
325	::Error("AliMCAuxHandler::Create", "No MC truth handler");
326	return 0;
327	}
328
329	AliMCEventHandler* mc = dynamic_cast<AliMCEventHandler*>(vmc);
330	if (!mc) {
331	::Error("AliMCAuxHandler::Create",
332	"MC truth handler not a AliMCEventHandler, but %s",
333	vmc->ClassName());
334	return 0;
335	}
336
337	AliMCAuxHandler* ret = new AliMCAuxHandler(name, what, mc);
338	mc->AddSubsidiaryHandler(ret);
339
340	return ret;
341	}
342
343	//____________________________________________________________________
344	TClonesArray*
345	AliMCAuxHandler::GetParticleArray(AliMCAuxHandler* handler,
346	Int_t particle)
347	{
348	if (!handler) {
349	::Error("AliMCAuxHandler::GetArray", "No handler passed");
350	return 0;
351	}
352
353	AliMCEventHandler* mc = handler->GetParent();
354	if (!mc) {
355	::Error("AliMCAuxHandler::GetArray", "Handler has no parent");
356	return 0;
357	}
358
359	AliMCEvent* event = mc->MCEvent();
360	if (!event) {
361	::Error("AliMCAuxHandler::GetArray", "No MC event");
362	return 0;
363	}
364
365	AliStack* stack = event->Stack();
289715c8	366	if (!stack) {
2e658fb9	367	::Error("AliMCAuxHandler::GetArray", "Event has no stack");
	368	return 0;
	369	}
	370
	371	handler->GetArray()->Clear();
	372	TTree* tree = handler->GetTree();
	373	if (!tree) {
	374	::Error("AliMCAuxHandler::GetArray", "Handler has no tree");
	375	return 0;
	376	}
	377
	378	Int_t treeIdx = stack->TreeKEntry(particle);
	379	if (treeIdx < 0 \|\| treeIdx >= tree->GetEntries()) {
	380	::Error("AliMCAuxHandler::GetArray",
	381	"Index %d of %d out of bounds [0,%lld]", treeIdx, particle,
	382	tree->GetEntries()-1);
	383	return 0;
	384	}
	385
	386	tree->GetEntry(treeIdx);
	387
	388	return handler->GetArray();
	389	}
	390
	391
	392
	393	//____________________________________________________________________
	394	//
	395	// EOF
	396	//