18179e7f4b5060195888299e7c5334b2cbfb5698
[u/mrichter/AliRoot.git] / HLT / MUON / macros / RunChain.C
1 /**************************************************************************
2  * This file is property of and copyright by the ALICE HLT Project        * 
3  * All rights reserved.                                                   *
4  *                                                                        *
5  * Primary Authors:                                                       *
6  *   Artur Szostak <artursz@iafrica.com>                                  *
7  *                                                                        *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          *
14  * provided "as is" without express or implied warranty.                  *
15  **************************************************************************/
16
17 /* This macro is used to run the dHLT component chain within the AliHLTSystem
18  * framework, which is a simulation of the dHLT online system's output.
19  * To run this macro you must be in the same directory as the galice.root
20  * files or in the directory containing the rawXX/ directories produced from
21  * AliRoot simulations.
22  * Also make sure the LUTs are in the same directory or specify the directory
23  * with the lutDir parameter option.
24  */
25
26 #if !defined(__CINT__) || defined(__MAKECINT__)
27 #include "HLT/BASE/AliHLTSystem.h"
28 #include "HLT/BASE/AliHLTConfiguration.h"
29 #include "AliLog.h"
30 #include "TString.h"
31 #include <iostream>
32 using std::cerr;
33 using std::endl;
34 #endif
35
36 /* @param chainType  Specifies the type of chain to run. This can be one of the
37  *     following:
38  *       "full" - Run the full dHLT chain. (default)
39  *       "ddlreco" - Run only the reconstruction of the DDL raw data up to hits
40  *                   and trigger records.
41  *       "tracker" - Run the tracker only using hits and trigger records from
42  *                   AliRoot simulation or offline reconstruction.
43  * @param firstEvent  The event number of the first event to process. (default = 0)
44  * @param lastEvent  The event number of the last event to process. If this is
45  *     less than firstEvent then it is set to firstEvent automatically. (default = -1)
46  * @param output  Specifies the kind of output to generate. The options can be one
47  *     of the following:
48  *       "bin" - Generates all possible output and dumps it to binary files
49  *                  using the FileWriter component.
50  *       "root" - Generates all possible output and writes it to a ROOT file
51  *                  using the ROOTFileWriter component.
52  *       "tracks_bin" - Generates only track data and dumps it to binary files
53  *                  using the FileWriter component. This option is equivalent to
54  *                  'bin' if the chain type is 'ddlreco'.
55  *       "tracks_root" - Generates only track data and writes it to a ROOT file
56  *                  using the ROOTFileWriter component. This option is equivalent
57  *                  to 'bin' if the chain type is 'ddlreco'.
58  * @param dataSource  This is the data source from which to use hits and trigger
59  *     records when we are running the tracker only chain. Note this parameter
60  *     only makes sense if chainType = "tracker". The possible options are:
61  *       "sim" - Take data from GEANT hits. (default)
62  *       "rec" - Take data from offline reconstructed hits and local trigger
63  *               objects.
64  * @param logLevel  Specifies the amount of logging messages produced by the HLT
65  *     system. The possible options are:
66  *       "normal" - Shows warnings, errors and information.
67  *       "max" - Shows everything including debug messages if they were compiled in.
68  *       "min" - Shows only error messages.
69  * @param lutDir  This is the directory in which the LUTs can be found.
70 ///TODO *      If it is set to "CDB" (case sensitive) then the LUTs will be loaded from
71 ///TODO *      CDB instead.
72  */
73 void RunChain(
74                 const char* chainType = "full",
75                 Int_t firstEvent = 0,
76                 Int_t lastEvent = -1,
77                 const char* output = "bin",
78                 const char* dataSource = "sim",
79                 const char* logLevel = "normal",
80                 const char* lutDir = "."
81         )
82 {
83         // Make sure that the lastEvent is greater than firstEvent.
84         if (lastEvent < firstEvent)
85                 lastEvent = firstEvent;
86         int eventCount = lastEvent - firstEvent + 1;
87         
88         bool buildDDLFilePubs = false;
89         bool buildDDLRecoComps = false;
90         bool buildSimDataPubs = false;
91         bool buildRecDataPubs = false;
92         bool buildTrackerComp = false;
93         bool maxLogging = false;
94         bool minLogging = false;
95         bool useRootWriter = false;
96         bool makeTracksOnly = false;
97         
98         // Parse the chainType, output, dataSource and logLevel option strings:
99         TString outOpt = output;
100         if (outOpt.CompareTo("bin", TString::kIgnoreCase) == 0)
101         {
102                 useRootWriter = false;
103         }
104         else if (outOpt.CompareTo("root", TString::kIgnoreCase) == 0)
105         {
106                 useRootWriter = true;
107         }
108         else if (outOpt.CompareTo("tracks_bin", TString::kIgnoreCase) == 0)
109         {
110                 useRootWriter = false;
111                 makeTracksOnly = true;
112         }
113         else if (outOpt.CompareTo("tracks_root", TString::kIgnoreCase) == 0)
114         {
115                 useRootWriter = true;
116                 makeTracksOnly = true;
117         }
118         else
119         {
120                 cerr << "ERROR: Unknown option for output: " << output << endl;
121                 return;
122         }
123         
124         TString chainOpt = chainType;
125         if (chainOpt.CompareTo("full", TString::kIgnoreCase) == 0)
126         {
127                 buildDDLFilePubs = true;
128                 buildDDLRecoComps = true;
129                 buildTrackerComp = true;
130         }
131         else if (chainOpt.CompareTo("ddlreco", TString::kIgnoreCase) == 0)
132         {
133                 buildDDLFilePubs = true;
134                 buildDDLRecoComps = true;
135         }
136         else if (chainOpt.CompareTo("tracker", TString::kIgnoreCase) == 0)
137         {
138                 buildTrackerComp = true;
139                 
140                 TString dataOpt = dataSource;
141                 if (dataOpt.CompareTo("sim", TString::kIgnoreCase) == 0)
142                 {
143                         buildSimDataPubs = true;
144                 }
145                 else if (dataOpt.CompareTo("rec", TString::kIgnoreCase) == 0)
146                 {
147                         buildRecDataPubs = true;
148                 }
149                 else
150                 {
151                         cerr << "ERROR: Unknown option for dataSource: " << dataSource << endl;
152                         return;
153                 }
154         }
155         else
156         {
157                 cerr << "ERROR: Unknown option for chainType: " << chainType << endl;
158                 return;
159         }
160         
161         TString logOpt = logLevel;
162         if (logOpt.CompareTo("normal", TString::kIgnoreCase) == 0)
163         {
164                 // nothing to do.
165         }
166         else if (logOpt.CompareTo("max", TString::kIgnoreCase) == 0)
167         {
168                 maxLogging = true;
169         }
170         else if (logOpt.CompareTo("min", TString::kIgnoreCase) == 0)
171         {
172                 minLogging = true;
173         }
174         else
175         {
176                 cerr << "ERROR: Unknown option for logLevel: " << logLevel << endl;
177                 return;
178         }
179         
180         // If we are supposed to make tracks only but are in a ddlreco chain
181         // then we clearly can only generate the DDL reconstructed data, so do that.
182         if (makeTracksOnly && ! buildTrackerComp)
183         {
184                 makeTracksOnly = false;
185         }
186         
187         // Now we can initialise the AliHLTSystem...
188         AliHLTSystem sys;
189         
190         // Start by setting up the logging.
191         if (maxLogging)
192         {
193                 AliLog::SetGlobalLogLevel(AliLog::kMaxType);
194                 sys.SetGlobalLoggingLevel(kHLTLogAll);
195         }
196         if (minLogging)
197         {
198                 sys.SetGlobalLoggingLevel(kHLTLogError);
199         }
200         
201         sys.LoadComponentLibraries("libAliHLTUtil.so");
202         sys.LoadComponentLibraries("libAliHLTMUON.so");
203
204         // The DDL file publishers are only needed if we create the ddlreco or
205         // full chains. The filename lists are built assuming the aliroot rawXX/
206         // directory structure.
207         if (buildDDLFilePubs)
208         {
209                 string cmd13 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x001000";
210                 string cmd14 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x002000";
211                 string cmd15 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x004000";
212                 string cmd16 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x008000";
213                 string cmd17 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x010000";
214                 string cmd18 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x020000";
215                 string cmd19 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x040000";
216                 string cmd20 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x080000";
217                 string cmd21 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x100000";
218                 string cmd22 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x200000";
219                 for (int i = firstEvent; i < lastEvent+1; i++)
220                 {
221                         if (i != 0)
222                         {
223                                 cmd13 += " -nextevent";
224                                 cmd14 += " -nextevent";
225                                 cmd15 += " -nextevent";
226                                 cmd16 += " -nextevent";
227                                 cmd17 += " -nextevent";
228                                 cmd18 += " -nextevent";
229                                 cmd19 += " -nextevent";
230                                 cmd20 += " -nextevent";
231                                 cmd21 += " -nextevent";
232                                 cmd22 += " -nextevent";
233                         }
234                         char buf[16];
235                         sprintf(buf, "%d", i);
236                         cmd13 += " -datafile raw"; cmd13 += buf; cmd13 += "/MUONTRK_2572.ddl";
237                         cmd14 += " -datafile raw"; cmd14 += buf; cmd14 += "/MUONTRK_2573.ddl";
238                         cmd15 += " -datafile raw"; cmd15 += buf; cmd15 += "/MUONTRK_2574.ddl";
239                         cmd16 += " -datafile raw"; cmd16 += buf; cmd16 += "/MUONTRK_2575.ddl";
240                         cmd17 += " -datafile raw"; cmd17 += buf; cmd17 += "/MUONTRK_2576.ddl";
241                         cmd18 += " -datafile raw"; cmd18 += buf; cmd18 += "/MUONTRK_2577.ddl";
242                         cmd19 += " -datafile raw"; cmd19 += buf; cmd19 += "/MUONTRK_2578.ddl";
243                         cmd20 += " -datafile raw"; cmd20 += buf; cmd20 += "/MUONTRK_2579.ddl";
244                         cmd21 += " -datafile raw"; cmd21 += buf; cmd21 += "/MUONTRG_2816.ddl";
245                         cmd22 += " -datafile raw"; cmd22 += buf; cmd22 += "/MUONTRG_2817.ddl";
246                 }
247
248                 AliHLTConfiguration pubDDL13("pubDDL13", "FilePublisher", NULL, cmd13.c_str());
249                 AliHLTConfiguration pubDDL14("pubDDL14", "FilePublisher", NULL, cmd14.c_str());
250                 AliHLTConfiguration pubDDL15("pubDDL15", "FilePublisher", NULL, cmd15.c_str());
251                 AliHLTConfiguration pubDDL16("pubDDL16", "FilePublisher", NULL, cmd16.c_str());
252                 AliHLTConfiguration pubDDL17("pubDDL17", "FilePublisher", NULL, cmd17.c_str());
253                 AliHLTConfiguration pubDDL18("pubDDL18", "FilePublisher", NULL, cmd18.c_str());
254                 AliHLTConfiguration pubDDL19("pubDDL19", "FilePublisher", NULL, cmd19.c_str());
255                 AliHLTConfiguration pubDDL20("pubDDL20", "FilePublisher", NULL, cmd20.c_str());
256                 AliHLTConfiguration pubDDL21("pubDDL21", "FilePublisher", NULL, cmd21.c_str());
257                 AliHLTConfiguration pubDDL22("pubDDL22", "FilePublisher", NULL, cmd22.c_str());
258         }
259         
260         // Build the DDL reconstructor components for all the DDLs 13 to 22, that
261         // is for chambers 7 to 10 and trigger stations. We only need to build
262         // these components if we are are building the ddlreco or full chains.
263         if (buildDDLRecoComps)
264         {
265                 AliHLTConfiguration recDDL13("recDDL13", "MUONHitReconstructor", "pubDDL13", TString("-ddl 13 -lut ") + lutDir + TString("/Lut13.dat"));
266                 AliHLTConfiguration recDDL14("recDDL14", "MUONHitReconstructor", "pubDDL14", TString("-ddl 14 -lut ") + lutDir + TString("/Lut14.dat"));
267                 AliHLTConfiguration recDDL15("recDDL15", "MUONHitReconstructor", "pubDDL15", TString("-ddl 15 -lut ") + lutDir + TString("/Lut15.dat"));
268                 AliHLTConfiguration recDDL16("recDDL16", "MUONHitReconstructor", "pubDDL16", TString("-ddl 16 -lut ") + lutDir + TString("/Lut16.dat"));
269                 AliHLTConfiguration recDDL17("recDDL17", "MUONHitReconstructor", "pubDDL17", TString("-ddl 17 -lut ") + lutDir + TString("/Lut17.dat"));
270                 AliHLTConfiguration recDDL18("recDDL18", "MUONHitReconstructor", "pubDDL18", TString("-ddl 18 -lut ") + lutDir + TString("/Lut18.dat"));
271                 AliHLTConfiguration recDDL19("recDDL19", "MUONHitReconstructor", "pubDDL19", TString("-ddl 19 -lut ") + lutDir + TString("/Lut19.dat"));
272                 AliHLTConfiguration recDDL20("recDDL20", "MUONHitReconstructor", "pubDDL20", TString("-ddl 20 -lut ") + lutDir + TString("/Lut20.dat"));        
273                 AliHLTConfiguration recDDL21("recDDL21", "MUONTriggerReconstructor", "pubDDL21", TString("-ddl 21 -lut ") + lutDir + TString("/Lut21.dat -suppress_partial_triggers"));
274                 AliHLTConfiguration recDDL22("recDDL22", "MUONTriggerReconstructor", "pubDDL22", TString("-ddl 22 -lut ") + lutDir + TString("/Lut22.dat -suppress_partial_triggers"));
275         }
276
277         TString startEventStr = "-firstevent ";
278         startEventStr += firstEvent;
279         
280         // Build the data source components to take data from simulated hits if
281         // we are building the tracker only chain with the 'sim' data source.
282         if (buildSimDataPubs)
283         {
284                 AliHLTConfiguration recDDL13("recDDL13", "MUONRecHitsSource", NULL, startEventStr + " -simdata -plane left  -chamber 7");
285                 AliHLTConfiguration recDDL14("recDDL14", "MUONRecHitsSource", NULL, startEventStr + " -simdata -plane right -chamber 7");
286                 AliHLTConfiguration recDDL15("recDDL15", "MUONRecHitsSource", NULL, startEventStr + " -simdata -plane left  -chamber 8");
287                 AliHLTConfiguration recDDL16("recDDL16", "MUONRecHitsSource", NULL, startEventStr + " -simdata -plane right -chamber 8");
288                 AliHLTConfiguration recDDL17("recDDL17", "MUONRecHitsSource", NULL, startEventStr + " -simdata -plane left  -chamber 9");
289                 AliHLTConfiguration recDDL18("recDDL18", "MUONRecHitsSource", NULL, startEventStr + " -simdata -plane right -chamber 9");
290                 AliHLTConfiguration recDDL19("recDDL19", "MUONRecHitsSource", NULL, startEventStr + " -simdata -plane left  -chamber 10");
291                 AliHLTConfiguration recDDL20("recDDL20", "MUONRecHitsSource", NULL, startEventStr + " -simdata -plane right -chamber 10");
292                 AliHLTConfiguration recDDL21("recDDL21", "MUONTriggerRecordsSource", NULL, startEventStr + " -hitdata -plane left");
293                 AliHLTConfiguration recDDL22("recDDL22", "MUONTriggerRecordsSource", NULL, startEventStr + " -hitdata -plane right");
294         }
295         
296         // Build the data source components to take data from offline reconstructed
297         // objects if we are building the tracker only chain with the 'rec' data source.
298         if (buildRecDataPubs)
299         {
300                 AliHLTConfiguration recDDL13("recDDL13", "MUONRecHitsSource", NULL, startEventStr + " -recdata -plane left  -chamber 7");
301                 AliHLTConfiguration recDDL14("recDDL14", "MUONRecHitsSource", NULL, startEventStr + " -recdata -plane right -chamber 7");
302                 AliHLTConfiguration recDDL15("recDDL15", "MUONRecHitsSource", NULL, startEventStr + " -recdata -plane left  -chamber 8");
303                 AliHLTConfiguration recDDL16("recDDL16", "MUONRecHitsSource", NULL, startEventStr + " -recdata -plane right -chamber 8");
304                 AliHLTConfiguration recDDL17("recDDL17", "MUONRecHitsSource", NULL, startEventStr + " -recdata -plane left  -chamber 9");
305                 AliHLTConfiguration recDDL18("recDDL18", "MUONRecHitsSource", NULL, startEventStr + " -recdata -plane right -chamber 9");
306                 AliHLTConfiguration recDDL19("recDDL19", "MUONRecHitsSource", NULL, startEventStr + " -recdata -plane left  -chamber 10");
307                 AliHLTConfiguration recDDL20("recDDL20", "MUONRecHitsSource", NULL, startEventStr + " -recdata -plane right -chamber 10");
308                 AliHLTConfiguration recDDL21("recDDL21", "MUONTriggerRecordsSource", NULL, startEventStr + " -recdata -plane left");
309                 AliHLTConfiguration recDDL22("recDDL22", "MUONTriggerRecordsSource", NULL, startEventStr + " -recdata -plane right");
310         }
311         
312         // Build the tracker component if we are building the tracker only or
313         // full chains.
314         if (buildTrackerComp)
315         {
316                 AliHLTConfiguration tracker("tracker", "MUONMansoTrackerFSM", "recDDL13 recDDL14 recDDL15 recDDL16 recDDL17 recDDL18 recDDL19 recDDL20 recDDL21 recDDL22", "");
317         }
318
319         // Build the data sink to subscribe only to what has been created and
320         // to the data source we actaully want.
321         TString sources = "";
322         if (makeTracksOnly)
323         {
324                 sources += "tracker ";
325         }
326         else
327         {
328                 if (buildTrackerComp)
329                         sources += "tracker ";
330                 sources += "recDDL13 recDDL14 recDDL15 recDDL16 recDDL17 recDDL18 recDDL19 recDDL20 recDDL21 recDDL22";
331         }
332         if (useRootWriter)
333         {
334                 AliHLTConfiguration convert("convert", "MUONRootifier", sources, "");
335                 AliHLTConfiguration sink("sink", "ROOTFileWriter", "convert", "-datafile output.root -specfmt");
336         }
337         else
338         {
339                 AliHLTConfiguration sink("sink", "FileWriter", sources, "-datafile output.dat -specfmt");
340         }
341         
342         // Build and run the chain's tasks.
343         sys.BuildTaskList("sink");
344         sys.Run(eventCount);
345 }