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

// Notify the change of run number
    if (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))
	    {
		TClonesArray* dimuons = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetDimuons();
		new (fgAODDimuons) TClonesArray(*dimuons);
	    }

	    // 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
259b7a8a	302	if (fDebug > 1) AliInfo("AliAnalysisTaskSE::Exec() \n");
fdda6b64	303	//
	304	AliAODHandler* handler = (AliAODHandler*)
	305	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
	306	AliAODInputHandler* aodH = dynamic_cast<AliAODInputHandler*>(fInputHandler);
	307	//
	308	// Was event selected ?
bf666461	309	Bool_t isSelected = kTRUE;
9b98c4df	310	if( fInputHandler && fInputHandler->GetEventSelection() && fSelectCollisions) {
bf666461	311	isSelected = fInputHandler->IsEventSelected();
04a79fa0	312	}
9b98c4df	313
fdda6b64	314	if (handler) handler->SetFillAOD(isSelected);
9b98c4df	315
9b98c4df	316	if( fInputHandler ) fEntry = fInputHandler->GetReadEntry();
fdda6b64	317
bf666461	318
39b02a2e	319	// Notify the change of run number
	320	if (InputEvent()->GetRunNumber() != fCurrentRunNumber) {
	321	fCurrentRunNumber = InputEvent()->GetRunNumber();
	322	NotifyRun();
	323	}
04a79fa0	324
259b7a8a	325	else if( fMCEvent )
259b7a8a	326	fEntry = fMCEvent->Header()->GetEvent();
4d0a82af	327	if ( !((Entry()-1)%100) && fDebug > 0)
259b7a8a	328	AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
3f2431c4	329
fdda6b64	330
fdda6b64	331
c185e0db	332
c185e0db	333	if (handler && aodH) {
04a79fa0	334	fMCEvent = aodH->MCEvent();
5a922844	335	Bool_t merging = aodH->GetMergeEvents();
04a79fa0	336
c185e0db	337	if (!(handler->IsStandard()) && !(handler->AODIsReplicated())) {
	338	if ((handler->NeedsHeaderReplication()) && (fgAODHeader))
	339	{
61d5496b	340	// copy the contents by assigment
61d5496b	341	fgAODHeader = (dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader()));
daa81fe5	342	}
5a922844	343	if ((handler->NeedsTracksBranchReplication() \|\| merging) && (fgAODTracks))
c185e0db	344	{
	345	TClonesArray* tracks = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracks();
	346	new (fgAODTracks) TClonesArray(*tracks);
	347	}
417ab5ac	348	if ((handler->NeedsVerticesBranchReplication() \|\| merging) && (fgAODVertices))
c185e0db	349	{
	350	TClonesArray* vertices = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetVertices();
	351	new (fgAODVertices) TClonesArray(*vertices);
	352	}
	353	if ((handler->NeedsV0sBranchReplication()) && (fgAODV0s))
	354	{
113bc2bd	355	TClonesArray* v0s = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetV0s();
113bc2bd	356	new (fgAODV0s) TClonesArray(*v0s);
c185e0db	357	}
	358	if ((handler->NeedsTrackletsBranchReplication()) && (fgAODTracklets))
	359	{
61d5496b	360	fgAODTracklets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracklets();
c185e0db	361	}
	362	if ((handler->NeedsPMDClustersBranchReplication()) && (fgAODPMDClusters))
	363	{
113bc2bd	364	TClonesArray* pmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetPmdClusters();
113bc2bd	365	new (fgAODPMDClusters) TClonesArray(*pmdClusters);
c185e0db	366	}
5a922844	367	if ((handler->NeedsJetsBranchReplication() \|\| merging) && (fgAODJets))
c185e0db	368	{
113bc2bd	369	TClonesArray* jets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetJets();
113bc2bd	370	new (fgAODJets) TClonesArray(*jets);
c185e0db	371	}
	372	if ((handler->NeedsFMDClustersBranchReplication()) && (fgAODFMDClusters))
	373	{
113bc2bd	374	TClonesArray* fmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetFmdClusters();
113bc2bd	375	new (fgAODFMDClusters) TClonesArray(*fmdClusters);
c185e0db	376	}
5a922844	377	if ((handler->NeedsCaloClustersBranchReplication() \|\| merging) && (fgAODCaloClusters))
c185e0db	378	{
113bc2bd	379	TClonesArray* caloClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetCaloClusters();
	380	new (fgAODCaloClusters) TClonesArray(*caloClusters);
	381	}
	382
	383	if ((handler->NeedsMCParticlesBranchReplication() \|\| merging) && (fgAODMCParticles))
	384	{
	385	TClonesArray* mcParticles = (TClonesArray) ((dynamic_cast<AliAODEvent>(InputEvent()))->FindListObject("mcparticles"));
	386	new (fgAODMCParticles) TClonesArray(*mcParticles);
c185e0db	387	}
866d8d78	388
	389	if ((handler->NeedsDimuonsBranchReplication() \|\| merging) && (fgAODDimuons))
	390	{
	391	TClonesArray* dimuons = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetDimuons();
	392	new (fgAODDimuons) TClonesArray(*dimuons);
	393	}
	394
5a922844	395	// Additional merging if needed
5a922844	396	if (merging) {
113bc2bd	397	// mcParticles
	398	TClonesArray* mcparticles = (TClonesArray*) ((aodH->GetEventToMerge())->FindListObject("mcparticles"));
	399	Int_t npart = mcparticles->GetEntries();
	400	Int_t nc = fgAODMCParticles->GetEntries();
	401	Int_t nc0 = nc;
	402
	403	for (Int_t i = 0; i < npart; i++) {
	404	AliAODMCParticle* particle = (AliAODMCParticle*) mcparticles->At(i);
c8de791b	405	new((fgAODMCParticles)[nc++]) AliAODMCParticle(particle);
113bc2bd	406	}
113bc2bd	407
5a922844	408	// tracks
	409	TClonesArray* tracks = aodH->GetEventToMerge()->GetTracks();
	410	Int_t ntr = tracks->GetEntries();
113bc2bd	411	nc = fgAODTracks->GetEntries();
5a922844	412	for (Int_t i = 0; i < ntr; i++) {
	413	AliAODTrack* track = (AliAODTrack*) tracks->At(i);
	414	AliAODTrack* newtrack = new((fgAODTracks)[nc++]) AliAODTrack(track);
c8de791b	415
113bc2bd	416	newtrack->SetLabel(newtrack->GetLabel() + nc0);
5a922844	417	}
c8de791b	418
	419	for (Int_t i = 0; i < nc; i++)
	420	{
	421	AliAODTrack* track = (AliAODTrack*) fgAODTracks->At(i);
	422	track->ResetBit(kIsReferenced);
	423	track->SetUniqueID(0);
	424	}
	425
	426
5a922844	427	// clusters
	428	TClonesArray* clusters = aodH->GetEventToMerge()->GetCaloClusters();
	429	Int_t ncl = clusters->GetEntries();
	430	nc = fgAODCaloClusters->GetEntries();
	431	for (Int_t i = 0; i < ncl; i++) {
	432	AliAODCaloCluster* cluster = (AliAODCaloCluster*) clusters->At(i);
c8de791b	433	new((fgAODCaloClusters)[nc++]) AliAODCaloCluster(cluster);
5a922844	434	}
	435	// cells
	436	AliAODCaloCells* cellsA = aodH->GetEventToMerge()->GetEMCALCells();
	437	Int_t ncells = cellsA->GetNumberOfCells();
	438	nc = fgAODEmcalCells->GetNumberOfCells();
	439
	440	for (Int_t i = 0; i < ncells; i++) {
	441	Int_t cn = cellsA->GetCellNumber(i);
	442	Int_t pos = fgAODEmcalCells->GetCellPosition(cn);
	443	if (pos >= 0) {
	444	Double_t amp = cellsA->GetAmplitude(i) + fgAODEmcalCells->GetAmplitude(pos);
	445	fgAODEmcalCells->SetCell(pos, cn, amp);
	446	} else {
	447	Double_t amp = cellsA->GetAmplitude(i);
	448	fgAODEmcalCells->SetCell(nc++, cn, amp);
	449	fgAODEmcalCells->Sort();
	450	}
	451	}
113bc2bd	452
	453
	454	} // merging
c185e0db	455
5a922844	456	handler->SetAODIsReplicated();
3f2431c4	457	}
	458	}
	459
