[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 "AliAnalysisDataSlot.h"
#include "AliESDEvent.h"
#include "AliESD.h"
#include "AliAODEvent.h"
#include "AliAODHeader.h"
#include "AliAODTracklets.h"
#include "AliAODCaloCells.h"
#include "AliAODMCParticle.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;
TClonesArray*    AliAnalysisTaskSE::fgAODMCParticles   = NULL;
AliAODTracklets* AliAnalysisTaskSE::fgAODTracklets     = NULL;
AliAODCaloCells* AliAnalysisTaskSE::fgAODEmcalCells    = NULL;
AliAODCaloCells* AliAnalysisTaskSE::fgAODPhosCells     = 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;    
}


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());
    
    Bool_t merging = kFALSE;
    AliAODInputHandler* aodIH = static_cast<AliAODInputHandler*>((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
    if (aodIH) {
	if (aodIH->GetMergeEvents()) merging = kTRUE;
    }
    
    // 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() || merging) && !(fgAODTracks))      
	    {   
		if (fDebug > 1) AliInfo("Replicating track branch\n");
		fgAODTracks = new TClonesArray("AliAODTrack",500);
		fgAODTracks->SetName("tracks");
		handler->AddBranch("TClonesArray", &fgAODTracks);
	    }    
	    if ((handler->NeedsVerticesBranchReplication() || merging) && !(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() || merging) && !(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() || merging) && !(fgAODCaloClusters))	  
	    {   
		if (fDebug > 1) AliInfo("Replicating CaloClusters branch\n");
		fgAODCaloClusters = new TClonesArray("AliAODCaloCluster",500);
		fgAODCaloClusters->SetName("caloClusters");
		handler->AddBranch("TClonesArray", &fgAODCaloClusters);

		fgAODEmcalCells = new AliAODCaloCells();
		fgAODEmcalCells->SetName("emcalCells");
		handler->AddBranch("AliAODCaloCells", &fgAODEmcalCells);

		fgAODPhosCells = new AliAODCaloCells();
		fgAODPhosCells->SetName("phosCells");
		handler->AddBranch("AliAODCaloCells", &fgAODPhosCells);
	    }
	    if ((handler->NeedsMCParticlesBranchReplication() || merging) && !(fgAODMCParticles))	  
	    {   
		if (fDebug > 1) AliInfo("Replicating MCParticles branch\n");
		fgAODMCParticles = new TClonesArray("AliAODMCParticle",500);
		fgAODMCParticles->SetName("mcparticles");
		handler->AddBranch("TClonesArray", &fgAODMCParticles);
	    }
	    // cache the pointerd in the AODEvent
	    fOutputAOD->GetStdContent();
	}
    } 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) {
	fMCEvent = aodH->MCEvent();
	Bool_t merging = aodH->GetMergeEvents();
	
	if (!(handler->IsStandard()) && !(handler->AODIsReplicated())) {
	    if ((handler->NeedsHeaderReplication()) && (fgAODHeader))
	    {
	      // copy the contents by assigment
	      *fgAODHeader =  *(dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader()));
	    }
	    if ((handler->NeedsTracksBranchReplication() || merging) && (fgAODTracks))
	    {
		TClonesArray* tracks = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracks();
		new (fgAODTracks) TClonesArray(*tracks);
	    }
	    if ((handler->NeedsVerticesBranchReplication() || merging) && (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() || merging) && (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() || merging) && (fgAODCaloClusters))
	    {
		TClonesArray* caloClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetCaloClusters();
		new (fgAODCaloClusters) TClonesArray(*caloClusters);
	    }

	    if ((handler->NeedsMCParticlesBranchReplication() || merging) && (fgAODMCParticles))
	    {
		TClonesArray* mcParticles = (TClonesArray*) ((dynamic_cast<AliAODEvent*>(InputEvent()))->FindListObject("mcparticles"));
		new (fgAODMCParticles) TClonesArray(*mcParticles);
	    }
	
	    // Additional merging if needed
	    if (merging) {
		// mcParticles
		TClonesArray* mcparticles = (TClonesArray*) ((aodH->GetEventToMerge())->FindListObject("mcparticles"));
		Int_t npart = mcparticles->GetEntries();
		Int_t nc = fgAODMCParticles->GetEntries();
		Int_t nc0 = nc;
		
		for (Int_t i = 0; i < npart; i++) {
		    AliAODMCParticle* particle = (AliAODMCParticle*) mcparticles->At(i);
		    new((*fgAODMCParticles)[nc++]) AliAODMCParticle(*particle);
		}
		
		// tracks
		TClonesArray* tracks = aodH->GetEventToMerge()->GetTracks();
		Int_t ntr = tracks->GetEntries();
		nc  = fgAODTracks->GetEntries();	
		for (Int_t i = 0; i < ntr; i++) {
		    AliAODTrack*    track = (AliAODTrack*) tracks->At(i);
		    AliAODTrack* newtrack = new((*fgAODTracks)[nc++]) AliAODTrack(*track);

		    newtrack->SetLabel(newtrack->GetLabel() + nc0);
		}

		for (Int_t i = 0; i < nc; i++) 
		{
		    AliAODTrack* track = (AliAODTrack*) fgAODTracks->At(i);
		    track->ResetBit(kIsReferenced);
		    track->SetUniqueID(0);
		}
		
		
		// clusters
		TClonesArray* clusters = aodH->GetEventToMerge()->GetCaloClusters();
		Int_t ncl  = clusters->GetEntries();
		nc         =  fgAODCaloClusters->GetEntries();
		for (Int_t i = 0; i < ncl; i++) {
		    AliAODCaloCluster*    cluster = (AliAODCaloCluster*) clusters->At(i);
		    new((*fgAODCaloClusters)[nc++]) AliAODCaloCluster(*cluster);
		}
		// cells
		AliAODCaloCells* cellsA = aodH->GetEventToMerge()->GetEMCALCells();
		Int_t ncells  = cellsA->GetNumberOfCells();
		nc = fgAODEmcalCells->GetNumberOfCells();
		
		for (Int_t i  = 0; i < ncells; i++) {
		    Int_t cn  = cellsA->GetCellNumber(i);
		    Int_t pos = fgAODEmcalCells->GetCellPosition(cn);
		    if (pos >= 0) {
			Double_t amp = cellsA->GetAmplitude(i) + fgAODEmcalCells->GetAmplitude(pos);
			fgAODEmcalCells->SetCell(pos, cn, amp);
		    } else {
			Double_t amp = cellsA->GetAmplitude(i);
			fgAODEmcalCells->SetCell(nc++, cn, amp);
			fgAODEmcalCells->Sort();
		    }
		}
		
		
	    } // merging
	    
	    handler->SetAODIsReplicated();
	}
    }

