[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 "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),
    fCurrentRunNumber(-1),
    fHistosQA(0x0),
    fSelectCollisions(0)
{
  // Default constructor
}

AliAnalysisTaskSE::AliAnalysisTaskSE(const char* name):
    AliAnalysisTask(name, "AnalysisTaskSE"),
    fDebug(0),
    fEntry(0),
    fInputEvent(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),
    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;
    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;
    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) {
         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);
	    }
	    // 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");

    Bool_t isSelected = kTRUE;
    if( fInputHandler ) {
      isSelected = fInputHandler->IsEventSelected();
      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()));

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