]>
Commit | Line | Data |
---|---|---|
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. |
45 | AliHLTMUONAgent AliHLTMUONAgent::fgkInstance; | |
d1ff7c16 | 46 | |
94135365 | 47 | AliHLTOUTHandlerChain AliHLTMUONAgent::fgkESDMakerChain("libAliHLTMUON.so chains=dHLT-make-esd"); |
48 | AliHLTOUTHandlerChain AliHLTMUONAgent::fgkRootifyDumpChain("libAliHLTMUON.so chains=dHLT-rootify-and-dump"); | |
49 | ||
50 | ||
d1ff7c16 | 51 | ClassImp(AliHLTMUONAgent); |
52 | ||
53 | ||
626bfcc1 | 54 | AliHLTMUONAgent::AliHLTMUONAgent() : AliHLTModuleAgent("MUON") |
d1ff7c16 | 55 | { |
6253e09b | 56 | /// |
57 | /// Default constructor. | |
58 | /// | |
d1ff7c16 | 59 | } |
60 | ||
61 | AliHLTMUONAgent::~AliHLTMUONAgent() | |
62 | { | |
6253e09b | 63 | /// |
64 | /// Default destructor. | |
65 | /// | |
d1ff7c16 | 66 | } |
67 | ||
887a669c | 68 | const 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 | ||
116 | const 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 | ||
192 | int 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 | ||
367 | int 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 | |
390 | int 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 | ||
439 | AliHLTOUTHandler* 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 | ||
481 | int 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 | } |