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

/* $Id$ */
 
#include <TROOT.h>
#include <TSystem.h>
#include <TInterpreter.h>
#include <TChain.h>
#include <TFile.h>
#include <TList.h>

#include "AliAnalysisTaskSE.h"
#include "AliAnalysisManager.h"
#include "AliESDEvent.h"
#include "AliESD.h"
#include "AliAODEvent.h"
#include "AliAODHeader.h"
#include "AliAODTracklets.h"
#include "AliVEvent.h"
#include "AliAODHandler.h"
#include "AliAODInputHandler.h"
#include "AliMCEventHandler.h"
#include "AliInputEventHandler.h"
#include "AliMCEvent.h"
#include "AliStack.h"
#include "AliLog.h"


ClassImp(AliAnalysisTaskSE)

////////////////////////////////////////////////////////////////////////
AliAODHeader*    AliAnalysisTaskSE::fgAODHeader        = NULL;
TClonesArray*    AliAnalysisTaskSE::fgAODTracks        = NULL;
TClonesArray*    AliAnalysisTaskSE::fgAODVertices      = NULL;
TClonesArray*    AliAnalysisTaskSE::fgAODV0s           = NULL;
TClonesArray*    AliAnalysisTaskSE::fgAODPMDClusters   = NULL;
TClonesArray*    AliAnalysisTaskSE::fgAODJets          = NULL;
TClonesArray*    AliAnalysisTaskSE::fgAODFMDClusters   = NULL;
TClonesArray*    AliAnalysisTaskSE::fgAODCaloClusters  = NULL;
AliAODTracklets* AliAnalysisTaskSE::fgAODTracklets     = NULL;


AliAnalysisTaskSE::AliAnalysisTaskSE():
    AliAnalysisTask(),
    fDebug(0),
    fEntry(0),
    fInputEvent(0x0),
    fInputHandler(0x0),
    fOutputAOD(0x0),
    fMCEvent(0x0),
    fTreeA(0x0)
{
  // Default constructor
}

AliAnalysisTaskSE::AliAnalysisTaskSE(const char* name):
    AliAnalysisTask(name, "AnalysisTaskSE"),
    fDebug(0),
    fEntry(0),
    fInputEvent(0x0),
    fInputHandler(0x0),
    fOutputAOD(0x0),
    fMCEvent(0x0),
    fTreeA(0x0)
{
  // Default constructor
    DefineInput (0, TChain::Class());
    DefineOutput(0,  TTree::Class());
}

AliAnalysisTaskSE::AliAnalysisTaskSE(const AliAnalysisTaskSE& obj):
    AliAnalysisTask(obj),
    fDebug(0),
    fEntry(0),
    fInputEvent(0x0),
    fInputHandler(0x0),
    fOutputAOD(0x0),
    fMCEvent(0x0),
    fTreeA(0x0)
{
// Copy constructor
    fDebug        = obj.fDebug;
    fEntry        = obj.fEntry;
    fInputEvent   = obj.fInputEvent;
    fInputHandler = obj.fInputHandler;
    fOutputAOD    = obj.fOutputAOD;
    fMCEvent      = obj.fMCEvent;
    fTreeA        = obj.fTreeA;    
    printf("Constructor (3) \n");
}


AliAnalysisTaskSE& AliAnalysisTaskSE::operator=(const AliAnalysisTaskSE& other)
{
// Assignment
    AliAnalysisTask::operator=(other);
    fDebug        = other.fDebug;
    fEntry        = other.fEntry;
    fInputEvent   = other.fInputEvent;
    fInputHandler = other.fInputHandler;
    fOutputAOD    = other.fOutputAOD;
    fMCEvent      = other.fMCEvent;
    fTreeA        = other.fTreeA;    
    return *this;
}


void AliAnalysisTaskSE::ConnectInputData(Option_t* /*option*/)
{
// Connect the input data
    if (fDebug > 1) printf("AnalysisTaskSE::ConnectInputData() \n");
//
//  ESD
//
    fInputHandler = (AliInputEventHandler*) 
         ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
//
//  Monte Carlo
//
    AliMCEventHandler*    mcH = 0;
    mcH = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
    if (mcH) fMCEvent = mcH->MCEvent();
    
    
    if (fInputHandler) {
         fInputEvent = fInputHandler->GetEvent();
    } else if( fMCEvent ) {
         AliWarning("No Input Event Handler connected, only MC Truth Event Handler") ; 
    } else {
         AliError("No Input Event Handler connected") ; 
         return ; 
    }
}

