1 /**************************************************************************
2 * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
19 /// @file AliHLTMUONAgent.cxx
20 /// @author Artur Szostak <artursz@iafrica.com>
22 /// @brief Implementation of the AliHLTMUONAgent class.
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"
49 #include "TObjArray.h"
52 // The single global instance of the dimuon HLT agent.
53 AliHLTMUONAgent AliHLTMUONAgent::fgkInstance;
55 AliHLTOUTHandlerChain AliHLTMUONAgent::fgkESDMakerChain("libAliHLTMUON.so chains=dHLT-make-esd");
56 AliHLTOUTHandlerChain AliHLTMUONAgent::fgkRootifyDumpChain("libAliHLTMUON.so chains=dHLT-rootify-and-dump");
57 AliHLTOUTHandlerIgnore AliHLTMUONAgent::fgkDataIgnoreHandler;
58 Int_t AliHLTMUONAgent::fgMuonModuleLoaded = 0;
59 bool AliHLTMUONAgent::fgRunRootifyChain = false;
62 ClassImp(AliHLTMUONAgent);
65 bool AliHLTMUONAgent::IsMuonModuleLoaded()
67 /// Checks to see if the MUON module is loaded or not.
69 // If the check was already done then use the cached value.
70 if (fgMuonModuleLoaded > 0) return true;
71 if (fgMuonModuleLoaded < 0) return false;
75 // Search for a module in gAlice deriving from AliMUON.
76 TIter next(gAlice->Modules());
78 while ((mod = next()) != NULL)
80 if (mod->InheritsFrom(AliMUON::Class()))
82 fgMuonModuleLoaded = 1;
88 fgMuonModuleLoaded = -1;
93 AliHLTMUONAgent::AliHLTMUONAgent() : AliHLTModuleAgent("MUON")
96 /// Default constructor.
100 AliHLTMUONAgent::~AliHLTMUONAgent()
103 /// Default destructor.
107 const char* AliHLTMUONAgent::GetReconstructionChains(AliRawReader* rawReader,
108 AliRunLoader* runloader
112 /// Inherited from AliHLTModuleAgent.
113 /// Returns the top processing chain configurations for local event
115 /// @param [in] rawReader AliRoot rawreader instance.
116 /// @param [in] runloader AliRoot runloader
117 /// @return string containing the top configurations separated by blanks.
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.
123 if (rawReader != NULL)
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++)
131 if (rawReader->ReadHeader()) dataFromTracker = true;
133 rawReader->Select("MUONTRG", 0, 1);
134 for (Int_t i = 0; i < 2; i++)
136 if (rawReader->ReadHeader()) dataFromTrigger = true;
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";
146 if (runloader != NULL)
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
151 if (IsMuonModuleLoaded() and runloader->GetLoader("MUONLoader") != NULL)
158 const char* AliHLTMUONAgent::GetRequiredComponentLibraries() const
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.
167 // List of libraries that we depend on.
168 static const char* libs[] =
203 "libMUONgeometry.so",
208 "libMUONevaluation.so",
211 "libANALYSISalice.so",
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++)
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.
232 return result.Data();
236 int AliHLTMUONAgent::CreateConfigurations(
237 AliHLTConfigurationHandler* handler,
238 AliRawReader* rawReader,
239 AliRunLoader* runloader
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.
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.
255 if (handler == NULL) return 0;
257 const char* trackerId = AliHLTMUONConstants::MansoTrackerFSMId();
258 const char* fullTrackerId = AliHLTMUONConstants::FullTrackerId();
259 const char* decCompId = AliHLTMUONConstants::DecisionComponentId();
261 if (rawReader != NULL)
263 // Implement the dHLT-sim-fromRaw dHLT simulation chain reading
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");
335 const char* recoSrcs = "RecoRawDDL13 RecoRawDDL14 RecoRawDDL15 RecoRawDDL16 RecoRawDDL17"
336 " RecoRawDDL18 RecoRawDDL19 RecoRawDDL20 RecoRawDDL21 RecoRawDDL22";
337 handler->CreateConfiguration("MansoTrackerForRaw", trackerId, recoSrcs, "");
339 handler->CreateConfiguration("DecisionForRaw", decCompId, "MansoTrackerForRaw", "");
341 TString outputSrcs = "DecisionForRaw MansoTrackerForRaw ";
342 outputSrcs += recoSrcs;
343 handler->CreateConfiguration("dHLT-sim-fromRaw", "BlockFilter", outputSrcs, "");
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");
352 handler->CreateConfiguration("DecisionForRawFullTrk", decCompId, "FullTrackerForRaw", "");
354 TString outputSrcsFull = "DecisionForRawFullTrk FullTrackerForRaw ";
355 outputSrcsFull += recoSrcsFull;
356 handler->CreateConfiguration("dHLT-sim-fromRaw-fullTracker", "BlockFilter", outputSrcsFull, "");
359 if (IsMuonModuleLoaded() and runloader != NULL)
361 // Implement the dHLT-sim dHLT simulation chain reading from
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");
387 const char* recoSrcs = "RecoDDL13 RecoDDL14 RecoDDL15 RecoDDL16 RecoDDL17"
388 " RecoDDL18 RecoDDL19 RecoDDL20 RecoDDL21 RecoDDL22";
389 handler->CreateConfiguration("MansoTracker", trackerId, recoSrcs, "");
391 handler->CreateConfiguration("Decision", decCompId, "MansoTracker", "");
393 TString outputSrcs = "Decision MansoTracker ";
394 outputSrcs += recoSrcs;
395 handler->CreateConfiguration("dHLT-sim", "BlockFilter", outputSrcs.Data(), "");
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");
412 const char* dataSrcs = "HitsDDL13 HitsDDL14 HitsDDL15 HitsDDL16 HitsDDL17"
413 " HitsDDL18 HitsDDL19 HitsDDL20 TrigRecsDDL21 TrigRecsDDL22";
414 handler->CreateConfiguration("MansoTrackerForMC", trackerId, dataSrcs, "");
416 handler->CreateConfiguration("DecisionForMC", decCompId, "MansoTrackerForMC", "");
418 outputSrcs = "DecisionForMC MansoTrackerForMC ";
419 outputSrcs += dataSrcs;
420 handler->CreateConfiguration("dHLT-sim-fromMC", "BlockFilter", outputSrcs.Data(), "");
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(
429 AliHLTMUONConstants::ESDMakerId(),
430 "HLTOUTPubTrigRecs HLTOUTPubMansoTracks HLTOUTPubTracks",
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(
445 AliHLTMUONConstants::RootifierComponentId(),
446 "HLTOUTPubTrigRecs HLTOUTPubTrigDbg HLTOUTPubHits HLTOUTPubClusters"
447 " HLTOUTPubChannels HLTOUTPubMansoTracks HLTOUTPubCandidates"
448 " HLTOUTPubTracks HLTOUTPubSingles HLTOUTPubPairs",
451 handler->CreateConfiguration(
452 "dHLT-rootify-and-dump",
455 "-concatenate-events -datafile dHLTRawData.root -specfmt"
462 int AliHLTMUONAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
465 /// Registers all available components of this module.
466 /// @param [in] pHandler instance of the component handler.
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);
489 int AliHLTMUONAgent::GetHandlerDescription(
490 AliHLTComponentDataType dt,
494 AliHLTUInt32_t /*spec*/,
496 AliHLTOUTHandlerDesc& desc
499 /// Get handler decription for MUON data in the HLTOUT data stream.
501 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
502 dt == AliHLTMUONConstants::MansoTracksBlockDataType() or
503 dt == AliHLTMUONConstants::TracksBlockDataType()
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(),
511 desc = AliHLTOUTHandlerDesc(kChain, dt, "dHLT-make-esd");
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()
527 if (fgRunRootifyChain)
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(),
534 desc = AliHLTOUTHandlerDesc(kChain, dt, "dHLT-rootify-and-dump");
539 HLTDebug("Indicating we will ignore data type = %s and specification = 0x%8.8X",
540 AliHLTComponent::DataType2Text(dt).c_str(),
543 desc = AliHLTOUTHandlerDesc(kProprietary, dt, "AliHLTOUTHandlerIgnore");
548 if (dt == kAliHLTDataTypeEvent)
550 HLTDebug("Indicating we will ignore data type = %s and specification = 0x%8.8X",
551 AliHLTComponent::DataType2Text(dt).c_str(),
554 desc = AliHLTOUTHandlerDesc(kProprietary, dt, "AliHLTOUTHandlerIgnore");
562 AliHLTOUTHandler* AliHLTMUONAgent::GetOutputHandler(
563 AliHLTComponentDataType dt,
567 AliHLTUInt32_t /*spec*/
571 /// Get specific handler for MUON data in the HLTOUT data stream.
573 HLTDebug("Trying to create HLTOUT handler for data type = %s and"
574 " specification = 0x%8.8X",
575 AliHLTComponent::DataType2Text(dt).c_str(),
579 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
580 dt == AliHLTMUONConstants::MansoTracksBlockDataType() or
581 dt == AliHLTMUONConstants::TracksBlockDataType()
584 return &fgkESDMakerChain;
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()
599 if (fgRunRootifyChain)
601 return &fgkRootifyDumpChain;
605 return &fgkDataIgnoreHandler;
609 if (dt == kAliHLTDataTypeEvent)
611 return &fgkDataIgnoreHandler;
618 int AliHLTMUONAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
620 /// Deletes the HLTOUT handlers. In this case since the handlers are
621 /// allocated statically, we just check that the right pointer was
624 HLTDebug("Trying to delete HLTOUT handler: %p", pInstance);
626 if (pInstance != &fgkESDMakerChain or pInstance != &fgkRootifyDumpChain
627 or pInstance != &fgkDataIgnoreHandler