Coverity fix.

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

diff --git a/ANALYSIS/AliAnalysisTaskSE.cxx b/ANALYSIS/AliAnalysisTaskSE.cxx
index 65e8e4b725331726bab71cc6c55889e8eac1d9e8..abbe975e4eb747004384393811756486d9388d3f 100644 (file)
--- a/ANALYSIS/AliAnalysisTaskSE.cxx
+++ b/ANALYSIS/AliAnalysisTaskSE.cxx
@@ -40,6 +40,7 @@
 #include "AliAODInputHandler.h"
 #include "AliMCEventHandler.h"
 #include "AliInputEventHandler.h"
+#include "AliMultiInputEventHandler.h"
 #include "AliESDInputHandler.h"
 #include "AliMCEvent.h"
 #include "AliStack.h"
@@ -76,7 +77,9 @@ AliAnalysisTaskSE::AliAnalysisTaskSE():
     fTreeA(0x0),
     fCurrentRunNumber(-1),
     fHistosQA(0x0),
-    fOfflineTriggerMask(0)
+    fOfflineTriggerMask(0),
+    fMultiInputHandler(0),
+    fMCEventHandler(0)
 {
   // Default constructor
 }
@@ -93,7 +96,9 @@ AliAnalysisTaskSE::AliAnalysisTaskSE(const char* name):
     fTreeA(0x0),
     fCurrentRunNumber(-1),
     fHistosQA(0x0),
-    fOfflineTriggerMask(0)
+    fOfflineTriggerMask(0),
+    fMultiInputHandler(0),
+    fMCEventHandler(0)
 {
   // Default constructor
     DefineInput (0, TChain::Class());
@@ -112,7 +117,9 @@ AliAnalysisTaskSE::AliAnalysisTaskSE(const AliAnalysisTaskSE& obj):
     fTreeA(0x0),
     fCurrentRunNumber(-1),
     fHistosQA(0x0),
-    fOfflineTriggerMask(0)
+    fOfflineTriggerMask(0),
+    fMultiInputHandler(obj.fMultiInputHandler),
+    fMCEventHandler(obj.fMCEventHandler)
 {
 // Copy constructor
     fDebug            = obj.fDebug;
@@ -144,6 +151,8 @@ AliAnalysisTaskSE& AliAnalysisTaskSE::operator=(const AliAnalysisTaskSE& other)
     fCurrentRunNumber = other.fCurrentRunNumber;
     fHistosQA         = other.fHistosQA;
     fOfflineTriggerMask = other.fOfflineTriggerMask;
+    fMultiInputHandler  = other.fMultiInputHandler;
+    fMCEventHandler     = other.fMCEventHandler;
     return *this;
 }
 
@@ -152,20 +161,10 @@ 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();
-    } 
-    
+
+   // Connect input handlers (multi input handler is handled)
+   ConnectMultiHandler();
+
     if (fInputHandler) {
        if ((fInputHandler->GetTree())->GetBranch("ESDfriend."))
            fESDfriend = ((AliESDInputHandler*)fInputHandler)->GetESDfriend();
@@ -177,6 +176,8 @@ void AliAnalysisTaskSE::ConnectInputData(Option_t* /*option*/)
          AliError("No Input Event Handler connected") ; 
          return ; 
     }
+    // Disconnect multi handler
+    DisconnectMultiHandler();
 }
 
 void AliAnalysisTaskSE::CreateOutputObjects()
