Updated macros for PHOS alignment calculation
[u/mrichter/AliRoot.git] / HLT / EMCAL / AliHLTEMCALAgent.cxx
CommitLineData
2f0cecb4 1// $Id$
8db5dd01 2
3//**************************************************************************
4//* This file is property of and copyright by the ALICE HLT Project *
5//* ALICE Experiment at CERN, All rights reserved. *
6//* *
7//* Primary Authors: Federico Ronchetti *
8//* *
9//* Permission to use, copy, modify and distribute this software and its *
10//* documentation strictly for non-commercial purposes is hereby granted *
11//* without fee, provided that the above copyright notice appears in all *
12//* copies and that both the copyright notice and this permission notice *
13//* appear in the supporting documentation. The authors make no claims *
14//* about the suitability of this software for any purpose. It is *
15//* provided "as is" without express or implied warranty. *
16//**************************************************************************
17
18/** @file AliHLTEMCALAgent.cxx
19 @author Federico Ronchetti
20 @date
21 @brief Agent of the libAliHLTEMCAL library
22 */
23
24#include "AliHLTEMCALAgent.h"
25#include "AliHLTConfiguration.h"
26#include "AliHLTEMCALDefinitions.h"
27#include "AliHLTOUT.h"
28#include "AliHLTOUTHandlerChain.h"
6c0647cd 29#include "AliHLTErrorGuard.h"
8db5dd01 30#include "AliRunLoader.h"
b0692a71 31#include "AliDAQ.h"
8db5dd01 32#include "AliCDBManager.h"
33#include "AliCDBEntry.h"
34
35
36// #include "AliHLTEMCALConstant.h"
37#include "AliHLTEMCALConstants.h"
38#include "AliHLTEMCALMapper.h"
39
40/** global instance for agent registration */
41AliHLTEMCALAgent gAliHLTEMCALAgent;
42
43// component headers
44//#include "AliHLTEMCALCalibrationComponent.h"
45#include "AliHLTCaloClusterAnalyser.h"
46#include "AliHLTEMCALClusterizerComponent.h"
47#include "AliHLTEMCALDigitMakerComponent.h"
48//#include "AliHLTEMCALESDEntriesMakerComponent.h"
49//#include "AliHLTEMCALHistogramProducerComponent.h"
50//#include "AliHLTEMCALModuleCalibrationProcessorComponent.h"
51//#include "AliHLTEMCALMonitorTriggerComponent.h"
52#include "AliHLTEMCALRawAnalyzerComponent.h"
53#include "AliHLTEMCALRawAnalyzerCrudeComponent.h"
54#include "AliHLTEMCALRawAnalyzerPeakFinderComponent.h"
55//#include "AliHLTEMCALRcuCalibrationProcessorComponent.h"
56//#include "AliHLTEMCALRcuDAComponent.h"
6c0647cd 57#include "AliHLTEMCALRawAnalyzerLMSComponent.h"
58#include "AliHLTEMCALRawAnalyzerFastFitComponent.h"
59#include "AliHLTEMCALRawAnalyzerNNComponent.h"
60#include "AliHLTEMCALClusterizerComponentNbyN.h"
8db5dd01 61
62/** ROOT macro for the implementation of ROOT specific class methods */
63ClassImp(AliHLTEMCALAgent)
64
6c0647cd 65AliHLTEMCALAgent::AliHLTEMCALAgent() : AliHLTModuleAgent("EMCAL")
66 , fRawDataHandler(NULL)
67 , fMappers()
8db5dd01 68{
69 // see header file for class documentation
70 // or
71 // refer to README to build package
72 // or
73 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
74}
75
76AliHLTEMCALAgent::~AliHLTEMCALAgent()
77{
78 // see header file for class documentation
79}
80
b0692a71 81UInt_t AliHLTEMCALAgent::GetDetectorMask() const
82{
83 return AliDAQ::kEMCAL;
84}
85
8db5dd01 86int AliHLTEMCALAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
87 AliRawReader* /*rawReader*/,
88 AliRunLoader* /*runloader*/) const
89{
90 // see header file for class documentation
91 if (handler)
92 {
93 // const char* cdbEntry="EMCAL/Calib/Parameters";
94 //AliCDBManager* pMan=AliCDBManager::Instance();
95 //AliEMCALParam* pEMCALParam=NULL;
96
97 // if (pMan)
98 // {
99 // AliCDBEntry *pEntry = pMan->Get(cdbEntry);
100 // if (pEntry &&
101 // pEntry->GetObject() &&
102 // (pEMCALParam=dynamic_cast<AliEMCALParam*>(pEntry->GetObject())))
103 // {
104 // } else
105 // {
106 // HLTWarning("can not load AliEMCALParam from CDB entry %s", cdbEntry);
107 // }
108 // }
109
110 int moduleStart = 0;
111 int moduleEnd = 9;
112
113 int rcuStart = 0;
114 int rcuEnd = 1;
115
116 Int_t rcusPerModule = 2;
117 Int_t ddlOffset = 4608;
118
119 TString mergerInput;
120 TString sinkClusterInput;
121 TString emInput;
122
1bfac818 123 for (int module = moduleStart; module <= moduleEnd; module++)
8db5dd01 124 {
125 TString clInput;
126
127 for(int rcu = rcuStart; rcu < rcuEnd; rcu++)
128 {
129 TString arg, publisher, ra, dm;
130 // raw data publisher components
131 publisher.Form("EMCAL-RP_%02d_%d", module, rcu);
132 arg.Form("-verbose -minid %d -datatype 'DDL_RAW ' 'EMCA' -dataspec 0x%x ", ddlOffset + module*(rcusPerModule) + rcu, 0x1 << (module*rcusPerModule + rcu));
133
134 handler->CreateConfiguration(publisher.Data(), "AliRawReaderPublisher", NULL , arg.Data());
135
136 // Raw analyzer
137 arg = "";
138 ra.Form("EMCAL-RA_%02d_%d", module, rcu);
139 handler->CreateConfiguration(ra.Data(), "EmcalRawCrude", publisher.Data(), arg.Data());
140
141 // digit maker components
142 dm.Form("EMCAL-DM_%02d_%d", module, rcu);
143 arg="";
144 arg.Form("-sethighgainfactor 0.0153 -setlowgainfactor 0.2448 -setdigitthresholds 0.005 0.002");
145 handler->CreateConfiguration(dm.Data(), "EmcalDigitMaker", ra.Data(), arg.Data());
146
147 if(clInput.Length() > 0) clInput += " ";
148 clInput+=dm;
149 }
150
151 TString arg, cl, ca;
152
153 cl.Form("EMCAL-CF_%02d", module);
154 arg = "";
155 arg.Form("-digitthreshold 0.005 -recpointthreshold 0.1 -modulemode");
156 handler->CreateConfiguration(cl.Data(), "EmcalClusterizer", clInput.Data(), arg.Data());
157
158 //ca.Form("EMCAL-CA_%02d", module);
159 //arg = " ";
160 //handler->CreateConfiguration(ca.Data(), "CaloClusterAnalyser", cl.Data(), arg.Data());
161
162 if(emInput.Length() > 0) emInput += " ";
163 emInput += ca;
164 }
165
166
167 TString arg, em;
168
169 // tracker finder components
170
171 // later
172 // em.Form("EMCAL-EM");
173 //arg = " ";
174 //handler->CreateConfiguration(em.Data(), "EmcalEsdEntriesMaker", emInput.Data(), " ");
175
176 }
177
178 return 0;
179}
180
181const char* AliHLTEMCALAgent::GetReconstructionChains(AliRawReader* /*rawReader*/,
182 AliRunLoader* runloader) const
183{
184 // see header file for class documentation
185 if (runloader) {
186 // reconstruction chains for AliRoot simulation
187 // Note: run loader is only available while running embedded into
188 // AliRoot simulation
189
caa5984b 190 // if (runloader->GetLoader("EMCALLoader") != NULL)
191 // return "EMCAL-EM";
8db5dd01 192 }
193 return NULL;
194}
195
196const char* AliHLTEMCALAgent::GetRequiredComponentLibraries() const
197{
198 // see header file for class documentation
199 return NULL;
200}
201
202int AliHLTEMCALAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
203{
204 // see header file for class documentation
205 if (!pHandler) return -EINVAL;
206
207 pHandler->AddComponent(new AliHLTEMCALRawAnalyzerCrudeComponent);
6c0647cd 208 pHandler->AddComponent(new AliHLTEMCALRawAnalyzerLMSComponent);
209 pHandler->AddComponent(new AliHLTEMCALRawAnalyzerPeakFinderComponent);
210 pHandler->AddComponent(new AliHLTEMCALRawAnalyzerFastFitComponent);
211 pHandler->AddComponent(new AliHLTEMCALRawAnalyzerNNComponent);
8db5dd01 212 pHandler->AddComponent(new AliHLTEMCALDigitMakerComponent);
213 pHandler->AddComponent(new AliHLTEMCALClusterizerComponent);
6c0647cd 214 pHandler->AddComponent(new AliHLTEMCALClusterizerComponentNbyN);
8db5dd01 215 //pHandler->AddComponent(new AliHLTCaloClusterAnalyserComponent);
216 //pHandler->AddComponent(new AliHLTEMCALESDEntriesMakerComponent);
217
218 return 0;
219}
220
221
222int AliHLTEMCALAgent::GetHandlerDescription(AliHLTComponentDataType dt,
223 AliHLTUInt32_t spec,
224 AliHLTOUTHandlerDesc& desc) const
225{
226 // see header file for class documentation
2f0cecb4 227
8db5dd01 228 // raw data blocks to be fed into offline reconstruction
229 if (dt==(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginEMCAL))
230 {
6c0647cd 231 AliHLTEMCALMapper* pMapper=GetMapper(spec);
232
233 if(pMapper && pMapper->GetDDLFromSpec(spec) >= 0)
8db5dd01 234 {
235 desc=AliHLTOUTHandlerDesc(kRawReader, dt, GetModuleId());
236 return 1;
237 }
6c0647cd 238 else if (pMapper==NULL)
239 {
240 ALIHLTERRORGUARD(5, "failed to create EMCAL mapper");
241 return 0;
242 }
8db5dd01 243 else
244 {
245 HLTWarning("Handler can not process data inconsistent with a single EMCAL DDL from specification % d", spec);
246 return 0;
247 }
248 }
249 return 0;
250}
251
252AliHLTOUTHandler* AliHLTEMCALAgent::GetOutputHandler(AliHLTComponentDataType dt,
253 AliHLTUInt32_t /*spec*/)
254{
255 // see header file for class documentation
256
257 // raw data blocks to be fed into offline reconstruction
258 if (dt==(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginEMCAL))
259 {
260 if (!fRawDataHandler)
261 {
6c0647cd 262 fRawDataHandler = new AliHLTEMCALAgent::AliHLTEMCALRawDataHandler(this);
8db5dd01 263 }
264 return fRawDataHandler;
265 }
266
267 return NULL;
268}
269
270int AliHLTEMCALAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
271{
272 // see header file for class documentation
273 if (pInstance==NULL) return -EINVAL;
274
275 if (pInstance==fRawDataHandler) {
276 delete fRawDataHandler;
277 fRawDataHandler=NULL;
278 }
279 return 0;
280}
281
6c0647cd 282AliHLTEMCALAgent::AliHLTEMCALRawDataHandler::AliHLTEMCALRawDataHandler(AliHLTEMCALAgent* pAgent)
283 : fpAgent(pAgent)
8db5dd01 284{
285 // see header file for class documentation
286}
287
288AliHLTEMCALAgent::AliHLTEMCALRawDataHandler::~AliHLTEMCALRawDataHandler()
289{
290 // see header file for class documentation
291}
292
293int AliHLTEMCALAgent::AliHLTEMCALRawDataHandler::ProcessData(AliHLTOUT* pData)
294{
295 // see header file for class documentation
296 if (!pData) return -EINVAL;
297
298 AliHLTComponentDataType dt = kAliHLTVoidDataType;
299 AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
300
6c0647cd 301 AliHLTEMCALMapper* pMapper=fpAgent?fpAgent->GetMapper(spec):NULL;
302 if (!pMapper) {
303 ALIHLTERRORGUARD(5, "%s", fpAgent?"can not retrieve EMCAL mapper from agent":"agent not available to retrieve EMCAL mapper");
304 return -ENODEV;
305 }
8db5dd01 306
307 int iResult = pData->GetDataBlockDescription(dt, spec);
308 if (iResult>=0)
309 {
310 int ddl = -1;
6c0647cd 311 if((ddl = pMapper->GetDDLFromSpec(spec)) >=0)
8db5dd01 312 {
313 iResult = ddl;
314 }
315 }
316 else
317 {
318 HLTError("Handler can not process data inconsistent with a single EMCAL DDL from specification % d", spec);
319 iResult=-EBADMSG;
320 }
321 return iResult;
322}
6c0647cd 323
324AliHLTEMCALMapper* AliHLTEMCALAgent::GetMapper(AliHLTUInt32_t spec) const
325{
326 // get the mapper instance for a specification
327 std::map<AliHLTUInt32_t, AliHLTEMCALMapper*>::const_iterator element=fMappers.find(spec);
328 if (element!=fMappers.end()) return element->second;
329
330 AliHLTEMCALMapper* mapper=new AliHLTEMCALMapper(spec);
331 if (!mapper) return NULL;
332 mapper->InitDDLSpecificationMapping();
333 const_cast<AliHLTEMCALAgent*>(this)->fMappers[spec]=mapper;
334 return mapper;
335}