void AliAnalysisTaskSE::CreateOutputObjects()
{
// Create the output container
//
//  Default AOD
    if (fDebug > 1) printf("AnalysisTaskSE::CreateOutPutData() \n");

    AliAODHandler* handler = (AliAODHandler*) 
         ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
    
    // Check if AOD replication has been required
    
    if (handler) {
	fOutputAOD   = handler->GetAOD();
	fTreeA = handler->GetTree();
	if (!(handler->IsStandard())) {
	    if ((handler->NeedsHeaderReplication()) && !(fgAODHeader)) 
		{
		 if (fDebug > 1) AliInfo("Replicating header");
		 fgAODHeader = new AliAODHeader;
		 handler->AddBranch("AliAODHeader", &fgAODHeader);
		}
	    if ((handler->NeedsTracksBranchReplication()) && !(fgAODTracks))      
	    {   
		if (fDebug > 1) AliInfo("Replicating track branch\n");
		fgAODTracks = new TClonesArray("AliAODTrack",500);
		fgAODTracks->SetName("tracks");
		handler->AddBranch("TClonesArray", &fgAODTracks);
	    }    
	    if ((handler->NeedsVerticesBranchReplication()) && !(fgAODVertices))
	    {
		if (fDebug > 1) AliInfo("Replicating vertices branch\n");
		fgAODVertices = new TClonesArray("AliAODVertex",500);
		fgAODVertices->SetName("vertices");
		handler->AddBranch("TClonesArray", &fgAODVertices);
	    }	
	    if ((handler->NeedsV0sBranchReplication()) && !(fgAODV0s))	  
	    {   
		if (fDebug > 1) AliInfo("Replicating V0s branch\n");
		fgAODV0s = new TClonesArray("AliAODv0",500);
		fgAODV0s->SetName("v0s");
		handler->AddBranch("TClonesArray", &fgAODV0s);
	    }
	    if ((handler->NeedsTrackletsBranchReplication()) && !(fgAODTracklets))	  
	    {   
		if (fDebug > 1) AliInfo("Replicating Tracklets branch\n");
		fgAODTracklets = new AliAODTracklets("tracklets","tracklets");
		handler->AddBranch("AliAODTracklets", &fgAODTracklets);
	    }
	    if ((handler->NeedsPMDClustersBranchReplication()) && !(fgAODPMDClusters))	  
	    {   
		if (fDebug > 1) AliInfo("Replicating PMDClusters branch\n");
		fgAODPMDClusters = new TClonesArray("AliAODPmdCluster",500);
		fgAODPMDClusters->SetName("pmdClusters");
		handler->AddBranch("TClonesArray", &fgAODPMDClusters);
	    }
	    if ((handler->NeedsJetsBranchReplication()) && !(fgAODJets))	  
	    {   
		if (fDebug > 1) AliInfo("Replicating Jets branch\n");
		fgAODJets = new TClonesArray("AliAODJet",500);
		fgAODJets->SetName("jets");
		handler->AddBranch("TClonesArray", &fgAODJets);
	    }
	    if ((handler->NeedsFMDClustersBranchReplication()) && !(fgAODFMDClusters))	  
	    {   
		AliInfo("Replicating FMDClusters branch\n");
		fgAODFMDClusters = new TClonesArray("AliAODFmdCluster",500);
		fgAODFMDClusters->SetName("fmdClusters");
		handler->AddBranch("TClonesArray", &fgAODFMDClusters);
	    }
	    if ((handler->NeedsCaloClustersBranchReplication()) && !(fgAODCaloClusters))	  
	    {   
		if (fDebug > 1) AliInfo("Replicating CaloClusters branch\n");
		fgAODCaloClusters = new TClonesArray("AliAODCaloCluster",500);
		fgAODCaloClusters->SetName("caloClusters");
		handler->AddBranch("TClonesArray", &fgAODCaloClusters);
	    }
	}
    } else {
	AliWarning("No AOD Event Handler connected.") ; 
    }
    UserCreateOutputObjects();
}

