ANALYSIS and ANALYSIScalib
[u/mrichter/AliRoot.git] / 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