Adding functionality to generate AliESDEvent objects from dHLT raw data during offlin...
[u/mrichter/AliRoot.git] / HLT / MUON / OfflineInterface / AliHLTMUONAgent.cxx
CommitLineData
d1ff7c16 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
6253e09b 18///
19/// @file AliHLTMUONAgent.cxx
20/// @author Artur Szostak <artursz@iafrica.com>
887a669c 21/// @date 28 May 2007
6253e09b 22/// @brief Implementation of the AliHLTMUONAgent class.
23///
d1ff7c16 24
25#include "AliHLTMUONAgent.h"
887a669c 26#include "AliHLTMUONConstants.h"
6253e09b 27#include "AliHLTMUONRecHitsSource.h"
28#include "AliHLTMUONTriggerRecordsSource.h"
887a669c 29#include "AliHLTMUONDigitPublisherComponent.h"
6253e09b 30#include "AliHLTMUONRootifierComponent.h"
31#include "AliHLTMUONHitReconstructorComponent.h"
32#include "AliHLTMUONTriggerReconstructorComponent.h"
33#include "AliHLTMUONMansoTrackerFSMComponent.h"
c9537879 34#include "AliHLTMUONDecisionComponent.h"
649ab027 35#include "AliHLTMUONESDMaker.h"
0528e93a 36#include "AliHLTMUONEmptyEventFilterComponent.h"
dba14d7d 37#include "AliHLTMUONDataCheckerComponent.h"
94135365 38#include "AliHLTOUTHandlerChain.h"
352670bf 39#include "AliRawReader.h"
d1ff7c16 40#include "AliRunLoader.h"
887a669c 41#include "TSystem.h"
42#include "TString.h"
d1ff7c16 43
6253e09b 44// The single global instance of the dimuon HLT agent.
45AliHLTMUONAgent AliHLTMUONAgent::fgkInstance;
d1ff7c16 46
94135365 47AliHLTOUTHandlerChain AliHLTMUONAgent::fgkESDMakerChain("libAliHLTMUON.so chains=dHLT-make-esd");
48AliHLTOUTHandlerChain AliHLTMUONAgent::fgkRootifyDumpChain("libAliHLTMUON.so chains=dHLT-rootify-and-dump");
49
50
d1ff7c16 51ClassImp(AliHLTMUONAgent);
52
53
626bfcc1 54AliHLTMUONAgent::AliHLTMUONAgent() : AliHLTModuleAgent("MUON")
d1ff7c16 55{
6253e09b 56 ///
57 /// Default constructor.
58 ///
d1ff7c16 59}
60
61AliHLTMUONAgent::~AliHLTMUONAgent()
62{
6253e09b 63 ///
64 /// Default destructor.
65 ///
d1ff7c16 66}
67
887a669c 68const char* AliHLTMUONAgent::GetReconstructionChains(AliRawReader* rawReader,
69 AliRunLoader* runloader
d1ff7c16 70 ) const
71{
6253e09b 72 ///
73 /// Inherited from AliHLTModuleAgent.
74 /// Returns the top processing chain configurations for local event
75 /// reconstruction.
76 /// @param rawReader [in] AliRoot rawreader instance.
77 /// @param runloader [in] AliRoot runloader
78 /// @return string containing the top configurations separated by blanks.
79 ///
887a669c 80 /// If rawReader is not NULL then the standard dHLT chain is run taking
81 /// data from raw DDL data. Otherwise runloader is checked and if it is
82 /// not NULL then a dHLT chain is run with input data from digits.
6253e09b 83
887a669c 84 if (rawReader != NULL)
85 {
352670bf 86 // Check if there is any data from the tracker and trigger.
87 bool dataFromTracker = false;
88 bool dataFromTrigger = false;
89 rawReader->Select("MUONTRK", 0, 19);
90 for (Int_t i = 0; i < 20; i++)
91 {
92 if (rawReader->ReadHeader()) dataFromTracker = true;
93 }
94 rawReader->Select("MUONTRG", 0, 1);
95 for (Int_t i = 0; i < 2; i++)
96 {
97 if (rawReader->ReadHeader()) dataFromTrigger = true;
98 }
99 rawReader->RewindEvents();
100
101 // If raw data was found for our detector then select the
102 // appropriate chain.
103 if (dataFromTracker and dataFromTrigger)
104 return "dHLT-sim-fromRaw";
887a669c 105 }
352670bf 106
107 if (runloader != NULL)
887a669c 108 {
352670bf 109 if (runloader->GetLoader("MUONLoader") != NULL)
110 return "dHLT-sim";
887a669c 111 }
352670bf 112
113 return "";
d1ff7c16 114}
115
116const char* AliHLTMUONAgent::GetRequiredComponentLibraries() const
117{
6253e09b 118 ///
119 /// Inherited from AliHLTModuleAgent.
120 /// Returns a list of libraries which the configurations registered by
121 /// this module agent depend on.
122 /// @return list of component libraries as a blank-separated string.
123 ///
124
887a669c 125 // List of libraries that we depend on.
126 static const char* libs[] =
127 {
128 "libCore.so",
129 "libCint.so",
130 "libGraf.so",
131 "libRIO.so",
132 "libNet.so",
133 "libHist.so",
134 "libMatrix.so",
135 "libMathCore.so",
136 "libMinuit.so",
137 "libTree.so",
138 "libGraf3d.so",
139 "libGpad.so",
140 "libPhysics.so",
141 "libGui.so",
142 "libProofPlayer.so",
143 "libProof.so",
144 "libThread.so",
145 "libGeom.so",
887a669c 146 "libEG.so",
147 "libTreePlayer.so",
148 "libXMLIO.so",
149 "libVMC.so",
150 "libESD.so",
151 "libCDB.so",
152 "libSTEERBase.so",
153 "libSTEER.so",
154 "libGui.so",
155 "libRAWDatasim.so",
156 "libRAWDatarec.so",
157 "libRAWDatabase.so",
158 "libMUONcore.so",
159 "libMUONraw.so",
160 "libMUONbase.so",
161 "libMUONgeometry.so",
162 "libMUONmapping.so",
163 "libMUONcalib.so",
164 "libMUONsim.so",
165 "libMUONtrigger.so",
166 "libMUONevaluation.so",
167 "libMUONrec.so",
168 "libHLTbase.so",
169 "libAliHLTUtil.so",
170 NULL
171 };
172
173 // First check if the library is not already loaded. If it is then we have
174 // no reason to declare it as needed, so that we do not load it again.
175 static TString result;
176 for (const char** lib = libs; *lib != NULL; lib++)
177 {
178 const char* list = gSystem->GetLibraries(*lib, "", kFALSE);
179 if (list == NULL) continue;
180 // Check if not found, i.e. result was an empty string.
181 // If so then add the library to the required list.
182 if (list[0] == '\0')
183 {
184 result += *lib;
185 result += " ";
186 }
187 }
188 return result.Data();
d1ff7c16 189}
190
191
192int AliHLTMUONAgent::CreateConfigurations(
193 AliHLTConfigurationHandler* handler,
887a669c 194 AliRawReader* rawReader,
195 AliRunLoader* runloader
d1ff7c16 196 ) const
197{
6253e09b 198 /// Register all processing configurations belonging to the dimuon HLT
199 /// library with the AliHLTConfigurationHandler.
200 /// @param handler the configuration handler
201 /// @param rawReader [in] AliRoot rawreader instance.
202 /// @param runloader AliRoot runloader
203 /// @return Zero on success and error code if failed.
204 ///
887a669c 205 /// Chains available:
206 /// dHLT-sim - standard dHLT simulation chain.
207 /// dHLT-sim-fromRaw - standard dHLT chain taking raw DDL data as input.
208 /// dHLT-sim-fromMC - dHLT chain taking Monte Carlo hit data as input.
209 /// So hit reconstruction is not checked, just the tracker.
6253e09b 210
d1ff7c16 211 if (handler == NULL) return 0;
887a669c 212
213 const char* trackerId = AliHLTMUONConstants::MansoTrackerFSMId();
214 const char* decCompId = AliHLTMUONConstants::DecisionComponentId();
215
216 if (rawReader != NULL)
217 {
218 // Implement the dHLT-sim-fromRaw dHLT simulation chain reading
219 // from raw data.
220 const char* rawPubComp = "AliRawReaderPublisher";
221 const char* cmd13 = "-minid 2572 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x001000";
222 const char* cmd14 = "-minid 2573 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x002000";
223 const char* cmd15 = "-minid 2574 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x004000";
224 const char* cmd16 = "-minid 2575 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x008000";
225 const char* cmd17 = "-minid 2576 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x010000";
226 const char* cmd18 = "-minid 2577 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x020000";
227 const char* cmd19 = "-minid 2578 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x040000";
228 const char* cmd20 = "-minid 2579 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x080000";
229 const char* cmd21 = "-minid 2816 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x100000";
230 const char* cmd22 = "-minid 2817 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x200000";
231 handler->CreateConfiguration("RawDDL13", rawPubComp, NULL, cmd13);
232 handler->CreateConfiguration("RawDDL14", rawPubComp, NULL, cmd14);
233 handler->CreateConfiguration("RawDDL15", rawPubComp, NULL, cmd15);
234 handler->CreateConfiguration("RawDDL16", rawPubComp, NULL, cmd16);
235 handler->CreateConfiguration("RawDDL17", rawPubComp, NULL, cmd17);
236 handler->CreateConfiguration("RawDDL18", rawPubComp, NULL, cmd18);
237 handler->CreateConfiguration("RawDDL19", rawPubComp, NULL, cmd19);
238 handler->CreateConfiguration("RawDDL20", rawPubComp, NULL, cmd20);
239 handler->CreateConfiguration("RawDDL21", rawPubComp, NULL, cmd21);
240 handler->CreateConfiguration("RawDDL22", rawPubComp, NULL, cmd22);
241 const char* hrId = AliHLTMUONConstants::HitReconstructorId();
242 const char* trId = AliHLTMUONConstants::TriggerReconstructorId();
243 handler->CreateConfiguration("RecoRawDDL13", hrId, "RawDDL13", "-ddl 13 -cdb");
244 handler->CreateConfiguration("RecoRawDDL14", hrId, "RawDDL14", "-ddl 14 -cdb");
245 handler->CreateConfiguration("RecoRawDDL15", hrId, "RawDDL15", "-ddl 15 -cdb");
246 handler->CreateConfiguration("RecoRawDDL16", hrId, "RawDDL16", "-ddl 16 -cdb");
247 handler->CreateConfiguration("RecoRawDDL17", hrId, "RawDDL17", "-ddl 17 -cdb");
248 handler->CreateConfiguration("RecoRawDDL18", hrId, "RawDDL18", "-ddl 18 -cdb");
249 handler->CreateConfiguration("RecoRawDDL19", hrId, "RawDDL19", "-ddl 19 -cdb");
250 handler->CreateConfiguration("RecoRawDDL20", hrId, "RawDDL20", "-ddl 20 -cdb");
251 handler->CreateConfiguration("RecoRawDDL21", trId, "RawDDL21", "-ddl 21 -cdb -suppress_partial_triggers");
252 handler->CreateConfiguration("RecoRawDDL22", trId, "RawDDL22", "-ddl 22 -cdb -suppress_partial_triggers");
253
254 const char* recoSrcs = "RecoRawDDL13 RecoRawDDL14 RecoRawDDL15 RecoRawDDL16 RecoRawDDL17"
255 " RecoRawDDL18 RecoRawDDL19 RecoRawDDL20 RecoRawDDL21 RecoRawDDL22";
256 handler->CreateConfiguration("MansoTrackerForRaw", trackerId, recoSrcs, "");
257
147b1df7 258 handler->CreateConfiguration("DecisionForRaw", decCompId, "MansoTrackerForRaw", "");
259
260 TString outputSrcs = "DecisionForRaw MansoTrackerForRaw ";
261 outputSrcs += recoSrcs;
262 handler->CreateConfiguration("dHLT-sim-fromRaw", "BlockFilter", outputSrcs, "");
887a669c 263 }
264
265 if (runloader != NULL)
266 {
267 // Implement the dHLT-sim dHLT simulation chain reading from
268 // simulated digits.
269 const char* digitPub = AliHLTMUONConstants::DigitPublisherId();
270 handler->CreateConfiguration("DigitDDL13", digitPub, NULL, "-simdata -ddl 13");
271 handler->CreateConfiguration("DigitDDL14", digitPub, NULL, "-simdata -ddl 14");
272 handler->CreateConfiguration("DigitDDL15", digitPub, NULL, "-simdata -ddl 15");
273 handler->CreateConfiguration("DigitDDL16", digitPub, NULL, "-simdata -ddl 16");
274 handler->CreateConfiguration("DigitDDL17", digitPub, NULL, "-simdata -ddl 17");
275 handler->CreateConfiguration("DigitDDL18", digitPub, NULL, "-simdata -ddl 18");
276 handler->CreateConfiguration("DigitDDL19", digitPub, NULL, "-simdata -ddl 19");
277 handler->CreateConfiguration("DigitDDL20", digitPub, NULL, "-simdata -ddl 20");
278 handler->CreateConfiguration("DigitDDL21", digitPub, NULL, "-simdata -ddl 21");
279 handler->CreateConfiguration("DigitDDL22", digitPub, NULL, "-simdata -ddl 22");
280 const char* hrId = AliHLTMUONConstants::HitReconstructorId();
281 const char* trId = AliHLTMUONConstants::TriggerReconstructorId();
282 handler->CreateConfiguration("RecoDDL13", hrId, "DigitDDL13", "-ddl 13 -cdb");
283 handler->CreateConfiguration("RecoDDL14", hrId, "DigitDDL14", "-ddl 14 -cdb");
284 handler->CreateConfiguration("RecoDDL15", hrId, "DigitDDL15", "-ddl 15 -cdb");
285 handler->CreateConfiguration("RecoDDL16", hrId, "DigitDDL16", "-ddl 16 -cdb");
286 handler->CreateConfiguration("RecoDDL17", hrId, "DigitDDL17", "-ddl 17 -cdb");
287 handler->CreateConfiguration("RecoDDL18", hrId, "DigitDDL18", "-ddl 18 -cdb");
288 handler->CreateConfiguration("RecoDDL19", hrId, "DigitDDL19", "-ddl 19 -cdb");
289 handler->CreateConfiguration("RecoDDL20", hrId, "DigitDDL20", "-ddl 20 -cdb");
290 handler->CreateConfiguration("RecoDDL21", trId, "DigitDDL21", "-ddl 21 -cdb -suppress_partial_triggers");
291 handler->CreateConfiguration("RecoDDL22", trId, "DigitDDL22", "-ddl 22 -cdb -suppress_partial_triggers");
292
293 const char* recoSrcs = "RecoDDL13 RecoDDL14 RecoDDL15 RecoDDL16 RecoDDL17"
294 " RecoDDL18 RecoDDL19 RecoDDL20 RecoDDL21 RecoDDL22";
295 handler->CreateConfiguration("MansoTracker", trackerId, recoSrcs, "");
296
147b1df7 297 handler->CreateConfiguration("Decision", decCompId, "MansoTracker", "");
298
299 TString outputSrcs = "Decision MansoTracker ";
300 outputSrcs += recoSrcs;
301 handler->CreateConfiguration("dHLT-sim", "BlockFilter", outputSrcs.Data(), "");
887a669c 302
303 // Implement the dHLT-sim-fromMC dHLT simulation chain reading
304 // Monte Carlo geant hits and putting those into a tracker component.
305 const char* rhsId = AliHLTMUONConstants::RecHitsSourceId();
306 const char* trsId = AliHLTMUONConstants::TriggerRecordsSourceId();
307 handler->CreateConfiguration("HitsDDL13", rhsId, NULL, "-simdata -plane left -chamber 7");
308 handler->CreateConfiguration("HitsDDL14", rhsId, NULL, "-simdata -plane right -chamber 7");
309 handler->CreateConfiguration("HitsDDL15", rhsId, NULL, "-simdata -plane left -chamber 8");
310 handler->CreateConfiguration("HitsDDL16", rhsId, NULL, "-simdata -plane right -chamber 8");
311 handler->CreateConfiguration("HitsDDL17", rhsId, NULL, "-simdata -plane left -chamber 9");
312 handler->CreateConfiguration("HitsDDL18", rhsId, NULL, "-simdata -plane right -chamber 9");
313 handler->CreateConfiguration("HitsDDL19", rhsId, NULL, "-simdata -plane left -chamber 10");
314 handler->CreateConfiguration("HitsDDL20", rhsId, NULL, "-simdata -plane right -chamber 10");
315 handler->CreateConfiguration("TrigRecsDDL21", trsId, NULL, "-hitdata -plane left");
316 handler->CreateConfiguration("TrigRecsDDL22", trsId, NULL, "-hitdata -plane right");
317
318 const char* dataSrcs = "HitsDDL13 HitsDDL14 HitsDDL15 HitsDDL16 HitsDDL17"
319 " HitsDDL18 HitsDDL19 HitsDDL20 TrigRecsDDL21 TrigRecsDDL22";
320 handler->CreateConfiguration("MansoTrackerForMC", trackerId, dataSrcs, "");
321
147b1df7 322 handler->CreateConfiguration("DecisionForMC", decCompId, "MansoTrackerForMC", "");
323
324 outputSrcs = "DecisionForMC MansoTrackerForMC ";
325 outputSrcs += dataSrcs;
326 handler->CreateConfiguration("dHLT-sim-fromMC", "BlockFilter", outputSrcs.Data(), "");
887a669c 327 }
328
94135365 329 // Create a chain for generating AliESDEvent objects from dHLT raw reconstructed data.
330 handler->CreateConfiguration("HLTOUTPubTrigRecs", "AliHLTOUTPublisher", NULL, "-datatype 'TRIGRECS' 'MUON'");
331 handler->CreateConfiguration("HLTOUTPubMansoTracks", "AliHLTOUTPublisher", NULL, "-datatype 'MANTRACK' 'MUON'");
332 handler->CreateConfiguration(
333 "dHLT-make-esd",
334 AliHLTMUONConstants::ESDMakerId(),
335 "HLTOUTPubTrigRecs HLTOUTPubMansoTracks",
336 "-make_minimal_esd"
337 );
338
339 // Create a chain for rootifying the raw dHLT data and dumping to file.
340 // This is used during AliRoot reconstruction.
341 handler->CreateConfiguration("HLTOUTPubTrigDbg", "AliHLTOUTPublisher", NULL, "-datatype 'TRIGRDBG' 'MUON'");
342 handler->CreateConfiguration("HLTOUTPubHits", "AliHLTOUTPublisher", NULL, "-datatype 'RECHITS ' 'MUON'");
343 handler->CreateConfiguration("HLTOUTPubClusters", "AliHLTOUTPublisher", NULL, "-datatype 'CLUSTERS' 'MUON'");
344 handler->CreateConfiguration("HLTOUTPubChannels", "AliHLTOUTPublisher", NULL, "-datatype 'CHANNELS' 'MUON'");
345 handler->CreateConfiguration("HLTOUTPubCandidates", "AliHLTOUTPublisher", NULL, "-datatype 'MNCANDID' 'MUON'");
346 handler->CreateConfiguration("HLTOUTPubSingles", "AliHLTOUTPublisher", NULL, "-datatype 'DECIDSIN' 'MUON'");
347 handler->CreateConfiguration("HLTOUTPubPairs", "AliHLTOUTPublisher", NULL, "-datatype 'DECIDPAR' 'MUON'");
348 handler->CreateConfiguration(
349 "HLTOUTConverter",
350 AliHLTMUONConstants::RootifierComponentId(),
351 "HLTOUTPubTrigRecs HLTOUTPubTrigDbg HLTOUTPubHits HLTOUTPubClusters"
352 " HLTOUTPubChannels HLTOUTPubMansoTracks HLTOUTPubCandidates"
353 " HLTOUTPubSingles HLTOUTPubPairs",
354 ""
355 );
356 handler->CreateConfiguration(
357 "dHLT-rootify-and-dump",
358 "ROOTFileWriter",
359 "HLTOUTConverter",
360 "-concatenate-events -datafile dHLTRawData.root -specfmt"
361 );
362
d1ff7c16 363 return 0;
364}
6253e09b 365
366
367int AliHLTMUONAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
368{
369 ///
370 /// Registers all available components of this module.
371 /// @param pHandler [in] instance of the component handler.
372 ///
373
374 if (pHandler == NULL) return -EINVAL;
375 pHandler->AddComponent(new AliHLTMUONRecHitsSource);
376 pHandler->AddComponent(new AliHLTMUONTriggerRecordsSource);
887a669c 377 pHandler->AddComponent(new AliHLTMUONDigitPublisherComponent);
6253e09b 378 pHandler->AddComponent(new AliHLTMUONRootifierComponent);
379 pHandler->AddComponent(new AliHLTMUONHitReconstructorComponent);
380 pHandler->AddComponent(new AliHLTMUONTriggerReconstructorComponent);
381 pHandler->AddComponent(new AliHLTMUONMansoTrackerFSMComponent);
c9537879 382 pHandler->AddComponent(new AliHLTMUONDecisionComponent);
649ab027 383 pHandler->AddComponent(new AliHLTMUONESDMaker);
0528e93a 384 pHandler->AddComponent(new AliHLTMUONEmptyEventFilterComponent);
dba14d7d 385 pHandler->AddComponent(new AliHLTMUONDataCheckerComponent);
6253e09b 386 return 0;
387}
388
94135365 389
390int AliHLTMUONAgent::GetHandlerDescription(
391 AliHLTComponentDataType dt,
392#ifdef __DEBUG
393 AliHLTUInt32_t spec,
394#else
395 AliHLTUInt32_t /*spec*/,
396#endif
397 AliHLTOUTHandlerDesc& desc
398 ) const
399{
400 /// Get handler decription for MUON data in the HLTOUT data stream.
401
402 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
403 dt == AliHLTMUONConstants::MansoTracksBlockDataType()
404 )
405 {
406 HLTDebug("Indicating we can handle data type = %s and specification"
407 " = 0x%8.8X with dHLT-make-esd chain",
408 AliHLTComponent::DataType2Text(dt).c_str(),
409 spec
410 );
411 desc = AliHLTOUTHandlerDesc(kChain, dt, "dHLT-make-esd");
412 return 1;
413 }
414
415 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
416 dt == AliHLTMUONConstants::TrigRecsDebugBlockDataType() or
417 dt == AliHLTMUONConstants::RecHitsBlockDataType() or
418 dt == AliHLTMUONConstants::ClusterBlockDataType() or
419 dt == AliHLTMUONConstants::ChannelBlockDataType() or
420 dt == AliHLTMUONConstants::MansoTracksBlockDataType() or
421 dt == AliHLTMUONConstants::MansoCandidatesBlockDataType() or
422 dt == AliHLTMUONConstants::SinglesDecisionBlockDataType() or
423 dt == AliHLTMUONConstants::PairsDecisionBlockDataType()
424 )
425 {
426 HLTDebug("Indicating we can handle data type = %s and specification"
427 " = 0x%8.8X with dHLT-rootify-and-dump chain",
428 AliHLTComponent::DataType2Text(dt).c_str(),
429 spec
430 );
431 desc = AliHLTOUTHandlerDesc(kChain, dt, "dHLT-rootify-and-dump");
432 return 1;
433 }
434
435 return 0;
436}
437
438
439AliHLTOUTHandler* AliHLTMUONAgent::GetOutputHandler(
440 AliHLTComponentDataType dt,
441#ifdef __DEBUG
442 AliHLTUInt32_t spec
443#else
444 AliHLTUInt32_t /*spec*/
445#endif
446 )
447{
448 /// Get specific handler for MUON data in the HLTOUT data stream.
449
450 HLTDebug("Trying to create HLTOUT handler for data type = %s and"
451 " specification = 0x%8.8X",
452 AliHLTComponent::DataType2Text(dt).c_str(),
453 spec
454 );
455
456 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
457 dt == AliHLTMUONConstants::MansoTracksBlockDataType()
458 )
459 {
460 return &fgkESDMakerChain;
461 }
462
463 if (dt == AliHLTMUONConstants::TriggerRecordsBlockDataType() or
464 dt == AliHLTMUONConstants::TrigRecsDebugBlockDataType() or
465 dt == AliHLTMUONConstants::RecHitsBlockDataType() or
466 dt == AliHLTMUONConstants::ClusterBlockDataType() or
467 dt == AliHLTMUONConstants::ChannelBlockDataType() or
468 dt == AliHLTMUONConstants::MansoTracksBlockDataType() or
469 dt == AliHLTMUONConstants::MansoCandidatesBlockDataType() or
470 dt == AliHLTMUONConstants::SinglesDecisionBlockDataType() or
471 dt == AliHLTMUONConstants::PairsDecisionBlockDataType()
472 )
473 {
474 return &fgkRootifyDumpChain;
475 }
476
477 return NULL;
478}
479
480
481int AliHLTMUONAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
482{
483 /// Deletes the HLTOUT handlers. In this case since the handlers are
484 /// allocated statically, we just check that the right pointer was
485 /// given and exit.
486
487 HLTDebug("Trying to delete HLTOUT handler: %p", pInstance);
488
489 if (pInstance != &fgkESDMakerChain or pInstance != &fgkRootifyDumpChain)
490 return -EINVAL;
491
492 return 0;
493}