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