// Call the user analysis    
    UserExec(option);
    // Added protection in case the derived task is not an AOD producer.
    AliAnalysisDataSlot *out0 = GetOutputSlot(0);
    if (out0 && out0->IsConnected()) 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, const char *fname)
{
    // Add a new branch to the aod tree
    AliAODHandler* handler = (AliAODHandler*) 
	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
    if (handler) {
	handler->AddBranch(cname, addobj, fname);
    }
}

Bool_t AliAnalysisTaskSE::IsStandardAOD() const
{
// Check if the output AOD handler is configured for standard or delta AOD.
// Users should first check that AODEvent() returns non-null.
    AliAODHandler* handler = (AliAODHandler*) 
         ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
    if (!handler) {
       Error("IsStandardAOD", "No AOD handler. Please use AODEvent() to check this first");
       return kTRUE;
    }
    return handler->IsStandard();   
}
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"
60a04972	27	#include "AliAnalysisDataSlot.h"
5232d0de	28	#include "AliESDEvent.h"
	29	#include "AliESD.h"
	30	#include "AliAODEvent.h"
3f2431c4	31	#include "AliAODHeader.h"
c185e0db	32	#include "AliAODTracklets.h"
5a922844	33	#include "AliAODCaloCells.h"
113bc2bd	34	#include "AliAODMCParticle.h"
5232d0de	35	#include "AliVEvent.h"
5232d0de	36	#include "AliAODHandler.h"
3f2431c4	37	#include "AliAODInputHandler.h"
5232d0de	38	#include "AliMCEventHandler.h"
	39	#include "AliInputEventHandler.h"
	40	#include "AliMCEvent.h"
	41	#include "AliStack.h"