void AliAnalysisTaskSE::Exec(Option_t* option)
{
//
// Exec analysis of one event
    if (fDebug > 1) AliInfo("AliAnalysisTaskSE::Exec() \n");
    if( fInputHandler ) 
       fEntry = fInputHandler->GetReadEntry();
    else if( fMCEvent )
       fEntry = fMCEvent->Header()->GetEvent(); 
    if ( !((Entry()-1)%100) && fDebug > 0) 
         AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));

    AliAODHandler* handler = (AliAODHandler*) 
	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
    AliAODInputHandler* aodH = dynamic_cast<AliAODInputHandler*>(fInputHandler);

    if (handler && aodH) {
	if (!(handler->IsStandard()) && !(handler->AODIsReplicated())) {
	    if ((handler->NeedsHeaderReplication()) && (fgAODHeader))
	    {
		fgAODHeader = dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader());
	    }
	    if ((handler->NeedsTracksBranchReplication()) && (fgAODTracks))
	    {
		TClonesArray* tracks = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracks();
		new (fgAODTracks) TClonesArray(*tracks);
	    }
	    if ((handler->NeedsVerticesBranchReplication()) && (fgAODVertices))
	    {
		TClonesArray* vertices = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetVertices();
		new (fgAODVertices) TClonesArray(*vertices);
	    }
	    if ((handler->NeedsV0sBranchReplication()) && (fgAODV0s))
	    {
		TClonesArray* V0s = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetV0s();
		new (fgAODV0s) TClonesArray(*V0s);
	    }
	    if ((handler->NeedsTrackletsBranchReplication()) && (fgAODTracklets))
	    {
		    fgAODTracklets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracklets();
	    }
	    if ((handler->NeedsPMDClustersBranchReplication()) && (fgAODPMDClusters))
	    {
		TClonesArray* PMDClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetPmdClusters();
		new (fgAODPMDClusters) TClonesArray(*PMDClusters);
	    }
	    if ((handler->NeedsJetsBranchReplication()) && (fgAODJets))
	    {
		TClonesArray* Jets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetJets();
		new (fgAODJets) TClonesArray(*Jets);
	    }
	    if ((handler->NeedsFMDClustersBranchReplication()) && (fgAODFMDClusters))
	    {
		TClonesArray* FMDClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetFmdClusters();
		new (fgAODFMDClusters) TClonesArray(*FMDClusters);
	    }
	    if ((handler->NeedsCaloClustersBranchReplication()) && (fgAODCaloClusters))
	    {
		TClonesArray* CaloClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetCaloClusters();
		new (fgAODCaloClusters) TClonesArray(*CaloClusters);
	    }
	    //
	    handler->SetAODIsReplicated();
	    
	}
    }

// Call the user analysis    
    UserExec(option);
    PostData(0, fTreeA);
    
}

const char* AliAnalysisTaskSE::CurrentFileName()
{
// Returns the current file name    
    if( fInputHandler )
      return fInputHandler->GetTree()->GetCurrentFile()->GetName();
    else if( fMCEvent )
      return ((AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()))->TreeK()->GetCurrentFile()->GetName();
    else return "";
}

void AliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj)
{
    // Add a new branch to the aod tree
    AliAODHandler* handler = (AliAODHandler*) 
	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
    if (handler) {
	handler->AddBranch(cname, addobj);
    }
}
Commit	Line	Data
5232d0de	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	/* $Id$ */
	17
	18	#include <TROOT.h>
	19	#include <TSystem.h>
	20	#include <TInterpreter.h>
	21	#include <TChain.h>
	22	#include <TFile.h>
	23	#include <TList.h>
	24
	25	#include "AliAnalysisTaskSE.h"
	26	#include "AliAnalysisManager.h"
	27	#include "AliESDEvent.h"
	28	#include "AliESD.h"
	29	#include "AliAODEvent.h"
3f2431c4	30	#include "AliAODHeader.h"
c185e0db	31	#include "AliAODTracklets.h"
5232d0de	32	#include "AliVEvent.h"
5232d0de	33	#include "AliAODHandler.h"
3f2431c4	34	#include "AliAODInputHandler.h"
5232d0de	35	#include "AliMCEventHandler.h"
	36	#include "AliInputEventHandler.h"
	37	#include "AliMCEvent.h"
	38	#include "AliStack.h"
4d0a82af	39	#include "AliLog.h"
5232d0de	40
	41
	42	ClassImp(AliAnalysisTaskSE)
	43
	44	////////////////////////////////////////////////////////////////////////
