ANALYSIS/AliAnalysisTaskME.cxx

   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 "AliAnalysisTaskME.h"
  26 #include "AliAnalysisManager.h"
  27 #include "AliAnalysisDataSlot.h"
  28 #include "AliAODEvent.h"
  29 #include "AliVEvent.h"
  30 #include "AliAODHandler.h"
  31 #include "AliMultiEventInputHandler.h"
  32 #include "AliLog.h"
  33
  34
  35 ClassImp(AliAnalysisTaskME)
  36
  37 ////////////////////////////////////////////////////////////////////////
  38
  39 AliAnalysisTaskME::AliAnalysisTaskME():
  40     AliAnalysisTask(),
  41     fDebug(0),
  42     fEntry(0),
  43     fFreshBufferOnly(kFALSE),
  44     fInputHandler(0x0),
  45     fOutputAOD(0x0),
  46     fTreeA(0x0),
  47     fOfflineTriggerMask(0)
  48 {
  49   // Default constructor
  50 }
  51
  52 AliAnalysisTaskME::AliAnalysisTaskME(const char* name):
  53     AliAnalysisTask(name, "AnalysisTaskME"),
  54     fDebug(0),
  55     fEntry(0),
  56     fFreshBufferOnly(kFALSE),
  57     fInputHandler(0x0),
  58     fOutputAOD(0x0),
  59     fTreeA(0x0),
  60     fOfflineTriggerMask(0)
  61 {
  62   // Default constructor
  63     DefineInput (0, TChain::Class());
  64     DefineOutput(0,  TTree::Class());
  65 }
  66
  67 AliAnalysisTaskME::AliAnalysisTaskME(const AliAnalysisTaskME& obj):
  68     AliAnalysisTask(obj),
  69     fDebug(0),
  70     fEntry(0),
  71     fFreshBufferOnly(kFALSE),
  72     fInputHandler(0x0),
  73     fOutputAOD(0x0),
  74     fTreeA(0x0),
  75     fOfflineTriggerMask(0)
  76 {
  77 // Copy constructor
  78     fDebug        = obj.fDebug;
  79     fEntry        = obj.fEntry;
  80     fInputHandler = obj.fInputHandler;
  81     fOutputAOD    = obj.fOutputAOD;
  82     fTreeA        = obj.fTreeA;
  83     fOfflineTriggerMask = obj.fOfflineTriggerMask;
  84 }
  85
  86
  87 AliAnalysisTaskME& AliAnalysisTaskME::operator=(const AliAnalysisTaskME& other)
  88 {
  89 // Assignment
  90     if (this != &other) {
  91         AliAnalysisTask::operator=(other);
  92         fDebug           = other.fDebug;
  93         fEntry           = other.fEntry;
  94         fFreshBufferOnly = other.fFreshBufferOnly;
  95         fInputHandler    = other.fInputHandler;
  96         fOutputAOD       = other.fOutputAOD;
  97         fTreeA           = other.fTreeA;
  98         fOfflineTriggerMask = other.fOfflineTriggerMask;
  99     }
 100     return *this;
 101 }
 102
 103
 104 void AliAnalysisTaskME::ConnectInputData(Option_t* /*option*/)
 105 {
 106 // Connect the input data
 107     if (fDebug > 1) printf("AnalysisTaskME::ConnectInputData() \n");
 108 //
 109 //  Multi AOD
 110 //
 111     fInputHandler = dynamic_cast<AliMultiEventInputHandler*>
 112         ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
 113     if (fInputHandler == 0) {
 114         AliFatal("Event Handler has to be MultiEventInputHandler !");
 115     } else {
 116         // Check that we have an event pool
 117         if (!fInputHandler->GetEventPool()) {
 118             fInputHandler->SetEventPool(AliAnalysisManager::GetAnalysisManager()->GetEventPool());
 119             if (!fInputHandler->GetEventPool())
 120                 AliFatal("MultiEventInputHandler has no EventPool connected !");
 121         }
 122     }
 123 }
 124
 125 void AliAnalysisTaskME::CreateOutputObjects()
 126 {
 127 // Create the output container
 128 //
 129 //  Default AOD
 130     if (fDebug > 1) printf("AnalysisTaskME::CreateOutPutData() \n");
 131
 132     AliAODHandler* handler = (AliAODHandler*)
 133         ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
 134
 135     if (handler) {
 136         fOutputAOD   = handler->GetAOD();
 137         fTreeA = handler->GetTree();
 138     } else {
 139         AliWarning("No AOD Event Handler connected.") ;
 140     }
 141     UserCreateOutputObjects();
 142 }
 143
 144 void AliAnalysisTaskME::Exec(Option_t* option)
 145 {
 146 //
 147 // Exec analysis of one event
 148
 149     if (fDebug > 1) AliInfo("AliAnalysisTaskME::Exec() \n");
 150     if( fInputHandler )
 151        fEntry = fInputHandler->GetReadEntry();
 152     if ( !((Entry()-1)%100) && fDebug > 0)
 153          AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
 154
 155     AliAODHandler* outputHandler = (AliAODHandler*)
 156         ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
 157 //
 158 // Was event selected ? If no event selection mechanism, the event SHOULD be selected (AG)
 159     UInt_t isSelected = AliVEvent::kAny;
 160     if(fInputHandler && fInputHandler->GetEventSelection()) {
 161       // Get the actual offline trigger mask for the event and AND it with the
 162       // requested mask. If no mask requested select by default the event.
 163       if (fOfflineTriggerMask)
 164         isSelected = fOfflineTriggerMask & fInputHandler->IsEventSelected();
 165     }
 166
 167     if (!isSelected) {
 168         if (fDebug > 1) AliInfo("Event rejected \n");
 169         fInputHandler->EventSkipped();
 170         return;
 171     }
 172 // Call the user analysis
 173
 174     if (fInputHandler && fInputHandler->IsBufferReady()) {
 175         if ((fFreshBufferOnly && fInputHandler->IsFreshBuffer()) || !fFreshBufferOnly)
 176         {
 177             if (outputHandler) outputHandler->SetFillAOD(kTRUE);
 178             UserExec(option);
 179             // Added protection in case the derived task is not an AOD producer.
 180             AliAnalysisDataSlot *out0 = GetOutputSlot(0);
 181             if (out0 && out0->IsConnected()) PostData(0, fTreeA);
 182         } else {
 183             if (outputHandler) outputHandler->SetFillAOD(kFALSE);
 184         }
 185     } else {
 186         AliInfo(Form("Waiting for buffer to be ready !\n"));
 187     }
 188 }
 189
 190 const char* AliAnalysisTaskME::CurrentFileName()
 191 {
 192 // Returns the current file name
 193     if(fInputHandler )
 194         return fInputHandler->GetTree()->GetCurrentFile()->GetName();
 195     else return "";
 196 }
 197
 198 void AliAnalysisTaskME::AddAODBranch(const char* cname, void* addobj, const char *fname)
 199 {
 200     // Add a new branch to the aod tree
 201     AliAODHandler* handler = (AliAODHandler*)
 202         ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
 203     if (handler) {
 204         handler->AddBranch(cname, addobj, fname);
 205     }
 206 }
 207
 208 AliVEvent*  AliAnalysisTaskME::GetEvent(Int_t iev)
 209 {
 210     // Get an event from the input handler
 211     return (fInputHandler->GetEvent(iev));
 212 }
 213