4d0a82af	42	#include "AliLog.h"
5232d0de	43
	44
	45	ClassImp(AliAnalysisTaskSE)
	46
	47	////////////////////////////////////////////////////////////////////////
c185e0db	48	AliAODHeader* AliAnalysisTaskSE::fgAODHeader = NULL;
	49	TClonesArray* AliAnalysisTaskSE::fgAODTracks = NULL;
	50	TClonesArray* AliAnalysisTaskSE::fgAODVertices = NULL;
	51	TClonesArray* AliAnalysisTaskSE::fgAODV0s = NULL;
	52	TClonesArray* AliAnalysisTaskSE::fgAODPMDClusters = NULL;
	53	TClonesArray* AliAnalysisTaskSE::fgAODJets = NULL;
	54	TClonesArray* AliAnalysisTaskSE::fgAODFMDClusters = NULL;
	55	TClonesArray* AliAnalysisTaskSE::fgAODCaloClusters = NULL;
113bc2bd	56	TClonesArray* AliAnalysisTaskSE::fgAODMCParticles = NULL;
c185e0db	57	AliAODTracklets* AliAnalysisTaskSE::fgAODTracklets = NULL;
5a922844	58	AliAODCaloCells* AliAnalysisTaskSE::fgAODEmcalCells = NULL;
5a922844	59	AliAODCaloCells* AliAnalysisTaskSE::fgAODPhosCells = NULL;
c185e0db	60
5232d0de	61
	62	AliAnalysisTaskSE::AliAnalysisTaskSE():
	63	AliAnalysisTask(),
	64	fDebug(0),
80d13558	65	fEntry(0),
5232d0de	66	fInputEvent(0x0),
80d13558	67	fInputHandler(0x0),
5232d0de	68	fOutputAOD(0x0),
	69	fMCEvent(0x0),
	70	fTreeA(0x0)
	71	{
	72	// Default constructor
	73	}
	74
	75	AliAnalysisTaskSE::AliAnalysisTaskSE(const char* name):
	76	AliAnalysisTask(name, "AnalysisTaskSE"),
	77	fDebug(0),
80d13558	78	fEntry(0),
5232d0de	79	fInputEvent(0x0),
80d13558	80	fInputHandler(0x0),
5232d0de	81	fOutputAOD(0x0),
	82	fMCEvent(0x0),
	83	fTreeA(0x0)
	84	{
	85	// Default constructor
	86	DefineInput (0, TChain::Class());
	87	DefineOutput(0, TTree::Class());
	88	}
	89
26f071d8	90	AliAnalysisTaskSE::AliAnalysisTaskSE(const AliAnalysisTaskSE& obj):
	91	AliAnalysisTask(obj),
	92	fDebug(0),
