source: trunk/MagicSoft/Mars/callisto.cc@ 8650

Last change on this file since 8650 was 8539, checked in by tbretz, 17 years ago
*** empty log message ***
File size: 22.5 KB
Line 
1#include <TROOT.h>
2#include <TClass.h>
3#include <TSystem.h>
4#include <TGClient.h>
5#include <TApplication.h>
6#include <TObjectTable.h>
7
8#include "MLog.h"
9#include "MLogManip.h"
10
11#include "MEnv.h"
12#include "MArgs.h"
13#include "MArray.h"
14#include "MDirIter.h"
15
16#include "MStatusDisplay.h"
17
18#include "MSequence.h"
19#include "MJPedestal.h"
20#include "MJCalibration.h"
21#include "MJCalibrateSignal.h"
22#include "MJCalibTest.h"
23
24using namespace std;
25
26static void StartUpMessage()
27{
28 gLog << all << endl;
29
30 // 1 2 3 4 5
31 // 12345678901234567890123456789012345678901234567890
32 gLog << "========================================================" << endl;
33 gLog << " Callisto - MARS V" << MARSVER << endl;
34 gLog << " MARS -- CALibrate LIght Signals and Time Offsets" << endl;
35 gLog << " Compiled with ROOT v" << ROOT_RELEASE << " on <" << __DATE__ << ">" << endl;
36 gLog << "========================================================" << endl;
37 gLog << endl;
38}
39
40static void Usage()
41{
42 // 1 2 3 4 5 6 7 8
43 // 12345678901234567890123456789012345678901234567890123456789012345678901234567890
44 gLog << all << endl;
45 gLog << "Sorry the usage is:" << endl;
46 gLog << " callisto [-c] [-y] [options] sequence.txt|number" << endl << endl;
47 gLog << " Arguments:" << endl;
48 gLog << " sequence.txt: ASCII file defining a sequence of runs" << endl;
49 gLog << " number: The sequence number (using file in the datacenter)" << endl;
50 gLog << " For more details see MSequence" << endl;
51 gLog << " Root Options:" << endl;
52 gLog << " -b Batch mode (no graphical output to screen)" << endl<<endl;
53 gLog << " Operation Modes:" << endl;
54 gLog << " -c Calculate the calibration constants" << endl;
55 gLog << " -y Extract and calibrate signal" << endl << endl;
56 gLog << " Data Type (exclusive):" << endl;
57 gLog << " -mc Input root-files are monte carlo files" << endl;
58 gLog << " Options:" << endl;
59 gLog.Usage();
60 gLog << " --debug-env=0 Disable debugging setting resources <default>" << endl;
61 gLog << " --debug-env[=1] Display untouched resources after program execution" << endl;
62 gLog << " --debug-env=2 Display untouched resources after eventloop setup" << endl;
63 gLog << " --debug-env=3 Debug setting resources from resource file" << endl;
64 gLog << " --debug-mem Debug memory usage" << endl << endl;
65 gLog << endl;
66 gLog << " -q Quit when job is finished" << endl;
67 gLog << " -f Force overwrite of existing files" << endl;
68 gLog << " --ind=path Path where to search for the data files" << endl;
69 gLog << " [default=standard path in datacenter]" << endl;
70 gLog << " --iny=path Path where to search for the calibration files" << endl;
71 gLog << " [default=local path or output path of Mode-C]" << endl;
72 gLog << " --outc=path Path to write Mode-C result to [def=local path]" << endl;
73 gLog << " --outy=path Path to write Mode-Y result to [def=local path]" << endl;
74 gLog << " --out=path Path to write the all results to [def=local path]" << endl;
75 gLog << " (overwrites --outc and --outy)" << endl;
76 gLog << " --path=path Path to write the all results to [def=local path]" << endl;
77 gLog << " (overwrites --iny, --outc and --outy)" << endl;
78 gLog << " --print-seq Print Sequence information" << endl;
79 gLog << " --print-files Print Files taken from Sequence" << endl;
80 gLog << " --print-found Print Files found from Sequence" << endl;
81 gLog << " --use-test Apply calibration constants to same calibration" << endl;
82 gLog << " file (for testing, calibration mode only)" << endl;
83 gLog << " --movie Write a movie in addition to Mode-Y (this might " << endl;
84 gLog << " stop the eventloop before all evts are processed)" << endl;
85 gLog << " --moon Force using pedestal fits instead of calculated RMS" << endl;
86 gLog << " --config=callisto.rc Resource file [default=callisto.rc]" << endl;
87 gLog << endl;
88 gLog << " --version, -V Show startup message with version number" << endl;
89 gLog << " -?, -h, --help This help" << endl << endl;
90 gLog << " Setup of the two jobs run by callisto (MJPedestal and MJCalibration)" << endl;
91 gLog << " can be done with the resource file. See MJPedestal and MJCalibration" << endl;
92 gLog << " especially CheckEnv() for more details. Command line options might" << endl;
93 gLog << " be overwritten by the resource file." << endl << endl;
94 gLog << " If running in Mode-C and Mode-Y --iny= is obsolete, instead --outc=" << endl;
95 gLog << " is used." << endl << endl;
96 gLog << " Using --iny=, --outc=, --outy=, --out= or --path= automatically" << endl;
97 gLog << " enables the corresponding modes. In this case -c/-y are obsolete." << endl << endl;
98 gLog << "Description:" << endl;
99 gLog << " callisto will calculate pedestals from pedestal-files defined in a" << endl;
100 gLog << " sequence-file. This pedestals are used to calculate the calibration" << endl;
101 gLog << " constants. These constants are stored in a so called calibration-file" << endl;
102 gLog << " together with some datacheck plots which can be viewed using either" << endl;
103 gLog << " showplot or MStatusDisplay in the interpreter. A description of a" << endl;
104 gLog << " sequence-file can be found in the class reference of MSequence." << endl << endl;
105 gLog << "Background:" << endl;
106 gLog << " Callisto is a large, icy, dark-colored, low-density outer moon of" << endl;
107 gLog << " Jupiter that is scarred with impact craters and ejecta. It has a" << endl;
108 gLog << " diameter of about 4800km, the second-largest moon of Jupiter; it is" << endl;
109 gLog << " roughly the size of Mercury. Callisto has the largest-known impact" << endl;
110 gLog << " crater in the Solar System, Valhalla, which has a bright patch 600km" << endl;
111 gLog << " across and rings that go out to almost 3000km. Callisto orbits" << endl;
112 gLog << " Jupiter at a mean distance of 1,883,000km. Its mass is 1.1e23 kg. It" << endl;
113 gLog << " takes Callisto 16.7 days to orbit Jupiter in a synchronous orbit." << endl;
114 gLog << " Jupiter's moon Callisto was discovered independently by Galileo and" << endl;
115 gLog << " S.Marius in 1610." << endl << endl;
116 gLog << "Example:" << endl;
117 gLog << " callisto -f --outc=mycal/ --outy=mysignal/ --log sequence02345.txt" << endl;
118 gLog << endl;
119}
120
121static void PrintFiles(const MSequence &seq, const TString &kInpathD, Bool_t raw, Bool_t showall)
122{
123 const char *prep = showall ? "Found" : "Scheduled";
124
125 MDirIter Next1, Next2, Next3;
126 seq.SetupPedRuns(Next1, kInpathD, raw);
127 seq.SetupCalRuns(Next2, kInpathD, raw);
128 seq.SetupDatRuns(Next3, kInpathD, raw);
129
130 gLog << all;
131 gLog.Separator(Form("%s Pedestal Files", prep));
132 Next1.Print(showall?"all":"");
133 gLog << endl;
134 gLog.Separator(Form("%s Calibration Files", prep));
135 Next2.Print(showall?"all":"");
136 gLog << endl;
137 gLog.Separator(Form("%s Data Files", prep));
138 Next3.Print(showall?"all":"");
139 gLog << endl;
140}
141
142int main(int argc, char **argv)
143{
144 if (!MARS::CheckRootVer())
145 return 0xff;
146
147 MLog::RedirectErrorHandler(MLog::kColor);
148
149 //
150 // Evaluate arguments
151 //
152 MArgs arg(argc, argv, kTRUE);
153 gLog.Setup(arg);
154
155 StartUpMessage();
156
157 if (arg.HasOnly("-V") || arg.HasOnly("--version"))
158 return 0;
159
160 if (arg.HasOnly("-?") || arg.HasOnly("-h") || arg.HasOnly("--help"))
161 {
162 Usage();
163 return 2;
164 }
165
166 const TString kConfig = arg.GetStringAndRemove("--config=", "callisto.rc");
167
168 const Bool_t kPrintSeq = arg.HasOnlyAndRemove("--print-seq");
169 const Bool_t kPrintFiles = arg.HasOnlyAndRemove("--print-files");
170 const Bool_t kPrintFound = arg.HasOnlyAndRemove("--print-found");
171 const Bool_t kUseTest = arg.HasOnlyAndRemove("--use-test");
172 const Bool_t kMovie = arg.HasOnlyAndRemove("--movie");
173 const Bool_t kDebugMem = arg.HasOnlyAndRemove("--debug-mem");
174 Bool_t kMoon = arg.HasOnlyAndRemove("--moon");
175 Int_t kDebugEnv = arg.HasOnlyAndRemove("--debug-env") ? 1 : 0;
176 kDebugEnv = arg.GetIntAndRemove("--debug-env=", kDebugEnv);
177
178 const Bool_t kQuit = arg.HasOnlyAndRemove("-q");
179 const Bool_t kBatch = arg.HasOnlyAndRemove("-b");
180 const Bool_t kOverwrite = arg.HasOnlyAndRemove("-f");
181 //const Bool_t kForceExec = arg.HasOnlyAndRemove("-ff");
182
183 const TString kInpathD = arg.GetStringAndRemove("--ind=", "");
184 TString kInpathY = arg.GetStringAndRemove("--iny=", "");
185 TString kOutpathY = arg.GetStringAndRemove("--outy=", "");
186 TString kOutpathC = arg.GetStringAndRemove("--outc=", "");
187 const TString kOutpath = arg.GetStringAndRemove("--out=", "");
188 const TString kPath = arg.GetStringAndRemove("--path=", "");
189
190 Bool_t kModeC = arg.HasOnlyAndRemove("-c");
191 Bool_t kModeY = arg.HasOnlyAndRemove("-y");
192 const Bool_t kIsMC = arg.HasOnlyAndRemove("-mc");
193
194 if (!kInpathY.IsNull() || !kOutpathY.IsNull() || !kOutpath.IsNull() || !kPath.IsNull())
195 kModeY = kTRUE;
196 if (!kOutpathC.IsNull() || !kOutpath.IsNull() || !kPath.IsNull())
197 kModeC = kTRUE;
198
199 //
200 // check for the right usage of the program
201 //
202 if (arg.GetNumArguments()!=1)
203 {
204 Usage();
205 return 2;
206 }
207
208 if (arg.GetNumOptions()>0)
209 {
210 gLog << warn << "WARNING - Unknown commandline options..." << endl;
211 arg.Print("options");
212 gLog << endl;
213 return 2;
214 }
215
216 if (!kModeC && !kModeY /*&& !kUseTest*/)
217 {
218 gLog << err << "Neither calibration (-c), signal extraction (-y) or test-mode (--use-test)" << endl;
219 gLog << "specified! You can also give the operation mode by the options defining the" << endl;
220 gLog << "output path --outc, --outy or --out." << endl;
221 Usage();
222 return 2;
223 }
224 if (!kModeY && kMovie)
225 {
226 gLog << err << "Signal extraction mode (-y) not switched on but movie requested." << endl;
227 Usage();
228 return 2;
229 }
230
231 if ((kModeC/* || kUseTest*/) && kOutpathC.IsNull())
232 kOutpathC = ".";
233 if (kModeY)
234 {
235 if (kInpathY.IsNull())
236 kInpathY = ".";
237 if (kOutpathY.IsNull())
238 kOutpathY = ".";
239 }
240 if (!kOutpath.IsNull())
241 {
242 kOutpathC = kOutpath;
243 kOutpathY = kOutpath;
244 }
245 if (!kPath.IsNull())
246 {
247 kOutpathC = kOutpath;
248 kOutpathY = kOutpath;
249 kInpathY = kOutpath;
250 }
251
252 if (kModeC && kModeY)
253 kInpathY = kOutpathC;
254
255 //
256 // Setup sequence file and check for its existance
257 //
258 TString kSequence = arg.GetArgumentStr(0);
259
260 if (!MSequence::InflatePath(kSequence, kIsMC))
261 return 3;
262
263 if (kDebugMem)
264 TObject::SetObjectStat(kTRUE);
265
266 //
267 // Setup sequence and check its validity
268 //
269 MSequence seq(kSequence, kInpathD);
270 if (!seq.IsMonteCarlo())
271 seq.SetMonteCarlo(kIsMC);
272 if (kPrintSeq)
273 {
274 gLog << all;
275 gLog.Separator(kSequence);
276 seq.Print();
277 gLog << endl;
278 }
279 if (!seq.IsValid())
280 {
281 gLog << err << "Sequence read but not valid!" << endl << endl;
282 return 5;
283 }
284
285 //
286 // Process print options
287 //
288 if (kPrintFiles)
289 PrintFiles(seq, kInpathD, !seq.IsMonteCarlo(), kFALSE);
290 if (kPrintFound)
291 PrintFiles(seq, kInpathD, !seq.IsMonteCarlo(), kTRUE);
292
293 if (seq.HasMoon())
294 kMoon = kTRUE;
295
296
297 /*
298 //
299 // Check for existance of all files
300 //
301 MDirIter iter;
302 const Int_t n0 = seq.SetupAllRuns(iter, kInpathD, "[DPC]");
303 const Int_t n1 = seq.GetNumAllRuns();
304 if (n0 != n1)
305 {
306 if (kForceExec)
307 gLog << warn << "WARNING";
308 else
309 gLog << err << "ERROR";
310 gLog << " - " << n1 << " files in sequence defined, but " << n0 << " found in ";
311 gLog << (kInpathD.IsNull() ? "<defaultpath>" : kInpathD.Data()) << endl;
312 if (!kForceExec)
313 return 2;
314 }
315
316 if (kPrintOnly)
317 return 0;
318 */
319 //
320 // Initialize root
321 //
322 MArray::Class()->IgnoreTObjectStreamer();
323 MParContainer::Class()->IgnoreTObjectStreamer();
324
325 TApplication app("callisto", &argc, argv);
326 if (!gROOT->IsBatch() && !gClient || gROOT->IsBatch() && !kBatch)
327 {
328 gLog << err << "Bombing... maybe your DISPLAY variable is not set correctly!" << endl;
329 return 1;
330 }
331
332 //
333 // Update frequency by default = 1Hz
334 //
335 MStatusDisplay *d = new MStatusDisplay;
336
337 // From now on each 'Exit' means: Terminate the application
338 d->SetBit(MStatusDisplay::kExitLoopOnExit);
339 d->SetTitle(kSequence);
340
341 MEnv env(kConfig);
342 if (!env.IsValid())
343 {
344 gLog << err << "Configuration file " << kConfig << " not found." << endl;
345 return 0xfe;
346 }
347
348 if (kModeC/* || kUseTest*/)
349 {
350 //
351 // Calculate pedestal for pedestal-calculation and calibration
352 //
353 MJPedestal job1(Form("MJPedestalC1 #%d", seq.GetSequence()));
354 job1.SetNoStorage();
355 job1.SetSequence(seq);
356 job1.SetEnv(&env);
357 job1.SetEnvDebug(kDebugEnv);
358 job1.SetDisplay(d);
359 job1.SetOverwrite(kOverwrite);
360 job1.SetUseHists(kMoon);
361
362
363 job1.SetExtractionFundamental();
364 // job1.SetPathOut(kOutpathC); // not yet needed
365 // job1.SetPathIn(kInpathC); // DO NOT CALL IT. IT WOULD READ THE XEXTRACTOR FROM calib-file
366
367 if (!job1.Process())
368 {
369 gLog << err << "Calculation of pedestal failed." << endl << endl;
370 return 6;
371 }
372
373 if (!job1.GetDisplay())
374 {
375 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
376 return 1;
377 }
378
379 //
380 // Calculate pedestal and pedestal resolution
381 //
382 MJPedestal job2(Form("MJPedestalC2 #%d", seq.GetSequence()));
383 job2.SetNoStorage();
384 job2.SetSequence(seq);
385 job2.SetEnv(&env);
386 job2.SetEnvDebug(kDebugEnv);
387 job2.SetDisplay(d);;
388 job2.SetOverwrite(kOverwrite);
389 job2.SetUseHists(kMoon);
390 job2.SetDeadPixelCheck();
391 // job1.SetPathOut(kOutpathC); // not yet needed
392 // job1.SetPathIn(kInpathC); // DO NOT CALL IT. IT WOULD READ THE XEXTRACTOR FROM calib-file
393
394 //job2.SetExtractorResolution();
395 job2.SetExtractionWithExtractorRndm();
396 job2.SetExtractor(job1.GetExtractor());
397 job2.SetPedestals(job1.GetPedestalCam());
398 job2.SetBadPixels(job1.GetBadPixels());
399
400 // Please check the Changelog of 2005/04/20 about further deatils of the next comment
401 //if (job1.GetExtractor().InheritsFrom("MExtractTimeAndCharge"))
402 if (!job2.Process())
403 {
404 gLog << err << "Calculation of pedestal resolution failed." << endl << endl;
405 return 7;
406 }
407
408 if (!job2.GetDisplay())
409 {
410 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
411 return 1;
412 }
413
414 //
415 // Do calibration
416 //
417 MJCalibration job3(Form("MJCalibration #%d", seq.GetSequence()));
418 job3.SetSequence(seq);
419 job3.SetEnv(&env);
420 job3.SetEnvDebug(kDebugEnv);
421 job3.SetDisplay(d);
422 job3.SetOverwrite(kOverwrite);
423 job3.SetPathOut(kOutpathC);
424 // job2.SetPathIn(kInpathC); // not yet needed
425
426 job3.SetBadPixels(job2.GetBadPixels());
427 job3.SetExtractor(job2.GetExtractor());
428 job3.SetExtractorCam(job2.GetPedestalCam());
429
430 if (!job3.Process(job1.GetPedestalCam()))
431 {
432 gLog << err << "Calculation of calibration failed." << endl << endl;
433 return 8;
434 }
435
436 if (kDebugEnv>0)
437 env.PrintUntouched();
438
439 if (!job3.GetDisplay())
440 {
441 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
442 return 1;
443 }
444
445 if (kUseTest)
446 {
447 MJCalibTest job4(Form("MJCalibTest #%d", seq.GetSequence()));
448 job4.SetBadPixels(job2.GetBadPixels());
449 job4.SetSequence(seq);
450 job4.SetEnv(&env);
451 job4.SetEnvDebug(kDebugEnv);
452 job4.SetDisplay(d);;
453 job4.SetOverwrite(kOverwrite);
454 job4.SetPathOut(kOutpathC);
455
456 if (!job4.Process(job1.GetPedestalCam()))
457 {
458 gLog << err << "Calibration of calibration failed." << endl << endl;
459 return 9;
460 }
461
462 if (kDebugEnv>0)
463 env.PrintUntouched();
464
465 if (!job4.GetDisplay())
466 {
467 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
468 return 1;
469 }
470 }
471 }
472
473 if (kModeY)
474 {
475 d->Reset();
476
477 //
478 // Calculate starting pedestal for data extraction
479 //
480 MJPedestal job1(Form("MJPedestalY1 #%d", seq.GetSequence()));
481 job1.SetNoStorage();
482 job1.SetSequence(seq);
483 job1.SetEnv(&env);
484 job1.SetEnvDebug(kDebugEnv);
485 job1.SetDisplay(d);
486 job1.SetNoDisplay();
487 job1.SetOverwrite(kOverwrite);
488 job1.SetPathIn(kInpathY); // --> READ Extractor from calib-file
489 //job1.SetPathOut(kOutpathY); // not yet needed
490 job1.SetUseData();
491 job1.SetExtractionFundamental();
492 job1.SetUseHists(kMoon);
493
494 if (!job1.Process())
495 {
496 gLog << err << "Calculation of fundamental pedestal failed." << endl << endl;
497 return 10;
498 }
499
500 if (!job1.GetDisplay())
501 {
502 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
503 return 1;
504 }
505
506 //
507 // Calculate pedestal and pedestal resolution
508 //
509 MJPedestal job2(Form("MJPedestalY2 #%d", seq.GetSequence()));
510 job2.SetNoStorage(kMovie);
511 job2.SetSequence(seq);
512 job2.SetEnv(&env);
513 job2.SetEnvDebug(kDebugEnv);
514 job2.SetDisplay(d);
515 job2.SetNoDisplay();
516 job2.SetOverwrite(kOverwrite);
517 job2.SetPathIn(kInpathY);
518 job2.SetPulsePosCheck(!seq.IsMonteCarlo());
519 job2.SetPathOut(kOutpathY); // for updating the extractor
520
521 job2.SetUseData();
522 job2.SetExtractionWithExtractorRndm();
523 job2.SetExtractor(job1.GetExtractor());
524 job2.SetPedestals(job1.GetPedestalCam());
525 job2.SetBadPixels(job1.GetBadPixels());
526 job2.SetUseHists(kMoon);
527
528 // Please check the Changelog of 2005/04/20 about further deatils of the next comment
529 //if (job1.GetExtractor().InheritsFrom("MExtractTimeAndCharge"))
530 const Int_t rc = job2.Process();
531 if (rc<=0)
532 {
533 // rc==0: Error
534 // rc==-1: too much to the left
535 // rc==-2: too much to the right
536 // rc==-3: too much to the right (beyond limits)
537
538 gLog << err << "Calculation of pedestal from extractor (random) failed." << endl << endl;
539
540 //error coding for the automatic analysis (to be filled into the database)
541 switch (rc)
542 {
543 case 0:
544 return 11;
545 case -1:
546 return 12;
547 case -2:
548 return 13;
549 case -3:
550 return 14;
551 }
552 return 2;
553 }
554
555 if (!job2.GetDisplay())
556 {
557 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
558 return 1;
559 }
560
561 //
562 // Calculate pedestal and pedestal resolution
563 //
564 MJPedestal job3(Form("MJPedestalY3 #%d", seq.GetSequence()));
565 job3.SetNoStorage();
566 job3.SetSequence(seq);
567 job3.SetEnv(&env);
568 job3.SetEnvDebug(kDebugEnv);
569 job3.SetDisplay(d);
570 job3.SetNoDisplay();
571 job3.SetOverwrite(kOverwrite);
572 job3.SetPathIn(kInpathY);
573 // job1.SetPathOut(kOutpathC); // not yet needed
574 // job1.SetPathIn(kInpathC); // not yet needed
575
576 job3.SetUseData();
577 job3.SetExtractionWithExtractor();
578 job3.SetExtractor(job2.GetExtractor());
579 job3.SetPedestals(job1.GetPedestalCam());
580 job3.SetBadPixels(job1.GetBadPixels());
581 job3.SetUseHists(kMoon);
582
583 if (!job3.Process())
584 {
585 gLog << err << "Calculation of pedestal from extractor failed." << endl << endl;
586 return 15;
587 }
588
589 if (!job3.GetDisplay())
590 {
591 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
592 return 1;
593 }
594
595 //
596 // Extract signal and calibrate it
597 //
598 MJCalibrateSignal job4(Form("MJCalibrateSignal #%d", seq.GetSequence()));
599 job4.SetSequence(seq);
600 job4.SetDisplay(d);;
601 job4.SetEnv(&env);
602 job4.SetEnvDebug(kDebugEnv);
603 job4.SetOverwrite(kOverwrite);
604 job4.SetPathIn(kInpathY);
605 job4.SetPathOut(kOutpathY);
606 job4.SetMovieMode(kMovie);
607 if (!seq.IsMonteCarlo())
608 job4.SetExtractor(job2.GetExtractor());
609
610 // Where to search for calibration files
611 if (!job4.Process(job1.GetPedestalCam(), job3.GetPedestalCam(), job2.GetPedestalCam()))
612 return 16;
613
614 if (kDebugEnv>0)
615 env.PrintUntouched();
616
617 if (!job4.GetDisplay())
618 {
619 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
620 return 1;
621 }
622 }
623
624 if (kBatch || kQuit)
625 delete d;
626 else
627 {
628 // From now on each 'Close' means: Terminate the application
629 d->SetBit(MStatusDisplay::kExitLoopOnClose);
630
631 // Wait until the user decides to exit the application
632 app.Run(kFALSE);
633 }
634
635 if (TObject::GetObjectStat())
636 {
637 TObject::SetObjectStat(kFALSE);
638 gObjectTable->Print();
639 }
640
641 return 0;
642}
643
Note: See TracBrowser for help on using the repository browser.