[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisTaskSE.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

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

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


ClassImp(AliAnalysisTaskSE)

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


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

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

AliAnalysisTaskSE::AliAnalysisTaskSE(const AliAnalysisTaskSE& obj):
    AliAnalysisTask(obj),
    fDebug(0),
    fEntry(0),
    fInputEvent(0x0),
    fInputHandler(0x0),
    fOutputAOD(0x0),
    fMCEvent(0x0),
    fTreeA(0x0),
    fCurrentRunNumber(-1),
    fHistosQA(0x0)
{
// 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;
    return *this;
}


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

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

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

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

		fgAODPhosCells = new AliAODCaloCells();
		fgAODPhosCells->SetName("phosCells");
		handler->AddBranch("AliAODCaloCells", &fgAODPhosCells);
	    }
	    if ((handler->NeedsMCParticlesBranchReplication() || merging) && !(fgAODMCParticles))	  
	    {   
		if (fDebug > 1) AliInfo("Replicating MCParticles branch\n");
		fgAODMCParticles = new TClonesArray("AliAODMCParticle",500);
		fgAODMCParticles->SetName("mcparticles");
		handler->AddBranch("TClonesArray", &fgAODMCParticles);
	    }
	    // cache the pointerd in the AODEvent
	    fOutputAOD->GetStdContent();
	}
    } else {
	AliWarning("No AOD Event Handler connected.") ; 
    }
    UserCreateOutputObjects();
}

void AliAnalysisTaskSE::Exec(Option_t* option)
{
//
// Exec analysis of one event
    if (fDebug > 1) AliInfo("AliAnalysisTaskSE::Exec() \n");

    if( fInputHandler ) {
       fEntry = fInputHandler->GetReadEntry();
    }
    
	   
    else if( fMCEvent )
       fEntry = fMCEvent->Header()->GetEvent(); 
    if ( !((Entry()-1)%100) && fDebug > 0) 
         AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));

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

    if (handler && aodH) {
	fMCEvent = aodH->MCEvent();
	Bool_t merging = aodH->GetMergeEvents();
	
	if (!(handler->IsStandard()) && !(handler->AODIsReplicated())) {
	    if ((handler->NeedsHeaderReplication()) && (fgAODHeader))
	    {
	      // copy the contents by assigment
	      *fgAODHeader =  *(dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader()));
	    }
	    if ((handler->NeedsTracksBranchReplication() || merging) && (fgAODTracks))
	    {
		TClonesArray* tracks = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracks();
		new (fgAODTracks) TClonesArray(*tracks);
	    }
	    if ((handler->NeedsVerticesBranchReplication() || merging) && (fgAODVertices))
	    {
		TClonesArray* vertices = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetVertices();
		new (fgAODVertices) TClonesArray(*vertices);
	    }
	    if ((handler->NeedsV0sBranchReplication()) && (fgAODV0s))
	    {
		TClonesArray* v0s = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetV0s();
		new (fgAODV0s) TClonesArray(*v0s);
	    }
	    if ((handler->NeedsTrackletsBranchReplication()) && (fgAODTracklets))
	    {
	      *fgAODTracklets = *(dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracklets();
	    }
	    if ((handler->NeedsPMDClustersBranchReplication()) && (fgAODPMDClusters))
	    {
		TClonesArray* pmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetPmdClusters();
		new (fgAODPMDClusters) TClonesArray(*pmdClusters);
	    }
	    if ((handler->NeedsJetsBranchReplication() || merging) && (fgAODJets))
	    {
		TClonesArray* jets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetJets();
		new (fgAODJets) TClonesArray(*jets);
	    }
	    if ((handler->NeedsFMDClustersBranchReplication()) && (fgAODFMDClusters))
	    {
		TClonesArray* fmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetFmdClusters();
		new (fgAODFMDClusters) TClonesArray(*fmdClusters);
	    }
	    if ((handler->NeedsCaloClustersBranchReplication() || merging) && (fgAODCaloClusters))
	    {
		TClonesArray* caloClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetCaloClusters();
		new (fgAODCaloClusters) TClonesArray(*caloClusters);
	    }

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

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

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

// Call the user analysis    
    UserExec(option);
    // Added protection in case the derived task is not an AOD producer.
    AliAnalysisDataSlot *out0 = GetOutputSlot(0);
    if (out0 && out0->IsConnected()) PostData(0, fTreeA);    
}

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

void AliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj, const char *fname)
{
    // Add a new branch to the aod tree
    AliAODHandler* handler = (AliAODHandler*) 
	((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
    if (handler) {
	handler->AddBranch(cname, addobj, fname);
    }
}

Bool_t AliAnalysisTaskSE::IsStandardAOD() const
{
// Check if the output AOD handler is configured for standard or delta AOD.
// Users should first check that AODEvent() returns non-null.
    AliAODHandler* handler = (AliAODHandler*) 
         ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
    if (!handler) {
       Error("IsStandardAOD", "No AOD handler. Please use AODEvent() to check this first");
       return kTRUE;
    }
    return handler->IsStandard();   
}

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