]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - HLT/MUON/OfflineInterface/AliHLTMUONAgent.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Coverity Fix for the DptDpt Code
[u/mrichter/AliRoot.git] / HLT / MUON / OfflineInterface / AliHLTMUONAgent.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-2007, 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///
19/// @file AliHLTMUONAgent.cxx
20/// @author Artur Szostak <artursz@iafrica.com>
21/// @date 28 May 2007
22/// @brief Implementation of the AliHLTMUONAgent class.
23///
24
25#include "AliHLTMUONAgent.h"
26#include "AliHLTMUONConstants.h"
27#include "AliHLTMUONRecHitsSource.h"
28#include "AliHLTMUONTriggerRecordsSource.h"
29#include "AliHLTMUONDigitPublisherComponent.h"
30#include "AliHLTMUONRootifierComponent.h"
31#include "AliHLTMUONHitReconstructorComponent.h"
32#include "AliHLTMUONTriggerReconstructorComponent.h"
33#include "AliHLTMUONMansoTrackerFSMComponent.h"
34#include "AliHLTMUONFullTrackerComponent.h"
35#include "AliHLTMUONDecisionComponent.h"
36#include "AliHLTMUONESDMaker.h"
37#include "AliHLTMUONEmptyEventFilterComponent.h"
38#include "AliHLTMUONDataCheckerComponent.h"
39#include "AliHLTMUONClusterFinderComponent.h"
40#include "AliHLTMUONRawDataHistoComponent.h"
41#include "AliHLTMUONClusterHistoComponent.h"
42#include "AliHLTOUTHandlerChain.h"
43#include "AliHLTOUTHandlerIgnore.h"
44#include "AliRawReader.h"
45#include "AliRunLoader.h"
46#include "AliRun.h"
47#include "AliMUON.h"
48#include "TSystem.h"
49#include "TObjArray.h"
50#include "TString.h"
51
52// The single global instance of the dimuon HLT agent.
53AliHLTMUONAgent AliHLTMUONAgent::fgkInstance;
54
55AliHLTOUTHandlerChain AliHLTMUONAgent::fgkESDMakerChain("libAliHLTMUON.so chains=dHLT-make-esd");
56AliHLTOUTHandlerChain AliHLTMUONAgent::fgkRootifyDumpChain("libAliHLTMUON.so chains=dHLT-rootify-and-dump");
57AliHLTOUTHandlerIgnore AliHLTMUONAgent::fgkDataIgnoreHandler;
58Int_t AliHLTMUONAgent::fgMuonModuleLoaded = 0;
59bool AliHLTMUONAgent::fgRunRootifyChain = false;
60
61
62ClassImp(AliHLTMUONAgent);
63
64
65bool AliHLTMUONAgent::IsMuonModuleLoaded()
66{
67 /// Checks to see if the MUON module is loaded or not.
68
69 // If the check was already done then use the cached value.
70 if (fgMuonModuleLoaded > 0) return true;
71 if (fgMuonModuleLoaded < 0) return false;
72
73 if (gAlice != NULL)
74 {
75 // Search for a module in gAlice deriving from AliMUON.
76 TIter next(gAlice->Modules());
77 TObject* mod = NULL;
78 while ((mod = next()) != NULL)
79 {
80 if (mod->InheritsFrom(AliMUON::Class()))
81 {
82 fgMuonModuleLoaded = 1;
83 return true;
84 }
85 }
86 }
87
88 fgMuonModuleLoaded = -1;
89 return false;
90}
91
92
93AliHLTMUONAgent::AliHLTMUONAgent() : AliHLTModuleAgent("MUON")
94{
95 ///
96 /// Default constructor.
97 ///
98}
99
100AliHLTMUONAgent::~AliHLTMUONAgent()
101{
102 ///
103 /// Default destructor.
104 ///
105}
106
107const char* AliHLTMUONAgent::GetReconstructionChains(AliRawReader* rawReader,
108 AliRunLoader* runloader
109 ) const
110{
111 ///
112 /// Inherited from AliHLTModuleAgent.
113 /// Returns the top processing chain configurations for local event
114 /// reconstruction.
115 /// @param [in] rawReader AliRoot rawreader instance.
116 /// @param [in] runloader AliRoot runloader
117 /// @return string containing the top configurations separated by blanks.
118 ///
119 /// If rawReader is not NULL then the standard dHLT chain is run taking
120 /// data from raw DDL data. Otherwise runloader is checked and if it is
121 /// not NULL then a dHLT chain is run with input data from digits.
122
123 if (rawReader != NULL)
124 {
125 // Check if there is any data from the tracker and trigger.
126 bool dataFromTracker = false;
127 bool dataFromTrigger = false;
128 rawReader->Select("MUONTRK", 0, 19);
129 for (Int_t i = 0; i < 20; i++)
130 {
131 if (rawReader->ReadHeader()) dataFromTracker = true;
132 }
133 rawReader->Select("MUONTRG", 0, 1);
134 for (Int_t i = 0; i < 2; i++)
135 {
136 if (rawReader->ReadHeader()) dataFromTrigger = true;
137 }
138 rawReader->Reset();
139
140 // If raw data was found for our detector then select the
141 // appropriate chain.
142 if (dataFromTracker and dataFromTrigger)
143 return "dHLT-sim-fromRaw";
144 }
145
146 if (runloader != NULL)
147 {
148 // IsMuonModuleLoaded() is used to check if the muon module was loaded
149 // If there is no AliMUON module in the simulation then do not run the
150 // MUON HLT chain.
151 if (IsMuonModuleLoaded() and runloader->GetLoader("MUONLoader") != NULL)
152 return "dHLT-sim";
153 }
154
155 return "";
156}
157
158const char* AliHLTMUONAgent::GetRequiredComponentLibraries() const
159{
160 ///
161 /// Inherited from AliHLTModuleAgent.
162 /// Returns a list of libraries which the configurations registered by
163 /// this module agent depend on.
164 /// @return list of component libraries as a blank-separated string.
165 ///
166
167 // List of libraries that we depend on.
168 static const char* libs[] =
169 {
170 "libCore.so",
171 // "libCint.so",
172 "libGraf.so",
173 "libRIO.so",
174 "libNet.so",
175 "libHist.so",
176 "libMatrix.so",
177 "libMathCore.so",
178 "libMinuit.so",
179 "libTree.so",
180 "libGraf3d.so",
181 "libGpad.so",
182 "libPhysics.so",
183 "libGui.so",
184 "libProofPlayer.so",
185 "libProof.so",
186 "libThread.so",
187 "libGeom.so",
188 "libEG.so",
189 "libTreePlayer.so",
190 "libXMLIO.so",
191 "libVMC.so",
192 "libESD.so",
193 "libCDB.so",
194 "libSTEERBase.so",
195 "libSTEER.so",
196 "libGui.so",
197 "libRAWDatasim.so",
198 "libRAWDatarec.so",
199 "libRAWDatabase.so",
200 "libMUONcore.so",
201 "libMUONraw.so",
202 "libMUONbase.so",
203 "libMUONgeometry.so",
204 "libMUONmapping.so",
205 "libMUONcalib.so",
206 "libMUONsim.so",
207 "libMUONtrigger.so",
208 "libMUONevaluation.so",
209 "libMUONrec.so",
210 "libANALYSIS.so",
211 "libANALYSISalice.so",
212 "libHLTbase.so",
213 "libAliHLTUtil.so",
214 NULL
215 };
216
217 // First check if the library is not already loaded. If it is then we have
218 // no reason to declare it as needed, so that we do not load it again.
219 static TString result;
220 for (const char** lib = libs; *lib != NULL; lib++)
221 {
222 const char* list = gSystem->GetLibraries(*lib, "", kFALSE);
223 if (list == NULL) continue;
224 // Check if not found, i.e. result was an empty string.
225 // If so then add the library to the required list.
226 if (list[0] == '\0')
227 {
228 result += *lib;
229 result += " ";
230 }
231 }
232 return result.Data();
233}
234
235
236int AliHLTMUONAgent::CreateConfigurations(
237 AliHLTConfigurationHandler* handler,
238 AliRawReader* rawReader,
239 AliRunLoader* runloader
240 ) const
241{
242 /// Register all processing configurations belonging to the dimuon HLT
243 /// library with the AliHLTConfigurationHandler.
244 /// @param [in] handler the configuration handler
245 /// @param [in] rawReader AliRoot rawreader instance.
246 /// @param [in] runloader AliRoot runloader
247 /// @return Zero on success and error code if failed.
248 ///
249 /// Chains available:
250 /// dHLT-sim - standard dHLT simulation chain.
251 /// dHLT-sim-fromRaw - standard dHLT chain taking raw DDL data as input.
252 /// dHLT-sim-fromMC - dHLT chain taking Monte Carlo hit data as input.
253 /// So hit reconstruction is not checked, just the tracker.
254
255 if (handler == NULL) return 0;
256
257 const char* trackerId = AliHLTMUONConstants::MansoTrackerFSMId();
258 const char* fullTrackerId = AliHLTMUONConstants::FullTrackerId();
259 const char* decCompId = AliHLTMUONConstants::DecisionComponentId();
260
261 if (rawReader != NULL)
262 {
263 // Implement the dHLT-sim-fromRaw dHLT simulation chain reading
264 // from raw data.
265 const char* rawPubComp = "AliRawReaderPublisher";
266 const char* cmd1 = "-minid 2560 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000001";
267 const char* cmd2 = "-minid 2561 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000002";
268 const char* cmd3 = "-minid 2562 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000004";
269 const char* cmd4 = "-minid 2563 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000008";
270 const char* cmd5 = "-minid 2564 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000010";
271 const char* cmd6 = "-minid 2565 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000020";
272 const char* cmd7 = "-minid 2566 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000040";
273 const char* cmd8 = "-minid 2567 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000080";
274 const char* cmd9 = "-minid 2568 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000100";
275 const char* cmd10 = "-minid 2569 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000200";
276 const char* cmd11 = "-minid 2570 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000400";
277 const char* cmd12 = "-minid 2571 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x000800";
278 const char* cmd13 = "-minid 2572 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x001000";
279 const char* cmd14 = "-minid 2573 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x002000";
280 const char* cmd15 = "-minid 2574 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x004000";
281 const char* cmd16 = "-minid 2575 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x008000";
282 const char* cmd17 = "-minid 2576 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x010000";
283 const char* cmd18 = "-minid 2577 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x020000";
284 const char* cmd19 = "-minid 2578 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x040000";
285 const char* cmd20 = "-minid 2579 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x080000";
286 const char* cmd21 = "-minid 2816 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x100000";
287 const char* cmd22 = "-minid 2817 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x200000";
288 handler->CreateConfiguration("RawDDL1", rawPubComp, NULL, cmd1);
289 handler->CreateConfiguration("RawDDL2", rawPubComp, NULL, cmd2);
290 handler->CreateConfiguration("RawDDL3", rawPubComp, NULL, cmd3);
291 handler->CreateConfiguration("RawDDL4", rawPubComp, NULL, cmd4);
292 handler->CreateConfiguration("RawDDL5", rawPubComp, NULL, cmd5);
293 handler->CreateConfiguration("RawDDL6", rawPubComp, NULL, cmd6);
294 handler->CreateConfiguration("RawDDL7", rawPubComp, NULL, cmd7);
295 handler->CreateConfiguration("RawDDL8", rawPubComp, NULL, cmd8);
296 handler->CreateConfiguration("RawDDL9", rawPubComp, NULL, cmd9);
297 handler->CreateConfiguration("RawDDL10", rawPubComp, NULL, cmd10);
298 handler->CreateConfiguration("RawDDL11", rawPubComp, NULL, cmd11);
299 handler->CreateConfiguration("RawDDL12", rawPubComp, NULL, cmd12);
300 handler->CreateConfiguration("RawDDL13", rawPubComp, NULL, cmd13);
301 handler->CreateConfiguration("RawDDL14", rawPubComp, NULL, cmd14);
302 handler->CreateConfiguration("RawDDL15", rawPubComp, NULL, cmd15);
303 handler->CreateConfiguration("RawDDL16", rawPubComp, NULL, cmd16);
304 handler->CreateConfiguration("RawDDL17", rawPubComp, NULL, cmd17);
305 handler->CreateConfiguration("RawDDL18", rawPubComp, NULL, cmd18);
306 handler->CreateConfiguration("RawDDL19", rawPubComp, NULL, cmd19);
307 handler->CreateConfiguration("RawDDL20", rawPubComp, NULL, cmd20);
308 handler->CreateConfiguration("RawDDL21", rawPubComp, NULL, cmd21);
309 handler->CreateConfiguration("RawDDL22", rawPubComp, NULL, cmd22);
310 const char* hrId = AliHLTMUONConstants::HitReconstructorId();
311 const char* trId = AliHLTMUONConstants::TriggerReconstructorId();
312 handler->CreateConfiguration("RecoRawDDL1", hrId, "RawDDL1", "-ddl 1 -cdb");
313 handler->CreateConfiguration("RecoRawDDL2", hrId, "RawDDL2", "-ddl 2 -cdb");
314 handler->CreateConfiguration("RecoRawDDL3", hrId, "RawDDL3", "-ddl 3 -cdb");
315 handler->CreateConfiguration("RecoRawDDL4", hrId, "RawDDL4", "-ddl 4 -cdb");
316 handler->CreateConfiguration("RecoRawDDL5", hrId, "RawDDL5", "-ddl 5 -cdb");
317 handler->CreateConfiguration("RecoRawDDL6", hrId, "RawDDL6", "-ddl 6 -cdb");
318 handler->CreateConfiguration("RecoRawDDL7", hrId, "RawDDL7", "-ddl 7 -cdb");
319 handler->CreateConfiguration("RecoRawDDL8", hrId, "RawDDL8", "-ddl 8 -cdb");
320 handler->CreateConfiguration("RecoRawDDL9", hrId, "RawDDL9", "-ddl 9 -cdb");
321 handler->CreateConfiguration("RecoRawDDL10", hrId, "RawDDL10", "-ddl 10 -cdb");
322 handler->CreateConfiguration("RecoRawDDL11", hrId, "RawDDL11", "-ddl 11 -cdb");
323 handler->CreateConfiguration("RecoRawDDL12", hrId, "RawDDL12", "-ddl 12 -cdb");
324 handler->CreateConfiguration("RecoRawDDL13", hrId, "RawDDL13", "-ddl 13 -cdb");
325 handler->CreateConfiguration("RecoRawDDL14", hrId, "RawDDL14", "-ddl 14 -cdb");
326 handler->CreateConfiguration("RecoRawDDL15", hrId, "RawDDL15", "-ddl 15 -cdb");
327 handler->CreateConfiguration("RecoRawDDL16", hrId, "RawDDL16", "-ddl 16 -cdb");
328 handler->CreateConfiguration("RecoRawDDL17", hrId, "RawDDL17", "-ddl 17 -cdb");
329 handler->CreateConfiguration("RecoRawDDL18", hrId, "RawDDL18", "-ddl 18 -cdb");
330 handler->CreateConfiguration("RecoRawDDL19", hrId, "RawDDL19", "-ddl 19 -cdb");
331 handler->CreateConfiguration("RecoRawDDL20", hrId, "RawDDL20", "-ddl 20 -cdb");
332 handler->CreateConfiguration("RecoRawDDL21", trId, "RawDDL21", "-ddl 21 -cdb -suppress_partial_triggers");
333 handler->CreateConfiguration("RecoRawDDL22", trId, "RawDDL22", "-ddl 22 -cdb -suppress_partial_triggers");
334
335 const char* recoSrcs = "RecoRawDDL13 RecoRawDDL14 RecoRawDDL15 RecoRawDDL16 RecoRawDDL17"
336 " RecoRawDDL18 RecoRawDDL19 RecoRawDDL20 RecoRawDDL21 RecoRawDDL22";
337 handler->CreateConfiguration("MansoTrackerForRaw", trackerId, recoSrcs, "");
338
339 handler->CreateConfiguration("DecisionForRaw", decCompId, "MansoTrackerForRaw", "");
340
341 TString outputSrcs = "DecisionForRaw MansoTrackerForRaw ";
342 outputSrcs += recoSrcs;
343 handler->CreateConfiguration("dHLT-sim-fromRaw", "BlockFilter", outputSrcs, "");
344
345 // For reconstruction using full tracker.
346 const char* recoSrcsFull = " RecoRawDDL1 RecoRawDDL2 RecoRawDDL3 RecoRawDDL4 RecoRawDDL5 RecoRawDDL6 "
347 " RecoRawDDL7 RecoRawDDL8 RecoRawDDL9 RecoRawDDL10 RecoRawDDL11 RecoRawDDL12 "
348 " RecoRawDDL13 RecoRawDDL14 RecoRawDDL15 RecoRawDDL16 RecoRawDDL17 "
349 " RecoRawDDL18 RecoRawDDL19 RecoRawDDL20 RecoRawDDL21 RecoRawDDL22 ";
350 handler->CreateConfiguration("FullTrackerForRaw", fullTrackerId, recoSrcsFull, "-cdb");
351
352 handler->CreateConfiguration("DecisionForRawFullTrk", decCompId, "FullTrackerForRaw", "");
353
354 TString outputSrcsFull = "DecisionForRawFullTrk FullTrackerForRaw ";
355 outputSrcsFull += recoSrcsFull;
356 handler->CreateConfiguration("dHLT-sim-fromRaw-fullTracker", "BlockFilter", outputSrcsFull, "");
357 }
358
359 if (IsMuonModuleLoaded() and runloader != NULL)
360 {
361 // Implement the dHLT-sim dHLT simulation chain reading from
362 // simulated digits.
363 const char* digitPub = AliHLTMUONConstants::DigitPublisherId();
364 handler->CreateConfiguration("DigitDDL13", digitPub, NULL, "-simdata -ddl 13");
365 handler->CreateConfiguration("DigitDDL14", digitPub, NULL, "-simdata -ddl 14");
366 handler->CreateConfiguration("DigitDDL15", digitPub, NULL, "-simdata -ddl 15");
367 handler->CreateConfiguration("DigitDDL16", digitPub, NULL, "-simdata -ddl 16");
368 handler->CreateConfiguration("DigitDDL17", digitPub, NULL, "-simdata -ddl 17");
369 handler->CreateConfiguration("DigitDDL18", digitPub, NULL, "-simdata -ddl 18");
370 handler->CreateConfiguration("DigitDDL19", digitPub, NULL, "-simdata -ddl 19");
371 handler->CreateConfiguration("DigitDDL20", digitPub, NULL, "-simdata -ddl 20");
372 handler->CreateConfiguration("DigitDDL21", digitPub, NULL, "-simdata -ddl 21");
373 handler->CreateConfiguration("DigitDDL22", digitPub, NULL, "-simdata -ddl 22");
374 const char* hrId = AliHLTMUONConstants::HitReconstructorId();
375 const char* trId = AliHLTMUONConstants::TriggerReconstructorId();
376 handler->CreateConfiguration("RecoDDL13", hrId, "DigitDDL13", "-ddl 13 -cdb");
377 handler->CreateConfiguration("RecoDDL14", hrId, "DigitDDL14", "-ddl 14 -cdb");
378 handler->CreateConfiguration("RecoDDL15", hrId, "DigitDDL15", "-ddl 15 -cdb");
379 handler->CreateConfiguration("RecoDDL16", hrId, "DigitDDL16", "-ddl 16 -cdb");
380 handler->CreateConfiguration("RecoDDL17", hrId, "DigitDDL17", "-ddl 17 -cdb");
381 handler->CreateConfiguration("RecoDDL18", hrId, "DigitDDL18", "-ddl 18 -cdb");
382 handler->CreateConfiguration("RecoDDL19", hrId, "DigitDDL19", "-ddl 19 -cdb");
383 handler->CreateConfiguration("RecoDDL20", hrId, "DigitDDL20", "-ddl 20 -cdb");
384 handler->CreateConfiguration("RecoDDL21", trId, "DigitDDL21", "-ddl 21 -cdb -suppress_partial_triggers");
385 handler->CreateConfiguration("RecoDDL22", trId, "DigitDDL22", "-ddl 22 -cdb -suppress_partial_triggers");
386
387 const char* recoSrcs = "RecoDDL13 RecoDDL14 RecoDDL15 RecoDDL16 RecoDDL17"
388 " RecoDDL18 RecoDDL19 RecoDDL20 RecoDDL21 RecoDDL22";
389 handler->CreateConfiguration("MansoTracker", trackerId, recoSrcs, "");
390
391 handler->CreateConfiguration("Decision", decCompId, "MansoTracker", "");
392
393 TString outputSrcs = "Decision MansoTracker ";
394 outputSrcs += recoSrcs;
395 handler->CreateConfiguration("dHLT-sim", "BlockFilter", outputSrcs.Data(), "");
396
397 // Implement the dHLT-sim-fromMC dHLT simulation chain reading
398 // Monte Carlo geant hits and putting those into a tracker component.
399 const char* rhsId = AliHLTMUONConstants::RecHitsSourceId();
400 const char* trsId = AliHLTMUONConstants::TriggerRecordsSourceId();
401 handler->CreateConfiguration("HitsDDL13", rhsId, NULL, "-simdata -plane left -chamber 7");
402 handler->CreateConfiguration("HitsDDL14", rhsId, NULL, "-simdata -plane right -chamber 7");
403 handler->CreateConfiguration("HitsDDL15", rhsId, NULL, "-simdata -plane left -chamber 8");
404 handler->CreateConfiguration("HitsDDL16", rhsId, NULL, "-simdata -plane right -chamber 8");
405 handler->CreateConfiguration("HitsDDL17", rhsId, NULL, "-simdata -plane left -chamber 9");
406 handler->CreateConfiguration("HitsDDL18", rhsId, NULL, "-simdata -plane right -chamber 9");
407 handler->CreateConfiguration("HitsDDL19", rhsId, NULL, "-simdata -plane left -chamber 10");
408 handler->CreateConfiguration("HitsDDL20", rhsId, NULL, "-simdata -plane right -chamber 10");
409 handler->CreateConfiguration("TrigRecsDDL21", trsId, NULL, "-hitdata -plane left");
410 handler->CreateConfiguration("TrigRecsDDL22", trsId, NULL, "-hitdata -plane right");
411
412 const char* dataSrcs = "HitsDDL13 HitsDDL14 HitsDDL15 HitsDDL16 HitsDDL17"
413 " HitsDDL18 HitsDDL19 HitsDDL20 TrigRecsDDL21 TrigRecsDDL22";
414 handler->CreateConfiguration("MansoTrackerForMC", trackerId, dataSrcs, "");
415
416 handler->CreateConfiguration("DecisionForMC", decCompId, "MansoTrackerForMC", "");
417
418 outputSrcs = "DecisionForMC MansoTrackerForMC ";
419 outputSrcs += dataSrcs;
420 handler->CreateConfiguration("dHLT-sim-fromMC", "BlockFilter", outputSrcs.Data(), "");
421 }
422
423 // Create a chain for generating AliESDEvent objects from dHLT raw reconstructed data.
424 handler->CreateConfiguration("HLTOUTPubTrigRecs", "AliHLTOUTPublisher", NULL, "-datatype 'TRIGRECS' 'MUON'");
425 handler->CreateConfiguration("HLTOUTPubMansoTracks", "AliHLTOUTPublisher", NULL, "-datatype 'MANTRACK' 'MUON'");
426 handler->CreateConfiguration("HLTOUTPubTracks", "AliHLTOUTPublisher", NULL, "-datatype 'TRACKS ' 'MUON'");
427 handler->CreateConfiguration(
428 "dHLT-make-esd",
429 AliHLTMUONConstants::ESDMakerId(),
430 "HLTOUTPubTrigRecs HLTOUTPubMansoTracks HLTOUTPubTracks",
431 "-make_minimal_esd"
432 );
433
434 // Create a chain for rootifying the raw dHLT data and dumping to file.
435 // This is used during AliRoot reconstruction.
436 handler->CreateConfiguration("HLTOUTPubTrigDbg", "AliHLTOUTPublisher", NULL, "-datatype 'TRIGRDBG' 'MUON'");
437 handler->CreateConfiguration("HLTOUTPubHits", "AliHLTOUTPublisher", NULL, "-datatype 'RECHITS ' 'MUON'");
438 handler->CreateConfiguration("HLTOUTPubClusters", "AliHLTOUTPublisher", NULL, "-datatype 'CLUSTERS' 'MUON'");
439 handler->CreateConfiguration("HLTOUTPubChannels", "AliHLTOUTPublisher", NULL, "-datatype 'CHANNELS' 'MUON'");
440 handler->CreateConfiguration("HLTOUTPubCandidates", "AliHLTOUTPublisher", NULL, "-datatype 'MNCANDID' 'MUON'");
441 handler->CreateConfiguration("HLTOUTPubSingles", "AliHLTOUTPublisher", NULL, "-datatype 'DECIDSIN' 'MUON'");
442 handler->CreateConfiguration("HLTOUTPubPairs", "AliHLTOUTPublisher", NULL, "-datatype 'DECIDPAR' 'MUON'");
443 handler->CreateConfiguration(
444 "HLTOUTConverter",
445 AliHLTMUONConstants::RootifierComponentId(),
446 "HLTOUTPubTrigRecs HLTOUTPubTrigDbg HLTOUTPubHits HLTOUTPubClusters"
447 " HLTOUTPubChannels HLTOUTPubMansoTracks HLTOUTPubCandidates"
448 " HLTOUTPubTracks HLTOUTPubSingles HLTOUTPubPairs",
449 ""
450 );
451 handler->CreateConfiguration(
452 "dHLT-rootify-and-dump",
453 "ROOTFileWriter",
454 "HLTOUTConverter",
455 "-concatenate-events -datafile dHLTRawData.root -specfmt"
456 );
457
458 return 0;
459}
460
461
462int AliHLTMUONAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
463{
464 ///
465 /// Registers all available components of this module.
466 /// @param [in] pHandler instance of the component handler.
467 ///
468
469 if (pHandler == NULL) return -EINVAL;
470 pHandler->AddComponent(new AliHLTMUONRecHitsSource);
471 pHandler->AddComponent(new AliHLTMUONTriggerRecordsSource);
472 pHandler->AddComponent(new AliHLTMUONDigitPublisherComponent);
473 pHandler->AddComponent(new AliHLTMUONRootifierComponent);
474 pHandler->AddComponent(new AliHLTMUONHitReconstructorComponent);
475 pHandler->AddComponent(new AliHLTMUONTriggerReconstructorComponent);
476 pHandler->AddComponent(new AliHLTMUONMansoTrackerFSMComponent);
477 pHandler->AddComponent(new AliHLTMUONFullTrackerComponent);
478 pHandler->AddComponent(new AliHLTMUONDecisionComponent);
479 pHandler->AddComponent(new AliHLTMUONESDMaker);
480 pHandler->AddComponent(new AliHLTMUONEmptyEventFilterComponent);
481 pHandler->AddComponent(new AliHLTMUONDataCheckerComponent);
482 pHandler->AddComponent(new AliHLTMUONClusterFinderComponent);
483 pHandler->AddComponent(new AliHLTMUONRawDataHistoComponent);
484 pHandler->AddComponent(new AliHLTMUONClusterHistoComponent);
485 return 0;
486}
487
488
489int AliHLTMUONAgent::GetHandlerDescription(
490 AliHLTComponentDataType dt,
491#ifdef __DEBUG
492 AliHLTUInt32_t spec,
493#else
494 AliHLTUInt32_t /*spec*/,
495#endif
496 AliHLTOUTHandlerDesc& desc
497 ) const
498{
499 /// Get handler decription for MUON data in the HLTOUT data stream.
500
501 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
502 dt == AliHLTMUONConstants::MansoTracksBlockDataType() or
503 dt == AliHLTMUONConstants::TracksBlockDataType()
504 )
505 {
506 HLTDebug("Indicating we can handle data type = %s and specification"
507 " = 0x%8.8X with dHLT-make-esd chain",
508 AliHLTComponent::DataType2Text(dt).c_str(),
509 spec
510 );
511 desc = AliHLTOUTHandlerDesc(kChain, dt, "dHLT-make-esd");
512 return 1;
513 }
514
515 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
516 dt == AliHLTMUONConstants::TrigRecsDebugBlockDataType() or
517 dt == AliHLTMUONConstants::RecHitsBlockDataType() or
518 dt == AliHLTMUONConstants::ClusterBlockDataType() or
519 dt == AliHLTMUONConstants::ChannelBlockDataType() or
520 dt == AliHLTMUONConstants::MansoTracksBlockDataType() or
521 dt == AliHLTMUONConstants::MansoCandidatesBlockDataType() or
522 dt == AliHLTMUONConstants::TracksBlockDataType() or
523 dt == AliHLTMUONConstants::SinglesDecisionBlockDataType() or
524 dt == AliHLTMUONConstants::PairsDecisionBlockDataType()
525 )
526 {
527 if (fgRunRootifyChain)
528 {
529 HLTDebug("Indicating we can handle data type = %s and specification"
530 " = 0x%8.8X with dHLT-rootify-and-dump chain",
531 AliHLTComponent::DataType2Text(dt).c_str(),
532 spec
533 );
534 desc = AliHLTOUTHandlerDesc(kChain, dt, "dHLT-rootify-and-dump");
535 return 1;
536 }
537 else
538 {
539 HLTDebug("Indicating we will ignore data type = %s and specification = 0x%8.8X",
540 AliHLTComponent::DataType2Text(dt).c_str(),
541 spec
542 );
543 desc = AliHLTOUTHandlerDesc(kProprietary, dt, "AliHLTOUTHandlerIgnore");
544 return 1;
545 }
546 }
547
548 if (dt == kAliHLTDataTypeEvent)
549 {
550 HLTDebug("Indicating we will ignore data type = %s and specification = 0x%8.8X",
551 AliHLTComponent::DataType2Text(dt).c_str(),
552 spec
553 );
554 desc = AliHLTOUTHandlerDesc(kProprietary, dt, "AliHLTOUTHandlerIgnore");
555 return 1;
556 }
557
558 return 0;
559}
560
561
562AliHLTOUTHandler* AliHLTMUONAgent::GetOutputHandler(
563 AliHLTComponentDataType dt,
564#ifdef __DEBUG
565 AliHLTUInt32_t spec
566#else
567 AliHLTUInt32_t /*spec*/
568#endif
569 )
570{
571 /// Get specific handler for MUON data in the HLTOUT data stream.
572
573 HLTDebug("Trying to create HLTOUT handler for data type = %s and"
574 " specification = 0x%8.8X",
575 AliHLTComponent::DataType2Text(dt).c_str(),
576 spec
577 );
578
579 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
580 dt == AliHLTMUONConstants::MansoTracksBlockDataType() or
581 dt == AliHLTMUONConstants::TracksBlockDataType()
582 )
583 {
584 return &fgkESDMakerChain;
585 }
586
587 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
588 dt == AliHLTMUONConstants::TrigRecsDebugBlockDataType() or
589 dt == AliHLTMUONConstants::RecHitsBlockDataType() or
590 dt == AliHLTMUONConstants::ClusterBlockDataType() or
591 dt == AliHLTMUONConstants::ChannelBlockDataType() or
592 dt == AliHLTMUONConstants::MansoTracksBlockDataType() or
593 dt == AliHLTMUONConstants::MansoCandidatesBlockDataType() or
594 dt == AliHLTMUONConstants::TracksBlockDataType() or
595 dt == AliHLTMUONConstants::SinglesDecisionBlockDataType() or
596 dt == AliHLTMUONConstants::PairsDecisionBlockDataType()
597 )
598 {
599 if (fgRunRootifyChain)
600 {
601 return &fgkRootifyDumpChain;
602 }
603 else
604 {
605 return &fgkDataIgnoreHandler;
606 }
607 }
608
609 if (dt == kAliHLTDataTypeEvent)
610 {
611 return &fgkDataIgnoreHandler;
612 }
613
614 return NULL;
615}
616
617
618int AliHLTMUONAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
619{
620 /// Deletes the HLTOUT handlers. In this case since the handlers are
621 /// allocated statically, we just check that the right pointer was
622 /// given and exit.
623
624 HLTDebug("Trying to delete HLTOUT handler: %p", pInstance);
625
626 if (pInstance != &fgkESDMakerChain or pInstance != &fgkRootifyDumpChain
627 or pInstance != &fgkDataIgnoreHandler
628 )
629 {
630 return -EINVAL;
631 }
632
633 return 0;
634}