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