4d0a82af	460	// Call the user analysis
bf666461	461	if (!fSelectCollisions \|\| isSelected)
90a9a634	462	UserExec(option);
	463
	464	// Added protection in case the derived task is not an AOD producer.
60a04972	465	AliAnalysisDataSlot *out0 = GetOutputSlot(0);
60a04972	466	if (out0 && out0->IsConnected()) PostData(0, fTreeA);
5232d0de	467	}
5232d0de	468
4d0a82af	469	const char* AliAnalysisTaskSE::CurrentFileName()
	470	{
	471	// Returns the current file name
259b7a8a	472	if( fInputHandler )
	473	return fInputHandler->GetTree()->GetCurrentFile()->GetName();
	474	else if( fMCEvent )
	475	return ((AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()))->TreeK()->GetCurrentFile()->GetName();
8803dcb1	476	else return "";
4d0a82af	477	}
5232d0de	478
3cee83d7	479	void AliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj, const char *fname)
164e94ff	480	{
	481	// Add a new branch to the aod tree
	482	AliAODHandler* handler = (AliAODHandler*)
	483	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
	484	if (handler) {
3cee83d7	485	handler->AddBranch(cname, addobj, fname);
164e94ff	486	}
164e94ff	487	}
3cee83d7	488
	489	Bool_t AliAnalysisTaskSE::IsStandardAOD() const
	490	{
	491	// Check if the output AOD handler is configured for standard or delta AOD.
	492	// Users should first check that AODEvent() returns non-null.
	493	AliAODHandler* handler = (AliAODHandler*)
	494	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
	495	if (!handler) {
	496	Error("IsStandardAOD", "No AOD handler. Please use AODEvent() to check this first");
	497	return kTRUE;
	498	}
	499	return handler->IsStandard();
	500	}
1ec2c8dc	501
	502	Bool_t AliAnalysisTaskSE::Notify()
	503	{
9a587f77	504	return (UserNotify());
1ec2c8dc	505	}
	506
	507