c185e0db	45	AliAODHeader* AliAnalysisTaskSE::fgAODHeader = NULL;
	46	TClonesArray* AliAnalysisTaskSE::fgAODTracks = NULL;
	47	TClonesArray* AliAnalysisTaskSE::fgAODVertices = NULL;
	48	TClonesArray* AliAnalysisTaskSE::fgAODV0s = NULL;
	49	TClonesArray* AliAnalysisTaskSE::fgAODPMDClusters = NULL;
	50	TClonesArray* AliAnalysisTaskSE::fgAODJets = NULL;
	51	TClonesArray* AliAnalysisTaskSE::fgAODFMDClusters = NULL;
	52	TClonesArray* AliAnalysisTaskSE::fgAODCaloClusters = NULL;
	53	AliAODTracklets* AliAnalysisTaskSE::fgAODTracklets = NULL;
	54
5232d0de	55
	56	AliAnalysisTaskSE::AliAnalysisTaskSE():
	57	AliAnalysisTask(),
	58	fDebug(0),
80d13558	59	fEntry(0),
5232d0de	60	fInputEvent(0x0),
80d13558	61	fInputHandler(0x0),
5232d0de	62	fOutputAOD(0x0),
	63	fMCEvent(0x0),
	64	fTreeA(0x0)
	65	{
	66	// Default constructor
	67	}
	68
	69	AliAnalysisTaskSE::AliAnalysisTaskSE(const char* name):
	70	AliAnalysisTask(name, "AnalysisTaskSE"),
	71	fDebug(0),
80d13558	72	fEntry(0),
5232d0de	73	fInputEvent(0x0),
80d13558	74	fInputHandler(0x0),
5232d0de	75	fOutputAOD(0x0),
	76	fMCEvent(0x0),
	77	fTreeA(0x0)
	78	{
	79	// Default constructor
	80	DefineInput (0, TChain::Class());
	81	DefineOutput(0, TTree::Class());
	82	}
	83
26f071d8	84	AliAnalysisTaskSE::AliAnalysisTaskSE(const AliAnalysisTaskSE& obj):
	85	AliAnalysisTask(obj),
	86	fDebug(0),
