]>
Commit | Line | Data |
---|---|---|
1 | // $Id$ | |
2 | ||
3 | //************************************************************************** | |
4 | //* This file is property of and copyright by the ALICE HLT Project * | |
5 | //* ALICE Experiment at CERN, All rights reserved. * | |
6 | //* * | |
7 | //* Primary Authors: Timur Pocheptsov <Timur.Pocheptsov@cern.ch> * | |
8 | //* Matthias Richter <Matthias.Richter@cern.ch> | |
9 | //* for The ALICE HLT Project. * | |
10 | //* * | |
11 | //* Permission to use, copy, modify and distribute this software and its * | |
12 | //* documentation strictly for non-commercial purposes is hereby granted * | |
13 | //* without fee, provided that the above copyright notice appears in all * | |
14 | //* copies and that both the copyright notice and this permission notice * | |
15 | //* appear in the supporting documentation. The authors make no claims * | |
16 | //* about the suitability of this software for any purpose. It is * | |
17 | //* provided "as is" without express or implied warranty. * | |
18 | //************************************************************************** | |
19 | ||
20 | /// @file AliHLTTTreeProcessor.cxx | |
21 | /// @author Timur Pocheptsov, Matthias Richter | |
22 | /// @date 05.07.2010 | |
23 | /// @brief Generic component for data collection in a TTree | |
24 | ||
25 | #include <cerrno> | |
26 | #include <memory> | |
27 | ||
28 | #include "AliHLTTTreeProcessor.h" | |
29 | #include "AliHLTErrorGuard.h" | |
30 | #include "TDirectory.h" | |
31 | #include "TDatime.h" | |
32 | #include "TString.h" | |
33 | #include "TTree.h" | |
34 | #include "TH1.h" | |
35 | #include "TStopwatch.h" | |
36 | #include "TUUID.h" | |
37 | #include "TSystem.h" | |
38 | #include "TRandom3.h" | |
39 | ||
40 | /** ROOT macro for the implementation of ROOT specific class methods */ | |
41 | ClassImp(AliHLTTTreeProcessor) | |
42 | ||
43 | AliHLTTTreeProcessor::AliHLTTTreeProcessor() | |
44 | : AliHLTProcessor(), | |
45 | fDefinitions(), | |
46 | fTree(0), | |
47 | fMaxEntries(kMaxEntries), | |
48 | fPublishInterval(kInterval), | |
49 | fLastTime(0), | |
50 | fpEventTimer(NULL), | |
51 | fpCycleTimer(NULL), | |
52 | fMaxMemory(700000), | |
53 | fMaxEventTime(0), | |
54 | fNofEventsForce(0), | |
55 | fForcedEventsCount(0), | |
56 | fSkippedEventsCount(0), | |
57 | fNewEventsCount(0), | |
58 | fUniqueId(0), | |
59 | fIgnoreCycleTime(10), | |
60 | fCycleTimeFactor(1.0) | |
61 | { | |
62 | // see header file for class documentation | |
63 | // or | |
64 | // refer to README to build package | |
65 | // or | |
66 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
67 | } | |
68 | ||
69 | const AliHLTUInt32_t AliHLTTTreeProcessor::fgkTimeScale=1000000; // ticks per second | |
70 | ||
71 | AliHLTTTreeProcessor::~AliHLTTTreeProcessor() | |
72 | { | |
73 | // see header file for class documentation | |
74 | } | |
75 | ||
76 | AliHLTComponentDataType AliHLTTTreeProcessor::GetOutputDataType() | |
77 | { | |
78 | // get the component output data type | |
79 | return kAliHLTDataTypeHistogram; | |
80 | } | |
81 | ||
82 | void AliHLTTTreeProcessor::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier) | |
83 | { | |
84 | // get the output size estimator | |
85 | // | |
86 | if (!fDefinitions.size()) { | |
87 | HLTError("Can not calculate output data size, no histogram definitions were provided"); | |
88 | return; | |
89 | } | |
90 | ||
91 | constBase = 0; | |
92 | for (list_const_iterator i = fDefinitions.begin(); i != fDefinitions.end(); ++i) | |
93 | constBase += i->GetSize(); | |
94 | ||
95 | inputMultiplier = 1.; | |
96 | } | |
97 | ||
98 | int AliHLTTTreeProcessor::DoInit(int argc, const char** argv) | |
99 | { | |
100 | // init component | |
101 | // ask child to create the tree. | |
102 | int iResult = 0; | |
103 | ||
104 | // component configuration | |
105 | //Stage 1: default initialization. | |
106 | //"Default" (for derived component) histograms. | |
107 | FillHistogramDefinitions(); | |
108 | //Default values. | |
109 | fMaxEntries = kMaxEntries; | |
110 | fPublishInterval = kInterval; | |
111 | fLastTime = 0; | |
112 | //Stage 2: OCDB. | |
113 | TString cdbPath("HLT/ConfigHLT/"); | |
114 | cdbPath += GetComponentID(); | |
115 | // | |
116 | iResult = ConfigureFromCDBTObjString(cdbPath); | |
117 | // | |
118 | if (iResult < 0) | |
119 | return iResult; | |
120 | //Stage 3: command line arguments. | |
121 | if (argc && (iResult = ConfigureFromArgumentString(argc, argv)) < 0) | |
122 | return iResult; | |
123 | ||
124 | // calculating a unique id from the hostname and process id | |
125 | // used for identifying output of multiple components | |
126 | TUUID guid = GenerateGUID(); | |
127 | union | |
128 | { | |
129 | UChar_t buf[16]; | |
130 | UInt_t bufAsInt[4]; | |
131 | }; | |
132 | guid.GetUUID(buf); | |
133 | fUniqueId = bufAsInt[0]; | |
134 | ||
135 | if (!fTree) { | |
136 | // originally foreseen to pass the arguments to the function, however | |
137 | // this is not appropriate. Argument scan via overloaded function | |
138 | // ScanConfigurationArgument | |
139 | std::auto_ptr<TTree> ptr(CreateTree(0, NULL)); | |
140 | if (ptr.get()) { | |
141 | ptr->SetDirectory(0); | |
142 | ptr->SetCircular(fMaxEntries); | |
143 | fTree = ptr.release(); | |
144 | } else //No way to process error correctly - error is unknown here. | |
145 | return -EINVAL; | |
146 | } else { | |
147 | HLTError("fTree pointer must be null before DoInit call"); | |
148 | return -EINVAL; | |
149 | } | |
150 | ||
151 | if (iResult>=0 && fMaxEventTime>0) { | |
152 | fpEventTimer=new TStopwatch; | |
153 | if (fpEventTimer) { | |
154 | fpEventTimer->Reset(); | |
155 | } | |
156 | fpCycleTimer=new TStopwatch; | |
157 | if (fpCycleTimer) { | |
158 | fpCycleTimer->Reset(); | |
159 | } | |
160 | } | |
161 | fSkippedEventsCount=0; | |
162 | ||
163 | return iResult; | |
164 | } | |
165 | ||
166 | int AliHLTTTreeProcessor::DoDeinit() | |
167 | { | |
168 | // cleanup component | |
169 | delete fTree; | |
170 | fTree = 0; | |
171 | fDefinitions.clear(); | |
172 | ||
173 | if (fpEventTimer) delete fpEventTimer; | |
174 | fpEventTimer=NULL; | |
175 | if (fpCycleTimer) delete fpCycleTimer; | |
176 | fpCycleTimer=NULL; | |
177 | ||
178 | return 0; | |
179 | } | |
180 | ||
181 | int AliHLTTTreeProcessor::DoEvent(const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData) | |
182 | { | |
183 | //Process event and publish histograms. | |
184 | AliHLTUInt32_t eventType=0; | |
185 | if (!IsDataEvent(&eventType) && eventType!=gkAliEventTypeEndOfRun) return 0; | |
186 | ||
187 | //I'm pretty sure, that if fTree == 0 (DoInit failed) DoEvent is not called. | |
188 | //But interface itself does not force you to call DoInit before DoEvent, so, | |
189 | //I make this check explicit. | |
190 | if (!fTree) { | |
191 | HLTError("fTree is a null pointer, try to call AliHLTTTreeProcessor::DoInit first."); | |
192 | return -EINVAL;//-ENULLTREE? :) | |
193 | } | |
194 | ||
195 | AliHLTUInt32_t averageEventTime=0; | |
196 | AliHLTUInt32_t averageCycleTime=0; | |
197 | ||
198 | int fillingtime=0; | |
199 | int publishtime=0; | |
200 | bool bDoFilling=true; | |
201 | bool bDoPublishing=false; | |
202 | const int cycleResetInterval=1000; | |
203 | if (fpEventTimer && fpCycleTimer) { | |
204 | averageEventTime=AliHLTUInt32_t(fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1); | |
205 | fillingtime=int(fpEventTimer->RealTime()*fgkTimeScale); | |
206 | publishtime=fillingtime; | |
207 | fpEventTimer->Start(kFALSE); | |
208 | fpCycleTimer->Stop(); | |
209 | averageCycleTime=AliHLTUInt32_t(fpCycleTimer->RealTime()*fgkTimeScale)/((GetEventCount()%cycleResetInterval)+1); | |
210 | // adapt processing to 3/4 of the max time | |
211 | bDoFilling=4*averageEventTime<3*fMaxEventTime || | |
212 | (averageEventTime<fCycleTimeFactor*averageCycleTime && fpCycleTimer->RealTime()>fIgnoreCycleTime); | |
213 | if (fNofEventsForce>0 && fForcedEventsCount<fNofEventsForce) { | |
214 | fForcedEventsCount++; | |
215 | bDoFilling=true; | |
216 | } | |
217 | } | |
218 | ||
219 | // FIXME: there is still an unclear increase in memory consumption, even if the number of entries | |
220 | // in the tree is restricted. Valgrind studies did not show an obvious memory leak. This is likely | |
221 | // to be caused by something deep in the Root TTree functionality and needs to be studied in detail. | |
222 | ProcInfo_t ProcInfo; | |
223 | gSystem->GetProcInfo(&ProcInfo); | |
224 | if (ProcInfo.fMemResident>fMaxMemory) bDoFilling=false; | |
225 | ||
226 | // process input data blocks and fill the tree | |
227 | int iResult = 0; | |
228 | if (eventType!=gkAliEventTypeEndOfRun) { | |
229 | if (bDoFilling) {iResult=FillTree(fTree, evtData, trigData); fNewEventsCount++;} | |
230 | else fSkippedEventsCount++; | |
231 | } | |
232 | if (fpEventTimer) { | |
233 | fpEventTimer->Stop(); | |
234 | fillingtime=int(fpEventTimer->RealTime()*fgkTimeScale)-fillingtime; | |
235 | if (fillingtime<0) fillingtime=0; | |
236 | fpEventTimer->Start(kFALSE); | |
237 | } | |
238 | ||
239 | if (iResult < 0) { | |
240 | ALIHLTERRORGUARD(5, "FillTree failed with %d, first event %d", iResult, GetEventCount()); | |
241 | return iResult; | |
242 | } | |
243 | ||
244 | const TDatime time; | |
245 | ||
246 | if (( time.Get() - fLastTime > fPublishInterval && fNewEventsCount>0) || | |
247 | eventType==gkAliEventTypeEndOfRun) { | |
248 | if ((bDoPublishing=fLastTime>0)) { // publish earliest after the first interval but set the timer | |
249 | ||
250 | for (list_const_iterator i = fDefinitions.begin(); i != fDefinitions.end(); ++i) { | |
251 | if (TH1* h = CreateHistogram(*i)) { | |
252 | //I do not care about errors here - since I'm not able | |
253 | //to rollback changes. | |
254 | // TODO: in case of -ENOSPC et the size of the last object by calling | |
255 | // GetLastObjectSize() and accumulate the necessary output buffer size | |
256 | PushBack(h, GetOriginDataType(), GetDataSpec()); | |
257 | delete h; | |
258 | } | |
259 | } | |
260 | unsigned eventcount=GetEventCount()+1; | |
261 | HLTBenchmark("publishing %d histograms, %d entries in tree, %d new events since last publishing, accumulated %d of %d events (%.1f%%)", fDefinitions.size(), fTree->GetEntriesFast(), fNewEventsCount, eventcount-fSkippedEventsCount, eventcount, eventcount>0?(100*float(eventcount-fSkippedEventsCount)/eventcount):0); | |
262 | fNewEventsCount=0; | |
263 | HLTBenchmark("current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual); | |
264 | } | |
265 | ||
266 | fLastTime=time.Get(); | |
267 | if (fLastTime==0) { | |
268 | // choose a random offset at beginning to equalize traffic for multiple instances | |
269 | // of the component | |
270 | gRandom->SetSeed(fUniqueId); | |
271 | fLastTime-=gRandom->Integer(fPublishInterval); | |
272 | } | |
273 | } | |
274 | ||
275 | if (fpEventTimer) { | |
276 | fpEventTimer->Stop(); | |
277 | publishtime=int(fpEventTimer->RealTime()*fgkTimeScale)-publishtime; | |
278 | if (publishtime>fillingtime) publishtime-=fillingtime; | |
279 | else publishtime=0; | |
280 | ||
281 | averageEventTime=AliHLTUInt32_t(fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1); | |
282 | ||
283 | // info output once every 5 seconds | |
284 | static UInt_t lastTime=0; | |
285 | if (time.Get()-lastTime>5 || | |
286 | eventType==gkAliEventTypeEndOfRun || | |
287 | bDoPublishing) { | |
288 | lastTime=time.Get(); | |
289 | unsigned eventcount=GetEventCount()+1; | |
290 | HLTBenchmark("filling time %d us, publishing time %d, average total processing time %d us, cycle time %d us, accumulated %d of %d events (%.1f%%)", fillingtime, publishtime, averageEventTime, averageCycleTime, eventcount-fSkippedEventsCount, eventcount, eventcount>0?(100*float(eventcount-fSkippedEventsCount)/eventcount):0); | |
291 | } | |
292 | } | |
293 | if (fpCycleTimer) { | |
294 | bool bReset=(GetEventCount()%cycleResetInterval)==0; | |
295 | fpCycleTimer->Start(bReset); | |
296 | } | |
297 | ||
298 | return iResult; | |
299 | } | |
300 | ||
301 | int AliHLTTTreeProcessor::ScanConfigurationArgument(int argc, const char** argv) | |
302 | { | |
303 | // scan one argument and its parameters from the list | |
304 | // return number of processed entries. | |
305 | // possible arguments: | |
306 | // -maxentries number | |
307 | // -interval number | |
308 | // -histogram name -size number -expression expression [-title expression ] -cut expression ][-opt option] | |
309 | // As soon as "-histogram" found, -size and -expression and -outtype are required, | |
310 | // cut and option can be omitted. | |
311 | if (argc <= 0) | |
312 | return 0; | |
313 | ||
314 | std::list<AliHLTHistogramDefinition> newDefs; | |
315 | AliHLTHistogramDefinition def; | |
316 | ||
317 | int i = 0; | |
318 | int maxEntries = fMaxEntries; | |
319 | ||
320 | while (i < argc) { | |
321 | const TString argument(argv[i]); | |
322 | ||
323 | if (argument.CompareTo("-maxentries") == 0) { //1. Max entries argument for TTree. | |
324 | if (i + 1 == argc) { | |
325 | HLTError("Numeric value for '-maxentries' is expected"); | |
326 | return -EPROTO; | |
327 | } | |
328 | //Next must be a number. | |
329 | //TString returns 0 (number) even if string contains non-numeric symbols. | |
330 | maxEntries = TString(argv[i + 1]).Atoi(); | |
331 | if (maxEntries <= 0) { | |
332 | HLTError("Bad value for '-maxentries': %d", maxEntries); | |
333 | return -EPROTO; | |
334 | } | |
335 | ||
336 | i += 2; | |
337 | } else if (argument.CompareTo("-interval") == 0) { //2. Interval argument for publishing. | |
338 | if (i + 1 == argc) { | |
339 | HLTError("Numeric value for '-interval' is expected"); | |
340 | return -EPROTO; | |
341 | } | |
342 | ||
343 | const Int_t interval = TString(argv[i + 1]).Atoi(); | |
344 | if (interval < 0) { | |
345 | HLTError("Bad value for '-interval' argument: %d", interval); | |
346 | return -EPROTO; | |
347 | } | |
348 | ||
349 | fPublishInterval = interval; | |
350 | ||
351 | i += 2; | |
352 | } else if (argument.CompareTo("-maxeventtime") == 0) { // max average processing time in us | |
353 | if (i + 1 == argc) { | |
354 | HLTError("Numeric value for '-maxeventtime' is expected"); | |
355 | return -EPROTO; | |
356 | } | |
357 | ||
358 | const Int_t time = TString(argv[i + 1]).Atoi(); | |
359 | if (time < 0) { | |
360 | HLTError("Bad value for '-maxeventtime' argument: %d", time); | |
361 | return -EPROTO; | |
362 | } | |
363 | ||
364 | fMaxEventTime = time; | |
365 | ||
366 | i += 2; | |
367 | } else if (argument.CompareTo("-forced-events") == 0) { // number of forced events | |
368 | if (i + 1 == argc) { | |
369 | HLTError("Numeric value for '-forced-events' is expected"); | |
370 | return -EPROTO; | |
371 | } | |
372 | ||
373 | const Int_t count = TString(argv[i + 1]).Atoi(); | |
374 | if (count < 0) { | |
375 | HLTError("Bad value for '-forced-events' argument: %d", count); | |
376 | return -EPROTO; | |
377 | } | |
378 | ||
379 | fNofEventsForce = count; | |
380 | fForcedEventsCount=0; | |
381 | ||
382 | i += 2; | |
383 | } else if (argument.CompareTo("-ignore-cycletime") == 0) { // ignore cycle time for n sec | |
384 | if (i + 1 == argc) { | |
385 | HLTError("Numeric value for '-ignore-cycletime' is expected"); | |
386 | return -EPROTO; | |
387 | } | |
388 | ||
389 | const Int_t time = TString(argv[i + 1]).Atoi(); | |
390 | if (time < 0) { | |
391 | HLTError("Bad value for '-ignore-cycletime' argument: %d", time); | |
392 | return -EPROTO; | |
393 | } | |
394 | ||
395 | fIgnoreCycleTime = time; | |
396 | i += 2; | |
397 | } else if (argument.CompareTo("-maxmemory") == 0) { // maximum of memory in kByte to be used by the component | |
398 | if (i + 1 == argc) { | |
399 | HLTError("Numeric value for '-maxmemory' is expected"); | |
400 | return -EPROTO; | |
401 | } | |
402 | ||
403 | const Int_t mem = TString(argv[i + 1]).Atoi(); | |
404 | if (mem < 0) { | |
405 | HLTError("Bad value for '-maxmemory' argument: %d", time); | |
406 | return -EPROTO; | |
407 | } | |
408 | ||
409 | fMaxMemory = mem; | |
410 | i += 2; | |
411 | } else if (argument.CompareTo("-cycletime-factor") == 0) { // weight factor for cycle time | |
412 | if (i + 1 == argc) { | |
413 | HLTError("Numeric value for '-cycletime-factor' is expected"); | |
414 | return -EPROTO; | |
415 | } | |
416 | ||
417 | const Float_t factor = TString(argv[i + 1]).Atof(); | |
418 | if (factor < 0) { | |
419 | HLTError("Bad value for '-cycletime-factor' argument: %f", factor); | |
420 | return -EPROTO; | |
421 | } | |
422 | ||
423 | fCycleTimeFactor = factor; | |
424 | i += 2; | |
425 | } else if (argument.CompareTo("-histogram") == 0) { //3. Histogramm definition. | |
426 | const int nParsed = ParseHistogramDefinition(argc, argv, i, def); | |
427 | if (!nParsed) | |
428 | return -EPROTO; | |
429 | ||
430 | newDefs.push_back(def); | |
431 | ||
432 | i += nParsed; | |
433 | } else { | |
434 | HLTError("Unknown argument %s", argument.Data()); | |
435 | return -EPROTO; | |
436 | } | |
437 | } | |
438 | ||
439 | if (maxEntries != fMaxEntries) { | |
440 | fMaxEntries = maxEntries; | |
441 | if (fTree) { | |
442 | fTree->Reset(); | |
443 | fTree->SetCircular(fMaxEntries); | |
444 | } | |
445 | } | |
446 | ||
447 | if (newDefs.size()) | |
448 | fDefinitions.swap(newDefs); | |
449 | ||
450 | return i; | |
451 | } | |
452 | ||
453 | TH1* AliHLTTTreeProcessor::CreateHistogram(const AliHLTHistogramDefinition& d) | |
454 | { | |
455 | ||
456 | // create a histogram from the tree | |
457 | if (!fTree) { | |
458 | HLTError("fTree is a null pointer, try to call AliHLTTTreeProcessor::DoInit first."); | |
459 | return 0; | |
460 | } | |
461 | ||
462 | TString histName(d.GetName()); | |
463 | if (!histName.Contains("(")) { | |
464 | //Without number of bins, the histogram will be "fixed" | |
465 | //and most of values can go to underflow/overflow bins, | |
466 | //since kCanRebin will be false. | |
467 | histName += TString::Format("(%d)", Int_t(kDefaultNBins)); | |
468 | } | |
469 | ||
470 | const Long64_t rez = fTree->Project(histName.Data(), d.GetExpression().Data(), d.GetCut().Data(), d.GetDrawOption().Data()); | |
471 | ||
472 | if (rez == -1) { | |
473 | HLTError("TTree::Project failed"); | |
474 | return 0; | |
475 | } | |
476 | ||
477 | //Now, cut off the binning part of a name | |
478 | histName = histName(0, histName.Index("(")); | |
479 | TH1 * hist = dynamic_cast<TH1*>(gDirectory->Get(histName.Data())); | |
480 | if (!hist) { | |
481 | const TString msg(Form("Hist %s is a null pointer, selection was %s, strange name or hist's type\n", histName.Data(), d.GetExpression().Data())); | |
482 | HLTError(msg.Data()); | |
483 | }else if (d.GetDrawOption().Length()) { | |
484 | hist->SetOption(d.GetDrawOption().Data()); | |
485 | } | |
486 | ||
487 | //Reformatting the histogram name | |
488 | TString str2=d.GetCut().Data(); | |
489 | str2.ReplaceAll("Track_", ""); | |
490 | str2.ReplaceAll("&&", " "); | |
491 | str2 = histName+" "+str2; | |
492 | hist->SetTitle(str2); | |
493 | ||
494 | if(d.GetTitle().Length()){ | |
495 | ||
496 | //removing underscore | |
497 | size_t found; | |
498 | string str=d.GetTitle().Data(); | |
499 | found=str.find_first_of("_"); | |
500 | if(!(d.GetExpression().CompareTo("Track_pt"))){ | |
501 | found=str.find_first_of("_",found+1); | |
502 | } | |
503 | str[found]=' '; | |
504 | char axis[100]; | |
505 | sprintf(axis,"%s",str.c_str()); | |
506 | ||
507 | hist->SetXTitle(axis); | |
508 | hist->GetXaxis()->CenterTitle(); | |
509 | } | |
510 | return hist; | |
511 | } | |
512 | ||
513 | int AliHLTTTreeProcessor::ParseHistogramDefinition(int argc, const char** argv, int pos, AliHLTHistogramDefinition& dst)const | |
514 | { | |
515 | //Histogram-definition: | |
516 | // -histogram name -size number -expression expression [-title expression][-cut expression][-opt option] | |
517 | ||
518 | //at pos we have '-histogram', at pos + 1 must be the name. | |
519 | if (pos + 1 == argc) { | |
520 | HLTError("Bad histogram definition, histogram name is expected"); | |
521 | return 0; | |
522 | } | |
523 | ||
524 | dst.SetName(argv[pos + 1]); | |
525 | pos += 2; | |
526 | ||
527 | //At pos must be '-size', and number at pos + 1. | |
528 | if (pos == argc || TString(argv[pos]).CompareTo("-size")) { | |
529 | HLTError("Bad histogram definition, '-size' is expected"); | |
530 | return 0; | |
531 | } | |
532 | ||
533 | if (pos + 1 == argc) { | |
534 | HLTError("Bad histogram definition, size is expected"); | |
535 | return 0; | |
536 | } | |
537 | ||
538 | dst.SetSize(TString(argv[pos + 1]).Atoi()); | |
539 | if (dst.GetSize() <= 0) { | |
540 | HLTError("Bad histogram definition, positive size is required"); | |
541 | return 0; | |
542 | } | |
543 | ||
544 | pos += 2; | |
545 | //At pos must be '-expression', and expression at pos + 1. | |
546 | if (pos == argc || TString(argv[pos]).CompareTo("-expression")) { | |
547 | HLTError("Bad histogram definition, '-expression' is expected"); | |
548 | return 0; | |
549 | } | |
550 | ||
551 | if (pos + 1 == argc) { | |
552 | HLTError("Bad histogram definition, expression is expected"); | |
553 | return 0; | |
554 | } | |
555 | ||
556 | dst.SetExpression(argv[pos + 1]); | |
557 | pos += 2; | |
558 | ||
559 | int processed = 6; | |
560 | dst.SetTitle(""); | |
561 | dst.SetCut(""); | |
562 | dst.SetDrawOption(""); | |
563 | ||
564 | //remaining options can be the title, cut and Draw option. | |
565 | //title must be first | |
566 | if (pos + 1 >= argc){ | |
567 | return processed; | |
568 | } | |
569 | if (TString(argv[pos]).CompareTo("-title") == 0) { | |
570 | dst.SetTitle(argv[pos + 1]); | |
571 | pos += 2; | |
572 | processed += 2; | |
573 | } | |
574 | ||
575 | //cut must be second. | |
576 | if (pos + 1 >= argc) | |
577 | return processed; | |
578 | ||
579 | if (TString(argv[pos]).CompareTo("-cut") == 0) { | |
580 | dst.SetCut(argv[pos + 1]); | |
581 | pos += 2; | |
582 | processed += 2; | |
583 | } | |
584 | ||
585 | if (pos + 1 >= argc) | |
586 | return processed; | |
587 | ||
588 | if (TString(argv[pos]).CompareTo("-opt") == 0) { | |
589 | dst.SetDrawOption(argv[pos + 1]); | |
590 | processed += 2; | |
591 | } | |
592 | ||
593 | return processed; | |
594 | } |