80d13558	93	fEntry(0),
26f071d8	94	fInputEvent(0x0),
80d13558	95	fInputHandler(0x0),
26f071d8	96	fOutputAOD(0x0),
	97	fMCEvent(0x0),
	98	fTreeA(0x0)
	99	{
	100	// Copy constructor
80d13558	101	fDebug = obj.fDebug;
	102	fEntry = obj.fEntry;
	103	fInputEvent = obj.fInputEvent;
	104	fInputHandler = obj.fInputHandler;
	105	fOutputAOD = obj.fOutputAOD;
	106	fMCEvent = obj.fMCEvent;
	107	fTreeA = obj.fTreeA;
26f071d8	108	}
	109
	110
	111	AliAnalysisTaskSE& AliAnalysisTaskSE::operator=(const AliAnalysisTaskSE& other)
	112	{
	113	// Assignment
	114	AliAnalysisTask::operator=(other);
80d13558	115	fDebug = other.fDebug;
	116	fEntry = other.fEntry;
	117	fInputEvent = other.fInputEvent;
	118	fInputHandler = other.fInputHandler;
	119	fOutputAOD = other.fOutputAOD;
	120	fMCEvent = other.fMCEvent;
	121	fTreeA = other.fTreeA;
26f071d8	122	return *this;
26f071d8	123	}
5232d0de	124
	125
	126	void AliAnalysisTaskSE::ConnectInputData(Option_t* /option/)
	127	{
	128	// Connect the input data
	129	if (fDebug > 1) printf("AnalysisTaskSE::ConnectInputData() \n");
	130	//
	131	// ESD
	132	//
f0b15803	133	fInputHandler = (AliInputEventHandler*)
259b7a8a	134	((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
5232d0de	135	//
	136	// Monte Carlo
	137	//
	138	AliMCEventHandler* mcH = 0;
	139	mcH = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
04a79fa0	140	if (mcH) {
	141	fMCEvent = mcH->MCEvent();
	142	}
259b7a8a	143
	144	if (fInputHandler) {
	145	fInputEvent = fInputHandler->GetEvent();
	146	} else if( fMCEvent ) {
	147	AliWarning("No Input Event Handler connected, only MC Truth Event Handler") ;
	148	} else {
	149	AliError("No Input Event Handler connected") ;
	150	return ;
	151	}
5232d0de	152	}
	153
	154	void AliAnalysisTaskSE::CreateOutputObjects()
	155	{
	156	// Create the output container
	157	//
	158	// Default AOD
	159	if (fDebug > 1) printf("AnalysisTaskSE::CreateOutPutData() \n");
	160
	161	AliAODHandler* handler = (AliAODHandler*)
259b7a8a	162	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
5232d0de	163
5a922844	164	Bool_t merging = kFALSE;
	165	AliAODInputHandler* aodIH = static_cast<AliAODInputHandler*>((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
	166	if (aodIH) {
	167	if (aodIH->GetMergeEvents()) merging = kTRUE;
	168	}
	169
c185e0db	170	// Check if AOD replication has been required
c185e0db	171
3b9a675c	172	if (handler) {
	173	fOutputAOD = handler->GetAOD();
	174	fTreeA = handler->GetTree();
c185e0db	175	if (!(handler->IsStandard())) {
	176	if ((handler->NeedsHeaderReplication()) && !(fgAODHeader))
	177	{
87022830	178	if (fDebug > 1) AliInfo("Replicating header");
	179	fgAODHeader = new AliAODHeader;
	180	handler->AddBranch("AliAODHeader", &fgAODHeader);
c185e0db	181	}
5a922844	182	if ((handler->NeedsTracksBranchReplication() \|\| merging) && !(fgAODTracks))
c185e0db	183	{
	184	if (fDebug > 1) AliInfo("Replicating track branch\n");
	185	fgAODTracks = new TClonesArray("AliAODTrack",500);
87022830	186	fgAODTracks->SetName("tracks");
c185e0db	187	handler->AddBranch("TClonesArray", &fgAODTracks);
c185e0db	188	}
4dd8a1c8	189	if ((handler->NeedsVerticesBranchReplication() \|\| merging) && !(fgAODVertices))
c185e0db	190	{
	191	if (fDebug > 1) AliInfo("Replicating vertices branch\n");
	192	fgAODVertices = new TClonesArray("AliAODVertex",500);
87022830	193	fgAODVertices->SetName("vertices");
c185e0db	194	handler->AddBranch("TClonesArray", &fgAODVertices);
	195	}
	196	if ((handler->NeedsV0sBranchReplication()) && !(fgAODV0s))
	197	{
	198	if (fDebug > 1) AliInfo("Replicating V0s branch\n");
	199	fgAODV0s = new TClonesArray("AliAODv0",500);
87022830	200	fgAODV0s->SetName("v0s");
c185e0db	201	handler->AddBranch("TClonesArray", &fgAODV0s);
	202	}
	203	if ((handler->NeedsTrackletsBranchReplication()) && !(fgAODTracklets))
	204	{
	205	if (fDebug > 1) AliInfo("Replicating Tracklets branch\n");
87022830	206	fgAODTracklets = new AliAODTracklets("tracklets","tracklets");
c185e0db	207	handler->AddBranch("AliAODTracklets", &fgAODTracklets);
	208	}
	209	if ((handler->NeedsPMDClustersBranchReplication()) && !(fgAODPMDClusters))
	210	{
	211	if (fDebug > 1) AliInfo("Replicating PMDClusters branch\n");
	212	fgAODPMDClusters = new TClonesArray("AliAODPmdCluster",500);
87022830	213	fgAODPMDClusters->SetName("pmdClusters");
c185e0db	214	handler->AddBranch("TClonesArray", &fgAODPMDClusters);
c185e0db	215	}
5a922844	216	if ((handler->NeedsJetsBranchReplication() \|\| merging) && !(fgAODJets))
c185e0db	217	{
	218	if (fDebug > 1) AliInfo("Replicating Jets branch\n");
	219	fgAODJets = new TClonesArray("AliAODJet",500);
87022830	220	fgAODJets->SetName("jets");
c185e0db	221	handler->AddBranch("TClonesArray", &fgAODJets);
	222	}
	223	if ((handler->NeedsFMDClustersBranchReplication()) && !(fgAODFMDClusters))
	224	{
	225	AliInfo("Replicating FMDClusters branch\n");
	226	fgAODFMDClusters = new TClonesArray("AliAODFmdCluster",500);
87022830	227	fgAODFMDClusters->SetName("fmdClusters");
c185e0db	228	handler->AddBranch("TClonesArray", &fgAODFMDClusters);
c185e0db	229	}
5a922844	230	if ((handler->NeedsCaloClustersBranchReplication() \|\| merging) && !(fgAODCaloClusters))
c185e0db	231	{
	232	if (fDebug > 1) AliInfo("Replicating CaloClusters branch\n");
	233	fgAODCaloClusters = new TClonesArray("AliAODCaloCluster",500);
87022830	234	fgAODCaloClusters->SetName("caloClusters");
c185e0db	235	handler->AddBranch("TClonesArray", &fgAODCaloClusters);
5a922844	236
	237	fgAODEmcalCells = new AliAODCaloCells();
	238	fgAODEmcalCells->SetName("emcalCells");
	239	handler->AddBranch("AliAODCaloCells", &fgAODEmcalCells);
	240
	241	fgAODPhosCells = new AliAODCaloCells();
	242	fgAODPhosCells->SetName("phosCells");
	243	handler->AddBranch("AliAODCaloCells", &fgAODPhosCells);
c185e0db	244	}
113bc2bd	245	if ((handler->NeedsMCParticlesBranchReplication() \|\| merging) && !(fgAODMCParticles))
	246	{
	247	if (fDebug > 1) AliInfo("Replicating MCParticles branch\n");
	248	fgAODMCParticles = new TClonesArray("AliAODMCParticle",500);
	249	fgAODMCParticles->SetName("mcparticles");
	250	handler->AddBranch("TClonesArray", &fgAODMCParticles);
	251	}
5a922844	252	// cache the pointerd in the AODEvent
5a922844	253	fOutputAOD->GetStdContent();
3f2431c4	254	}
3b9a675c	255	} else {
	256	AliWarning("No AOD Event Handler connected.") ;
	257	}
5232d0de	258	UserCreateOutputObjects();
	259	}
	260
	261	void AliAnalysisTaskSE::Exec(Option_t* option)
	262	{
	263	//
	264	// Exec analysis of one event
259b7a8a	265	if (fDebug > 1) AliInfo("AliAnalysisTaskSE::Exec() \n");
04a79fa0	266
04a79fa0	267	if( fInputHandler ) {
259b7a8a	268	fEntry = fInputHandler->GetReadEntry();
04a79fa0	269	}
	270
	271
259b7a8a	272	else if( fMCEvent )
259b7a8a	273	fEntry = fMCEvent->Header()->GetEvent();
4d0a82af	274	if ( !((Entry()-1)%100) && fDebug > 0)
259b7a8a	275	AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
3f2431c4	276
	277	AliAODHandler* handler = (AliAODHandler*)
	278	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
c185e0db	279	AliAODInputHandler* aodH = dynamic_cast<AliAODInputHandler*>(fInputHandler);
	280
	281	if (handler && aodH) {
04a79fa0	282	fMCEvent = aodH->MCEvent();
5a922844	283	Bool_t merging = aodH->GetMergeEvents();
04a79fa0	284
c185e0db	285	if (!(handler->IsStandard()) && !(handler->AODIsReplicated())) {
	286	if ((handler->NeedsHeaderReplication()) && (fgAODHeader))
	287	{
61d5496b	288	// copy the contents by assigment
61d5496b	289	fgAODHeader = (dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader()));
daa81fe5	290	}
5a922844	291	if ((handler->NeedsTracksBranchReplication() \|\| merging) && (fgAODTracks))
c185e0db	292	{
	293	TClonesArray* tracks = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracks();
	294	new (fgAODTracks) TClonesArray(*tracks);
	295	}
417ab5ac	296	if ((handler->NeedsVerticesBranchReplication() \|\| merging) && (fgAODVertices))
c185e0db	297	{
	298	TClonesArray* vertices = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetVertices();
	299	new (fgAODVertices) TClonesArray(*vertices);
	300	}
	301	if ((handler->NeedsV0sBranchReplication()) && (fgAODV0s))
	302	{
113bc2bd	303	TClonesArray* v0s = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetV0s();
113bc2bd	304	new (fgAODV0s) TClonesArray(*v0s);
c185e0db	305	}
	306	if ((handler->NeedsTrackletsBranchReplication()) && (fgAODTracklets))
	307	{
61d5496b	308	fgAODTracklets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracklets();
c185e0db	309	}
	310	if ((handler->NeedsPMDClustersBranchReplication()) && (fgAODPMDClusters))
	311	{
113bc2bd	312	TClonesArray* pmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetPmdClusters();
113bc2bd	313	new (fgAODPMDClusters) TClonesArray(*pmdClusters);
c185e0db	314	}
5a922844	315	if ((handler->NeedsJetsBranchReplication() \|\| merging) && (fgAODJets))
c185e0db	316	{
113bc2bd	317	TClonesArray* jets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetJets();
113bc2bd	318	new (fgAODJets) TClonesArray(*jets);
c185e0db	319	}
	320	if ((handler->NeedsFMDClustersBranchReplication()) && (fgAODFMDClusters))
	321	{
113bc2bd	322	TClonesArray* fmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetFmdClusters();
113bc2bd	323	new (fgAODFMDClusters) TClonesArray(*fmdClusters);
c185e0db	324	}
5a922844	325	if ((handler->NeedsCaloClustersBranchReplication() \|\| merging) && (fgAODCaloClusters))
c185e0db	326	{
113bc2bd	327	TClonesArray* caloClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetCaloClusters();
	328	new (fgAODCaloClusters) TClonesArray(*caloClusters);
	329	}
	330
	331	if ((handler->NeedsMCParticlesBranchReplication() \|\| merging) && (fgAODMCParticles))
	332	{
	333	TClonesArray* mcParticles = (TClonesArray) ((dynamic_cast<AliAODEvent>(InputEvent()))->FindListObject("mcparticles"));
	334	new (fgAODMCParticles) TClonesArray(*mcParticles);
c185e0db	335	}
5a922844	336
	337	// Additional merging if needed
	338	if (merging) {
113bc2bd	339	// mcParticles
	340	TClonesArray* mcparticles = (TClonesArray*) ((aodH->GetEventToMerge())->FindListObject("mcparticles"));
	341	Int_t npart = mcparticles->GetEntries();
	342	Int_t nc = fgAODMCParticles->GetEntries();
	343	Int_t nc0 = nc;
	344
	345	for (Int_t i = 0; i < npart; i++) {
	346	AliAODMCParticle* particle = (AliAODMCParticle*) mcparticles->At(i);
c8de791b	347	new((fgAODMCParticles)[nc++]) AliAODMCParticle(particle);
113bc2bd	348	}
113bc2bd	349
5a922844	350	// tracks
	351	TClonesArray* tracks = aodH->GetEventToMerge()->GetTracks();
	352	Int_t ntr = tracks->GetEntries();
113bc2bd	353	nc = fgAODTracks->GetEntries();
5a922844	354	for (Int_t i = 0; i < ntr; i++) {
	355	AliAODTrack* track = (AliAODTrack*) tracks->At(i);
	356	AliAODTrack* newtrack = new((fgAODTracks)[nc++]) AliAODTrack(track);
c8de791b	357
113bc2bd	358	newtrack->SetLabel(newtrack->GetLabel() + nc0);
5a922844	359	}
c8de791b	360
	361	for (Int_t i = 0; i < nc; i++)
	362	{
	363	AliAODTrack* track = (AliAODTrack*) fgAODTracks->At(i);
	364	track->ResetBit(kIsReferenced);
	365	track->SetUniqueID(0);
	366	}
	367
	368
5a922844	369	// clusters
	370	TClonesArray* clusters = aodH->GetEventToMerge()->GetCaloClusters();
	371	Int_t ncl = clusters->GetEntries();
	372	nc = fgAODCaloClusters->GetEntries();
	373	for (Int_t i = 0; i < ncl; i++) {
	374	AliAODCaloCluster* cluster = (AliAODCaloCluster*) clusters->At(i);
c8de791b	375	new((fgAODCaloClusters)[nc++]) AliAODCaloCluster(cluster);
5a922844	376	}
	377	// cells
	378	AliAODCaloCells* cellsA = aodH->GetEventToMerge()->GetEMCALCells();
	379	Int_t ncells = cellsA->GetNumberOfCells();
	380	nc = fgAODEmcalCells->GetNumberOfCells();
	381
	382	for (Int_t i = 0; i < ncells; i++) {
	383	Int_t cn = cellsA->GetCellNumber(i);
	384	Int_t pos = fgAODEmcalCells->GetCellPosition(cn);
	385	if (pos >= 0) {
	386	Double_t amp = cellsA->GetAmplitude(i) + fgAODEmcalCells->GetAmplitude(pos);
	387	fgAODEmcalCells->SetCell(pos, cn, amp);
	388	} else {
	389	Double_t amp = cellsA->GetAmplitude(i);
	390	fgAODEmcalCells->SetCell(nc++, cn, amp);
	391	fgAODEmcalCells->Sort();
	392	}
	393	}
113bc2bd	394
	395
	396	} // merging
c185e0db	397
5a922844	398	handler->SetAODIsReplicated();
3f2431c4	399	}
	400	}
	401
4d0a82af	402	// Call the user analysis
5232d0de	403	UserExec(option);
60a04972	404	// Added protection in case the derived task is not an AOD producer.
	405	AliAnalysisDataSlot *out0 = GetOutputSlot(0);
	406	if (out0 && out0->IsConnected()) PostData(0, fTreeA);
5232d0de	407	}
5232d0de	408
4d0a82af	409	const char* AliAnalysisTaskSE::CurrentFileName()
	410	{
	411	// Returns the current file name
259b7a8a	412	if( fInputHandler )
	413	return fInputHandler->GetTree()->GetCurrentFile()->GetName();
	414	else if( fMCEvent )
	415	return ((AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()))->TreeK()->GetCurrentFile()->GetName();
8803dcb1	416	else return "";
4d0a82af	417	}
5232d0de	418
3cee83d7	419	void AliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj, const char *fname)
164e94ff	420	{
	421	// Add a new branch to the aod tree
	422	AliAODHandler* handler = (AliAODHandler*)
	423	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
	424	if (handler) {
3cee83d7	425	handler->AddBranch(cname, addobj, fname);
164e94ff	426	}
164e94ff	427	}
3cee83d7	428
	429	Bool_t AliAnalysisTaskSE::IsStandardAOD() const
	430	{
	431	// Check if the output AOD handler is configured for standard or delta AOD.
	432	// Users should first check that AODEvent() returns non-null.
	433	AliAODHandler* handler = (AliAODHandler*)
	434	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
	435	if (!handler) {
	436	Error("IsStandardAOD", "No AOD handler. Please use AODEvent() to check this first");
	437	return kTRUE;
	438	}
	439	return handler->IsStandard();
	440	}