80d13558	87	fEntry(0),
26f071d8	88	fInputEvent(0x0),
80d13558	89	fInputHandler(0x0),
26f071d8	90	fOutputAOD(0x0),
	91	fMCEvent(0x0),
	92	fTreeA(0x0)
	93	{
	94	// Copy constructor
80d13558	95	fDebug = obj.fDebug;
	96	fEntry = obj.fEntry;
	97	fInputEvent = obj.fInputEvent;
	98	fInputHandler = obj.fInputHandler;
	99	fOutputAOD = obj.fOutputAOD;
	100	fMCEvent = obj.fMCEvent;
	101	fTreeA = obj.fTreeA;
f0b15803	102	printf("Constructor (3) \n");
26f071d8	103	}
	104
	105
	106	AliAnalysisTaskSE& AliAnalysisTaskSE::operator=(const AliAnalysisTaskSE& other)
	107	{
	108	// Assignment
	109	AliAnalysisTask::operator=(other);
80d13558	110	fDebug = other.fDebug;
	111	fEntry = other.fEntry;
	112	fInputEvent = other.fInputEvent;
	113	fInputHandler = other.fInputHandler;
	114	fOutputAOD = other.fOutputAOD;
	115	fMCEvent = other.fMCEvent;
	116	fTreeA = other.fTreeA;
26f071d8	117	return *this;
26f071d8	118	}
5232d0de	119
	120
	121	void AliAnalysisTaskSE::ConnectInputData(Option_t* /option/)
	122	{
	123	// Connect the input data
	124	if (fDebug > 1) printf("AnalysisTaskSE::ConnectInputData() \n");
	125	//
	126	// ESD
	127	//
f0b15803	128	fInputHandler = (AliInputEventHandler*)
259b7a8a	129	((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
5232d0de	130	//
	131	// Monte Carlo
	132	//
	133	AliMCEventHandler* mcH = 0;
	134	mcH = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
	135	if (mcH) fMCEvent = mcH->MCEvent();
259b7a8a	136
	137
	138	if (fInputHandler) {
	139	fInputEvent = fInputHandler->GetEvent();
	140	} else if( fMCEvent ) {
	141	AliWarning("No Input Event Handler connected, only MC Truth Event Handler") ;
	142	} else {
	143	AliError("No Input Event Handler connected") ;
	144	return ;
	145	}
5232d0de	146	}
	147
	148	void AliAnalysisTaskSE::CreateOutputObjects()
	149	{
	150	// Create the output container
	151	//
	152	// Default AOD
	153	if (fDebug > 1) printf("AnalysisTaskSE::CreateOutPutData() \n");
	154
	155	AliAODHandler* handler = (AliAODHandler*)
259b7a8a	156	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
5232d0de	157
c185e0db	158	// Check if AOD replication has been required
c185e0db	159
3b9a675c	160	if (handler) {
	161	fOutputAOD = handler->GetAOD();
	162	fTreeA = handler->GetTree();
c185e0db	163	if (!(handler->IsStandard())) {
	164	if ((handler->NeedsHeaderReplication()) && !(fgAODHeader))
	165	{
87022830	166	if (fDebug > 1) AliInfo("Replicating header");
	167	fgAODHeader = new AliAODHeader;
	168	handler->AddBranch("AliAODHeader", &fgAODHeader);
c185e0db	169	}
	170	if ((handler->NeedsTracksBranchReplication()) && !(fgAODTracks))
	171	{
	172	if (fDebug > 1) AliInfo("Replicating track branch\n");
	173	fgAODTracks = new TClonesArray("AliAODTrack",500);
87022830	174	fgAODTracks->SetName("tracks");
c185e0db	175	handler->AddBranch("TClonesArray", &fgAODTracks);
	176	}
	177	if ((handler->NeedsVerticesBranchReplication()) && !(fgAODVertices))
	178	{
	179	if (fDebug > 1) AliInfo("Replicating vertices branch\n");
	180	fgAODVertices = new TClonesArray("AliAODVertex",500);
87022830	181	fgAODVertices->SetName("vertices");
c185e0db	182	handler->AddBranch("TClonesArray", &fgAODVertices);
	183	}
	184	if ((handler->NeedsV0sBranchReplication()) && !(fgAODV0s))
	185	{
	186	if (fDebug > 1) AliInfo("Replicating V0s branch\n");
	187	fgAODV0s = new TClonesArray("AliAODv0",500);
87022830	188	fgAODV0s->SetName("v0s");
c185e0db	189	handler->AddBranch("TClonesArray", &fgAODV0s);
	190	}
	191	if ((handler->NeedsTrackletsBranchReplication()) && !(fgAODTracklets))
	192	{
	193	if (fDebug > 1) AliInfo("Replicating Tracklets branch\n");
87022830	194	fgAODTracklets = new AliAODTracklets("tracklets","tracklets");
c185e0db	195	handler->AddBranch("AliAODTracklets", &fgAODTracklets);
	196	}
	197	if ((handler->NeedsPMDClustersBranchReplication()) && !(fgAODPMDClusters))
	198	{
	199	if (fDebug > 1) AliInfo("Replicating PMDClusters branch\n");
	200	fgAODPMDClusters = new TClonesArray("AliAODPmdCluster",500);
87022830	201	fgAODPMDClusters->SetName("pmdClusters");
c185e0db	202	handler->AddBranch("TClonesArray", &fgAODPMDClusters);
	203	}
	204	if ((handler->NeedsJetsBranchReplication()) && !(fgAODJets))
	205	{
	206	if (fDebug > 1) AliInfo("Replicating Jets branch\n");
	207	fgAODJets = new TClonesArray("AliAODJet",500);
87022830	208	fgAODJets->SetName("jets");
c185e0db	209	handler->AddBranch("TClonesArray", &fgAODJets);
	210	}
	211	if ((handler->NeedsFMDClustersBranchReplication()) && !(fgAODFMDClusters))
	212	{
	213	AliInfo("Replicating FMDClusters branch\n");
	214	fgAODFMDClusters = new TClonesArray("AliAODFmdCluster",500);
87022830	215	fgAODFMDClusters->SetName("fmdClusters");
c185e0db	216	handler->AddBranch("TClonesArray", &fgAODFMDClusters);
	217	}
	218	if ((handler->NeedsCaloClustersBranchReplication()) && !(fgAODCaloClusters))
	219	{
	220	if (fDebug > 1) AliInfo("Replicating CaloClusters branch\n");
	221	fgAODCaloClusters = new TClonesArray("AliAODCaloCluster",500);
87022830	222	fgAODCaloClusters->SetName("caloClusters");
c185e0db	223	handler->AddBranch("TClonesArray", &fgAODCaloClusters);
c185e0db	224	}
3f2431c4	225	}
3b9a675c	226	} else {
	227	AliWarning("No AOD Event Handler connected.") ;
	228	}
5232d0de	229	UserCreateOutputObjects();
	230	}
	231
	232	void AliAnalysisTaskSE::Exec(Option_t* option)
	233	{
	234	//
	235	// Exec analysis of one event
259b7a8a	236	if (fDebug > 1) AliInfo("AliAnalysisTaskSE::Exec() \n");
	237	if( fInputHandler )
	238	fEntry = fInputHandler->GetReadEntry();
	239	else if( fMCEvent )
	240	fEntry = fMCEvent->Header()->GetEvent();
4d0a82af	241	if ( !((Entry()-1)%100) && fDebug > 0)
259b7a8a	242	AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
3f2431c4	243
	244	AliAODHandler* handler = (AliAODHandler*)
	245	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
c185e0db	246	AliAODInputHandler* aodH = dynamic_cast<AliAODInputHandler*>(fInputHandler);
	247
	248	if (handler && aodH) {
	249	if (!(handler->IsStandard()) && !(handler->AODIsReplicated())) {
	250	if ((handler->NeedsHeaderReplication()) && (fgAODHeader))
	251	{
	252	fgAODHeader = dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader());
daa81fe5	253	}
c185e0db	254	if ((handler->NeedsTracksBranchReplication()) && (fgAODTracks))
	255	{
	256	TClonesArray* tracks = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracks();
	257	new (fgAODTracks) TClonesArray(*tracks);
	258	}
	259	if ((handler->NeedsVerticesBranchReplication()) && (fgAODVertices))
	260	{
	261	TClonesArray* vertices = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetVertices();
	262	new (fgAODVertices) TClonesArray(*vertices);
	263	}
	264	if ((handler->NeedsV0sBranchReplication()) && (fgAODV0s))
	265	{
	266	TClonesArray* V0s = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetV0s();
	267	new (fgAODV0s) TClonesArray(*V0s);
	268	}
	269	if ((handler->NeedsTrackletsBranchReplication()) && (fgAODTracklets))
	270	{
	271	fgAODTracklets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracklets();
	272	}
	273	if ((handler->NeedsPMDClustersBranchReplication()) && (fgAODPMDClusters))
	274	{
	275	TClonesArray* PMDClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetPmdClusters();
	276	new (fgAODPMDClusters) TClonesArray(*PMDClusters);
	277	}
	278	if ((handler->NeedsJetsBranchReplication()) && (fgAODJets))
	279	{
	280	TClonesArray* Jets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetJets();
	281	new (fgAODJets) TClonesArray(*Jets);
	282	}
	283	if ((handler->NeedsFMDClustersBranchReplication()) && (fgAODFMDClusters))
	284	{
	285	TClonesArray* FMDClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetFmdClusters();
	286	new (fgAODFMDClusters) TClonesArray(*FMDClusters);
	287	}
	288	if ((handler->NeedsCaloClustersBranchReplication()) && (fgAODCaloClusters))
	289	{
	290	TClonesArray* CaloClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetCaloClusters();
	291	new (fgAODCaloClusters) TClonesArray(*CaloClusters);
	292	}
	293	//
	294	handler->SetAODIsReplicated();
	295
3f2431c4	296	}
	297	}
	298
4d0a82af	299	// Call the user analysis
5232d0de	300	UserExec(option);
2d108f6e	301	PostData(0, fTreeA);
2d108f6e	302
5232d0de	303	}
5232d0de	304
4d0a82af	305	const char* AliAnalysisTaskSE::CurrentFileName()
	306	{
	307	// Returns the current file name
259b7a8a	308	if( fInputHandler )
	309	return fInputHandler->GetTree()->GetCurrentFile()->GetName();
	310	else if( fMCEvent )
	311	return ((AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()))->TreeK()->GetCurrentFile()->GetName();
8803dcb1	312	else return "";
4d0a82af	313	}
5232d0de	314
0134949d	315	void AliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj)
164e94ff	316	{
	317	// Add a new branch to the aod tree
	318	AliAODHandler* handler = (AliAODHandler*)
	319	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
	320	if (handler) {
3b427089	321	handler->AddBranch(cname, addobj);
164e94ff	322	}
164e94ff	323	}