@@ -297,6 +298,9 @@ void AliAnalysisTaskSE::Exec(Option_t* option)
 {
 //
 // Exec analysis of one event
+
+    ConnectMultiHandler();
+
     if ( fDebug >= 10)
       printf("Task is active %5d\n", IsActive());
     
@@ -341,56 +345,57 @@ void AliAnalysisTaskSE::Exec(Option_t* option)
     if (handler && aodH) {
        fMCEvent = aodH->MCEvent();
        Bool_t merging = aodH->GetMergeEvents();
-       
-       if (!(handler->IsStandard()) && !(handler->AODIsReplicated())) {
+       AliAODEvent* aod = dynamic_cast<AliAODEvent*>(InputEvent());
+
+       if (aod && !(handler->IsStandard()) && !(handler->AODIsReplicated())) {
            if ((handler->NeedsHeaderReplication()) && (fgAODHeader))
            {
              // copy the contents by assigment
-             *fgAODHeader =  *(dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader()));
+             *fgAODHeader =  *(aod->GetHeader());
            }
            if ((handler->NeedsTracksBranchReplication() || merging) && (fgAODTracks))
            {
-               TClonesArray* tracks = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracks();
+               TClonesArray* tracks = aod->GetTracks();
                new (fgAODTracks) TClonesArray(*tracks);
            }
            if ((handler->NeedsVerticesBranchReplication() || merging) && (fgAODVertices))
            {
-               TClonesArray* vertices = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetVertices();
+               TClonesArray* vertices = aod->GetVertices();
                new (fgAODVertices) TClonesArray(*vertices);
            }
            if ((handler->NeedsV0sBranchReplication()) && (fgAODV0s))
            {
-               TClonesArray* v0s = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetV0s();
+               TClonesArray* v0s = aod->GetV0s();
                new (fgAODV0s) TClonesArray(*v0s);
            }
            if ((handler->NeedsTrackletsBranchReplication()) && (fgAODTracklets))
            {
-             *fgAODTracklets = *(dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracklets();
+             *fgAODTracklets = *aod->GetTracklets();
            }
            if ((handler->NeedsPMDClustersBranchReplication()) && (fgAODPMDClusters))
            {
-               TClonesArray* pmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetPmdClusters();
+               TClonesArray* pmdClusters = aod->GetPmdClusters();
                new (fgAODPMDClusters) TClonesArray(*pmdClusters);
            }
            if ((handler->NeedsJetsBranchReplication() || merging) && (fgAODJets))
            {
-               TClonesArray* jets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetJets();
+               TClonesArray* jets = aod->GetJets();
                new (fgAODJets) TClonesArray(*jets);
            }
            if ((handler->NeedsFMDClustersBranchReplication()) && (fgAODFMDClusters))
            {
-               TClonesArray* fmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetFmdClusters();
+               TClonesArray* fmdClusters = aod->GetFmdClusters();
                new (fgAODFMDClusters) TClonesArray(*fmdClusters);
            }
            if ((handler->NeedsCaloClustersBranchReplication() || merging) && (fgAODCaloClusters))
            {
-               TClonesArray* caloClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetCaloClusters();
+               TClonesArray* caloClusters = aod->GetCaloClusters();
                new (fgAODCaloClusters) TClonesArray(*caloClusters);
            }
 
            if ((handler->NeedsMCParticlesBranchReplication() || merging) && (fgAODMCParticles))
            {
-               TClonesArray* mcParticles = (TClonesArray*) ((dynamic_cast<AliAODEvent*>(InputEvent()))->FindListObject("mcparticles"));
+               TClonesArray* mcParticles = (TClonesArray*) (aod->FindListObject("mcparticles"));
                new (fgAODMCParticles) TClonesArray(*mcParticles);
            }
            
@@ -491,20 +496,19 @@ void AliAnalysisTaskSE::Exec(Option_t* option)
     }
 
 // Call the user analysis    
-    AliMCEventHandler*    mcH = 0;
-    mcH = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
-
-    if (!mcH) {
+    if (!fMCEventHandler) {
        if (isSelected) 
            UserExec(option);
     } else {
-       if (isSelected && (mcH->InitOk())) 
+       if (isSelected && (fMCEventHandler->InitOk())) 
            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);    
+    
+    DisconnectMultiHandler();
 }
 
 const char* AliAnalysisTaskSE::CurrentFileName()
@@ -573,3 +577,30 @@ void AliAnalysisTaskSE::LoadBranches() const
   TObject *obj;
   while ((obj=next())) mgr->LoadBranch(obj->GetName());
 }
+
+
+//_________________________________________________________________________________________________
+void AliAnalysisTaskSE::ConnectMultiHandler()
+{
+   //
+   // Connect MultiHandler
+   //
+   fInputHandler = (AliInputEventHandler *)((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
+   fMultiInputHandler = dynamic_cast<AliMultiInputEventHandler *>(fInputHandler);
+   if (fMultiInputHandler) {
+      fInputHandler = dynamic_cast<AliInputEventHandler *>(fMultiInputHandler->GetFirstInputEventHandler());
+      fMCEventHandler = dynamic_cast<AliMCEventHandler *>(fMultiInputHandler->GetFirstMCEventHandler());
+   } else { 
+      fMCEventHandler = dynamic_cast<AliMCEventHandler *>((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
+   }
+   if (fMCEventHandler) fMCEvent = fMCEventHandler->MCEvent();
+}
+
+//_________________________________________________________________________________________________
+void AliAnalysisTaskSE::DisconnectMultiHandler()
+{
+   //
+   // Disconnect MultiHandler
+   //
+   if (fMultiInputHandler) fInputHandler = fMultiInputHandler;
+}