[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 "AliAnalysisCuts.h"
#include "AliAnalysisDataSlot.h"

#include "AliESDEvent.h"
#include "AliESDfriend.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 "AliESDInputHandler.h"
#include "AliMCEvent.h"
#include "AliStack.h"
#include "AliLog.h"
#include "AliAODDimuon.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;
TClonesArray*    AliAnalysisTaskSE::fgAODDimuons        = NULL;

AliAnalysisTaskSE::AliAnalysisTaskSE():
    AliAnalysisTask(),
    fDebug(0),
    fEntry(0),
    fInputEvent(0x0),
    fESDfriend(0x0),
    fInputHandler(0x0),
    fOutputAOD(0x0),
    fMCEvent(0x0),
    fTreeA(0x0),
    fCurrentRunNumber(-1),
    fHistosQA(0x0),
    fSelectCollisions(0)
{
  // Default constructor
}

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

AliAnalysisTaskSE::AliAnalysisTaskSE(const AliAnalysisTaskSE& obj):
    AliAnalysisTask(obj),
    fDebug(0),
    fEntry(0),
    fInputEvent(0x0),
    fESDfriend(0x0),
    fInputHandler(0x0),
    fOutputAOD(0x0),
    fMCEvent(0x0),
    fTreeA(0x0),
    fCurrentRunNumber(-1),
    fHistosQA(0x0),
    fSelectCollisions(0)
{
// Copy constructor
    fDebug            = obj.fDebug;
    fEntry            = obj.fEntry;
    fInputEvent       = obj.fInputEvent;
    fESDfriend        = obj.fESDfriend;
    fInputHandler     = obj.fInputHandler;
    fOutputAOD        = obj.fOutputAOD;
    fMCEvent          = obj.fMCEvent;
    fTreeA            = obj.fTreeA;    
    fCurrentRunNumber = obj.fCurrentRunNumber;
    fHistosQA         = obj.fHistosQA;

}


AliAnalysisTaskSE& AliAnalysisTaskSE::operator=(const AliAnalysisTaskSE& other)
{
// Assignment
    AliAnalysisTask::operator=(other);
    fDebug            = other.fDebug;
    fEntry            = other.fEntry;
    fInputEvent       = other.fInputEvent;
    fESDfriend        = other.fESDfriend;
    fInputHandler     = other.fInputHandler;
    fOutputAOD        = other.fOutputAOD;
    fMCEvent          = other.fMCEvent;
    fTreeA            = other.fTreeA;    
    fCurrentRunNumber = other.fCurrentRunNumber;
    fHistosQA         = other.fHistosQA;
    fSelectCollisions = other.fSelectCollisions;
    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) {
	if ((fInputHandler->GetTree())->GetBranch("ESDfriend."))
	    fESDfriend = ((AliESDInputHandler*)fInputHandler)->GetESDfriend();

	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 (fOutputAOD && !(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);
	    }
	    if ((handler->NeedsDimuonsBranchReplication() || merging) && !(fgAODDimuons))      
	    {   
		if (fDebug > 1) AliInfo("Replicating dimuon branch\n");
		fgAODDimuons = new TClonesArray("AliAODDimuon",0);
		fgAODDimuons->SetName("dimuons");
		handler->AddBranch("TClonesArray", &fgAODDimuons);
	    }    

	    // 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 >= 10)
      printf("Task is active %5d\n", IsActive());
    
    if (fDebug > 1) AliInfo("AliAnalysisTaskSE::Exec() \n");
//
    AliAODHandler* handler = (AliAODHandler*) 
	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
    AliAODInputHandler* aodH = dynamic_cast<AliAODInputHandler*>(fInputHandler);
//
// Was event selected ?
    Bool_t isSelected = kTRUE;
    if( fInputHandler && fInputHandler->GetEventSelection() && fSelectCollisions) {
      isSelected = fInputHandler->IsEventSelected();
    }

    if (handler) handler->SetFillAOD(isSelected);

    if( fInputHandler ) {
	fEntry = fInputHandler->GetReadEntry();
	fESDfriend = ((AliESDInputHandler*)fInputHandler)->GetESDfriend();
    }
    

// Notify the change of run number
    if (InputEvent() && (InputEvent()->GetRunNumber() != fCurrentRunNumber)) {
	fCurrentRunNumber = InputEvent()->GetRunNumber();
	NotifyRun();
    }    
	   
    else if( fMCEvent )
       fEntry = fMCEvent->Header()->GetEvent(); 
    if ( !((Entry()-1)%100) && fDebug > 0) 
         AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));

    
    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);
	    }
	    
	    if ((handler->NeedsDimuonsBranchReplication() || merging) && (fgAODDimuons))
	    {
	        fgAODDimuons->Clear();
		TClonesArray& dimuons = *fgAODDimuons;
		TClonesArray& tracksnew = *fgAODTracks;
		
                Int_t nMuonTrack[10]; 
                for(Int_t imuon = 0; imuon < 10; imuon++) nMuonTrack[imuon] = 0;
                Int_t nMuons=0;
		for(Int_t ii=0; ii < fgAODTracks->GetEntries(); ii++){
		    AliAODTrack *track = (AliAODTrack*) fgAODTracks->At(ii);
		    if(track->IsMuonTrack()) {
			nMuonTrack[nMuons]= ii;
			nMuons++;
		    }  
		}
                Int_t jDimuons=0;
		if(nMuons >= 2){
		    for(Int_t i = 0; i < nMuons; i++){
			Int_t index0 = nMuonTrack[i];
			for(Int_t j = i+1; j < nMuons; j++){
			    Int_t index1 = nMuonTrack[j];
			    tracksnew.At(index0)->ResetBit(kIsReferenced);
			    tracksnew.At(index0)->SetUniqueID(0); 
			    tracksnew.At(index1)->ResetBit(kIsReferenced);
			    tracksnew.At(index1)->SetUniqueID(0);
			    new(dimuons[jDimuons++]) AliAODDimuon(tracksnew.At(index0),tracksnew.At(index1));
			}
		    }    
		}
	    }
	    
	    // 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    
    if (!fSelectCollisions || isSelected) 
	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();   
}

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