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

Last change on this file since 7082 was 7001, checked in by tbretz, 20 years ago
*** empty log message ***
File size: 22.1 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 on <" << __DATE__ << ">" << endl;
36 gLog << " Using ROOT v" << ROOTVER << endl;
37 gLog << "========================================================" << endl;
38 gLog << endl;
39}
40
41static void Usage()
42{
43 // 1 2 3 4 5 6 7 8
44 // 12345678901234567890123456789012345678901234567890123456789012345678901234567890
45 gLog << all << endl;
46 gLog << "Sorry the usage is:" << endl;
47 gLog << " callisto [-c] [-y] [options] sequence.txt" << endl << endl;
48 gLog << " Arguments:" << endl;
49 gLog << " sequence.txt: Ascii file defining a sequence of runs" << 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 << " -raw Read input from raw-data" << endl;
58 gLog << " -mc Input root-files are monte carlo files" << endl;
59 gLog << " -root Read input from root-files (merpped) <default>" << endl << endl;
60 gLog << " Options:" << endl;
61 gLog.Usage();
62 gLog << " --debug-env=0 Disable debugging setting resources <default>" << endl;
63 gLog << " --debug-env[=1] Display untouched resources after program execution" << endl;
64 gLog << " --debug-env=2 Display untouched resources after eventloop setup" << endl;
65 gLog << " --debug-env=3 Debug setting resources from resource file" << endl;
66 gLog << " --debug-mem Debug memory usage" << endl << endl;
67 gLog << endl;
68 gLog << " -q Quit when job is finished" << endl;
69 gLog << " -f Force overwrite of existing files" << endl;
70 gLog << " --ind=path Path where to search for the data files" << endl;
71 gLog << " [default=standard path in datacenter]" << endl;
72 gLog << " --iny=path Path where to search for the calibration files" << endl;
73 gLog << " [default=local path or output path of Mode-C]" << endl;
74 gLog << " --outc=path Path to write Mode-C result to [def=local path]" << endl;
75 gLog << " --outy=path Path to write Mode-Y result to [def=local path]" << endl;
76 gLog << " --out=path Path to write the all results to [def=local path]" << endl;
77 gLog << " (overwrites --outc and --outy)" << endl;
78 gLog << " --path=path Path to write the all results to [def=local path]" << endl;
79 gLog << " (overwrites --iny, --outc and --outy)" << endl;
80 gLog << " --print-seq Print Sequence information" << endl;
81 gLog << " --print-files Print Files taken from Sequence" << endl;
82 gLog << " --print-found Print Files found from Sequence" << endl;
83 gLog << " --use-test Apply calibration constants to same calibration" << endl;
84 gLog << " file (for testing, calibration mode only)" << 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 corresponmding 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 << " contants. 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 independantly 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 all)
122{
123 const char *prep = all ? "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(all?"all":"");
133 gLog << endl;
134 gLog.Separator(Form("%s Calibration Files", prep));
135 Next2.Print(all?"all":"");
136 gLog << endl;
137 gLog.Separator(Form("%s Data Files", prep));
138 Next3.Print(all?"all":"");
139 gLog << endl;
140}
141
142int main(int argc, char **argv)
143{
144 //
145 // Evaluate arguments
146 //
147 MArgs arg(argc, argv, kTRUE);
148 gLog.Setup(arg);
149
150 StartUpMessage();
151
152 if (arg.HasOnly("-V") || arg.HasOnly("--version"))
153 return 0;
154
155 if (arg.HasOnly("-?") || arg.HasOnly("-h") || arg.HasOnly("--help"))
156 {
157 Usage();
158 return 2;
159 }
160
161 const TString kConfig = arg.GetStringAndRemove("--config=", "callisto.rc");
162
163 const Bool_t kPrintSeq = arg.HasOnlyAndRemove("--print-seq");
164 const Bool_t kPrintFiles = arg.HasOnlyAndRemove("--print-files");
165 const Bool_t kPrintFound = arg.HasOnlyAndRemove("--print-found");
166 const Bool_t kUseTest = arg.HasOnlyAndRemove("--use-test");
167 const Bool_t kDebugMem = arg.HasOnlyAndRemove("--debug-mem");
168 Bool_t kMoon = arg.HasOnlyAndRemove("--moon");
169 Int_t kDebugEnv = arg.HasOnlyAndRemove("--debug-env") ? 1 : 0;
170 kDebugEnv = arg.GetIntAndRemove("--debug-env=", kDebugEnv);
171
172 const Bool_t kQuit = arg.HasOnlyAndRemove("-q");
173 const Bool_t kBatch = arg.HasOnlyAndRemove("-b");
174 const Bool_t kOverwrite = arg.HasOnlyAndRemove("-f");
175 //const Bool_t kForceExec = arg.HasOnlyAndRemove("-ff");
176
177 const TString kInpathD = arg.GetStringAndRemove("--ind=", "");
178 TString kInpathY = arg.GetStringAndRemove("--iny=", "");
179 TString kOutpathY = arg.GetStringAndRemove("--outy=", "");
180 TString kOutpathC = arg.GetStringAndRemove("--outc=", "");
181 const TString kOutpath = arg.GetStringAndRemove("--out=", "");
182 const TString kPath = arg.GetStringAndRemove("--path=", "");
183
184 Bool_t kModeC = arg.HasOnlyAndRemove("-c");
185 Bool_t kModeY = arg.HasOnlyAndRemove("-y");
186
187 MJCalib::DataType_t kDataType = MJCalib::kIsUseRootData; // root
188 if (arg.HasOnlyAndRemove("-raw"))
189 kDataType = MJCalib::kIsUseRawData; // raw
190 if (arg.HasOnlyAndRemove("-mc"))
191 kDataType = MJCalib::kIsUseMC; // monte carlo
192
193 if (!kInpathY.IsNull() || !kOutpathY.IsNull() || !kOutpath.IsNull() || !kPath.IsNull())
194 kModeY = kTRUE;
195 if (!kOutpathC.IsNull() || !kOutpath.IsNull() || !kPath.IsNull())
196 kModeC = kTRUE;
197
198 if (!kModeC && !kModeY /*&& !kUseTest*/)
199 {
200 gLog << err << "Neither calibration (-c) nor signal extraction (-y) or test-mode (--use-test) specified!" << endl;
201 Usage();
202 return 2;
203 }
204
205 if ((kModeC/* || kUseTest*/) && kOutpathC.IsNull())
206 kOutpathC = ".";
207 if (kModeY)
208 {
209 if (kInpathY.IsNull())
210 kInpathY = ".";
211 if (kOutpathY.IsNull())
212 kOutpathY = ".";
213 }
214 if (!kOutpath.IsNull())
215 {
216 kOutpathC = kOutpath;
217 kOutpathY = kOutpath;
218 }
219 if (!kPath.IsNull())
220 {
221 kOutpathC = kOutpath;
222 kOutpathY = kOutpath;
223 kInpathY = kOutpath;
224 }
225
226 if (kModeC && kModeY)
227 kInpathY = kOutpathC;
228
229 if (arg.GetNumOptions()>0)
230 {
231 gLog << warn << "WARNING - Unknown commandline options..." << endl;
232 arg.Print("options");
233 gLog << endl;
234 return 2;
235 }
236
237 //
238 // check for the right usage of the program
239 //
240 if (arg.GetNumArguments()!=1)
241 {
242 Usage();
243 return 2;
244 }
245
246 //
247 // Setup sequence file and check for its existance
248 //
249 const TString kSequence = arg.GetArgumentStr(0);
250
251 if (gSystem->AccessPathName(kSequence, kFileExists))
252 {
253 gLog << err << "Sorry, sequence file '" << kSequence << "' doesn't exist." << endl;
254 return 2;
255 }
256
257 if (gSystem->AccessPathName(kConfig, kFileExists))
258 {
259 gLog << err << "Sorry, config file '" << kConfig << "' doesn't exist." << endl;
260 return 2;
261 }
262
263 if (kDebugMem)
264 TObject::SetObjectStat(kTRUE);
265
266 //
267 // Setup sequence and check its validity
268 //
269 MSequence seq(kSequence);
270 if (kPrintSeq)
271 {
272 gLog << all;
273 gLog.Separator(kSequence);
274 seq.Print();
275 gLog << endl;
276 }
277 if (!seq.IsValid())
278 {
279 gLog << err << "Sequence read but not valid!" << endl << endl;
280 return 2;
281 }
282
283 //
284 // Process print options
285 //
286 if (kPrintFiles)
287 PrintFiles(seq, kInpathD, kDataType==MJCalib::kIsUseRawData, kFALSE);
288 if (kPrintFound)
289 PrintFiles(seq, kInpathD, kDataType==MJCalib::kIsUseRawData, kTRUE);
290
291 if (seq.HasMoon())
292 kMoon = kTRUE;
293
294
295 /*
296 //
297 // Check for existance of all files
298 //
299 MDirIter iter;
300 const Int_t n0 = seq.SetupAllRuns(iter, kInpathD, "[DPC]");
301 const Int_t n1 = seq.GetNumAllRuns();
302 if (n0 != n1)
303 {
304 if (kForceExec)
305 gLog << warn << "WARNING";
306 else
307 gLog << err << "ERROR";
308 gLog << " - " << n1 << " files in sequence defined, but " << n0 << " found in ";
309 gLog << (kInpathD.IsNull() ? "<defaultpath>" : kInpathD.Data()) << endl;
310 if (!kForceExec)
311 return 2;
312 }
313
314 if (kPrintOnly)
315 return 0;
316 */
317 //
318 // Initialize root
319 //
320 MArray::Class()->IgnoreTObjectStreamer();
321 MParContainer::Class()->IgnoreTObjectStreamer();
322
323 TApplication app("callisto", &argc, argv);
324 if (!gROOT->IsBatch() && !gClient || gROOT->IsBatch() && !kBatch)
325 {
326 gLog << err << "Bombing... maybe your DISPLAY variable is not set correctly!" << endl;
327 return 1;
328 }
329
330 //
331 // Update frequency by default = 1Hz
332 //
333 MStatusDisplay *d = new MStatusDisplay;
334
335 // From now on each 'Exit' means: Terminate the application
336 d->SetBit(MStatusDisplay::kExitLoopOnExit);
337 d->SetTitle(kSequence);
338
339 MEnv env(kConfig);
340 if (kModeC/* || kUseTest*/)
341 {
342 //
343 // Calculate pedestal for pedestal-calculation and calibration
344 //
345 MJPedestal job1(Form("MJPedestalC1 #%d", seq.GetSequence()));
346 job1.SetNoStorage();
347 job1.SetSequence(seq);
348 job1.SetEnv(&env);
349 job1.SetEnvDebug(kDebugEnv);
350 job1.SetDisplay(d);
351 job1.SetOverwrite(kOverwrite);
352 job1.SetPathData(kInpathD);
353 job1.SetDataType(kDataType);
354 job1.SetUseHists(kMoon);
355
356
357 job1.SetExtractionFundamental();
358 // job1.SetPathOut(kOutpathC); // not yet needed
359 // job1.SetPathIn(kInpathC); // not yet needed
360
361 if (!job1.Process())
362 {
363 gLog << err << "Calculation of pedestal failed." << endl << endl;
364 return 2;
365 }
366
367 if (!job1.GetDisplay())
368 {
369 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
370 return 1;
371 }
372
373 //
374 // Calculate pedestal and pedestal resolution
375 //
376 MJPedestal job2(Form("MJPedestalC2 #%d", seq.GetSequence()));
377 job2.SetNoStorage();
378 job2.SetSequence(seq);
379 job2.SetEnv(&env);
380 job2.SetEnvDebug(kDebugEnv);
381 job2.SetDisplay(d);;
382 job2.SetOverwrite(kOverwrite);
383 job2.SetPathData(kInpathD);
384 job2.SetDataType(kDataType);
385 job2.SetUseHists(kMoon);
386 // job1.SetPathOut(kOutpathC); // not yet needed
387 // job1.SetPathIn(kInpathC); // not yet needed
388
389 //job2.SetExtractorResolution();
390 job2.SetExtractionWithExtractorRndm();
391 job2.SetExtractor(job1.GetExtractor());
392 job2.SetPedestals(job1.GetPedestalCam());
393 job2.SetBadPixels(job1.GetBadPixels());
394
395 // Please check the Changelog of 2005/04/20 about further deatils of the next comment
396 //if (job1.GetExtractor().InheritsFrom("MExtractTimeAndCharge"))
397 if (!job2.Process())
398 {
399 gLog << err << "Calculation of pedestal resolution failed." << endl << endl;
400 return 2;
401 }
402
403 if (!job2.GetDisplay())
404 {
405 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
406 return 1;
407 }
408
409 //
410 // Do calibration
411 //
412 MJCalibration job3(Form("MJCalibration #%d", seq.GetSequence()));
413 job3.SetSequence(seq);
414 job3.SetEnv(&env);
415 job3.SetEnvDebug(kDebugEnv);
416 job3.SetDisplay(d);
417 job3.SetOverwrite(kOverwrite);
418 job3.SetPathOut(kOutpathC);
419 job3.SetPathData(kInpathD);
420 job3.SetDataType(kDataType);
421 // job2.SetPathIn(kInpathC); // not yet needed
422
423 job3.SetBadPixels(job2.GetBadPixels());
424 job3.SetExtractor(job2.GetExtractor());
425 job3.SetExtractorCam(job2.GetPedestalCam());
426
427 if (!job3.Process(job1.GetPedestalCam()))
428 {
429 gLog << err << "Calculation of calibration failed." << endl << endl;
430 return 2;
431 }
432
433 if (kDebugEnv>0)
434 env.PrintUntouched();
435
436 if (!job3.GetDisplay())
437 {
438 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
439 return 1;
440 }
441
442 if (kUseTest)
443 {
444 MJCalibTest job4(Form("MJCalibTest #%d", seq.GetSequence()));
445 job4.SetBadPixels(job2.GetBadPixels());
446 job4.SetSequence(seq);
447 job4.SetEnv(&env);
448 job4.SetEnvDebug(kDebugEnv);
449 job4.SetDisplay(d);;
450 job4.SetOverwrite(kOverwrite);
451 job4.SetPathOut(kOutpathC);
452 job4.SetPathData(kInpathD);
453 job4.SetDataType(kDataType);
454
455 if (!job4.Process(job1.GetPedestalCam()))
456 {
457 gLog << err << "Calibration of calibration failed." << endl << endl;
458 return 2;
459 }
460
461 if (kDebugEnv>0)
462 env.PrintUntouched();
463
464 if (!job4.GetDisplay())
465 {
466 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
467 return 1;
468 }
469 }
470 }
471
472 if (kModeY)
473 {
474 d->Reset();
475
476 //
477 // Calculate starting pedestal for data extraction
478 //
479 MJPedestal job1(Form("MJPedestalY1 #%d", seq.GetSequence()));
480 job1.SetNoStorage();
481 job1.SetSequence(seq);
482 job1.SetEnv(&env);
483 job1.SetEnvDebug(kDebugEnv);
484 job1.SetDisplay(d);
485 job1.SetNoDisplay();
486 job1.SetOverwrite(kOverwrite);
487 job1.SetPathData(kInpathD);
488 job1.SetPathIn(kInpathY);
489 job1.SetDataType(kDataType);
490 //job1.SetPathOut(kOutpathY); // not yet needed
491 job1.SetUseData();
492 job1.SetExtractionFundamental();
493 job1.SetUseHists(kMoon);
494
495 if (!job1.Process())
496 {
497 gLog << err << "Calculation of fundamental pedestal failed." << endl << endl;
498 return 2;
499 }
500
501 if (!job1.GetDisplay())
502 {
503 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
504 return 1;
505 }
506
507 //
508 // Calculate pedestal and pedestal resolution
509 //
510 MJPedestal job2(Form("MJPedestalY2 #%d", seq.GetSequence()));
511 job2.SetNoStorage();
512 job2.SetSequence(seq);
513 job2.SetEnv(&env);
514 job2.SetEnvDebug(kDebugEnv);
515 job2.SetDisplay(d);
516 job2.SetNoDisplay();
517 job2.SetOverwrite(kOverwrite);
518 job2.SetPathData(kInpathD);
519 job2.SetPathIn(kInpathY);
520 job2.SetDataType(kDataType);
521 job2.SetPulsePosCheck(kDataType!=MJCalib::kIsUseMC);
522 job2.SetPathOut(kOutpathY); // for updating the extractor
523
524 job2.SetUseData();
525 job2.SetExtractionWithExtractor();
526 job2.SetExtractor(job1.GetExtractor());
527 job2.SetPedestals(job1.GetPedestalCam());
528 job2.SetBadPixels(job1.GetBadPixels());
529 job2.SetUseHists(kMoon);
530
531 // Please check the Changelog of 2005/04/20 about further deatils of the next comment
532 //if (job1.GetExtractor().InheritsFrom("MExtractTimeAndCharge"))
533 if (!job2.Process())
534 {
535 gLog << err << "Calculation of pedestal from extrtactor (random) failed." << endl << endl;
536 return 2;
537 }
538
539 if (!job2.GetDisplay())
540 {
541 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
542 return 1;
543 }
544
545 //
546 // Calculate pedestal and pedestal resolution
547 //
548 MJPedestal job3(Form("MJPedestalY3 #%d", seq.GetSequence()));
549 job3.SetNoStorage();
550 job3.SetSequence(seq);
551 job3.SetEnv(&env);
552 job3.SetEnvDebug(kDebugEnv);
553 job3.SetDisplay(d);
554 job3.SetNoDisplay();
555 job3.SetOverwrite(kOverwrite);
556 job3.SetPathData(kInpathD);
557 job3.SetPathIn(kInpathY);
558 job3.SetDataType(kDataType);
559 // job1.SetPathOut(kOutpathC); // not yet needed
560 // job1.SetPathIn(kInpathC); // not yet needed
561
562 job3.SetUseData();
563 job3.SetExtractionWithExtractorRndm();
564 job3.SetExtractor(job1.GetExtractor());
565 job3.SetPedestals(job1.GetPedestalCam());
566 job3.SetBadPixels(job1.GetBadPixels());
567 job3.SetUseHists(kMoon);
568
569 if (!job3.Process())
570 {
571 gLog << err << "Calculation of pedestal from extractor failed." << endl << endl;
572 return 2;
573 }
574
575 if (!job3.GetDisplay())
576 {
577 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
578 return 1;
579 }
580
581 //
582 // Extract signal and calibrate it
583 //
584 MJCalibrateSignal job4(Form("MJCalibrateSignal #%d", seq.GetSequence()));
585 job4.SetSequence(seq);
586 job4.SetDisplay(d);;
587 job4.SetEnv(&env);
588 job4.SetEnvDebug(kDebugEnv);
589 job4.SetOverwrite(kOverwrite);
590 job4.SetPathIn(kInpathY);
591 job4.SetPathOut(kOutpathY);
592 job4.SetPathData(kInpathD);
593 job4.SetDataType(kDataType);
594 if (kDataType!=MJCalib::kIsUseMC)
595 job4.SetExtractor(job2.GetExtractor());
596
597 // Where to search for calibration files
598 if (!job4.Process(job1.GetPedestalCam(), job2.GetPedestalCam(), job3.GetPedestalCam()))
599 return 2;
600
601 if (kDebugEnv>0)
602 env.PrintUntouched();
603
604 if (!job4.GetDisplay())
605 {
606 gLog << warn << "Display closed by user... execution aborted." << endl << endl;
607 return 1;
608 }
609 }
610
611 if (kBatch || kQuit)
612 delete d;
613 else
614 {
615 // From now on each 'Close' means: Terminate the application
616 d->SetBit(MStatusDisplay::kExitLoopOnClose);
617
618 // Wait until the user decides to exit the application
619 app.Run(kFALSE);
620 }
621
622 if (TObject::GetObjectStat())
623 {
624 TObject::SetObjectStat(kFALSE);
625 gObjectTable->Print();
626 }
627
628 return 0;
629}
630
Note: See TracBrowser for help on using the repository browser.