/[PAMELA software]/DarthVader/AnticounterLevel2/src/AcCore.cpp
ViewVC logotype

Contents of /DarthVader/AnticounterLevel2/src/AcCore.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.27 - (show annotations) (download)
Mon Nov 23 09:57:22 2009 UTC (15 years ago) by mocchiut
Branch: MAIN
Changes since 1.26: +2 -2 lines
Cleanup

1 //
2 // C/C++ headers
3 //
4 #include <fstream>
5 #include <string.h>
6 //
7 // ROOT headers
8 //
9 #include <TTree.h>
10 #include <TClassEdit.h>
11 #include <TObject.h>
12 #include <TList.h>
13 #include <TArrayI.h>
14 #include <TSystem.h>
15 #include <TSystemDirectory.h>
16 #include <TString.h>
17 #include <TFile.h>
18 #include <TClass.h>
19 #include <TCanvas.h>
20 #include <TH1.h>
21 #include <TH1F.h>
22 #include <TH2D.h>
23 #include <TLatex.h>
24 #include <TPad.h>
25 #include <TSQLServer.h>
26 #include <TSQLRow.h>
27 #include <TSQLResult.h>
28 //#include <TClonesArray.h>
29 //
30 // RunInfo header
31 //
32 #include <RunInfo.h>
33 //
34 // YODA headers
35 //
36 #include <PamelaRun.h>
37 #include <physics/trigger/TriggerEvent.h>
38 #include <physics/anticounter/AnticounterEvent.h>
39 //
40 // RunInfo header
41 //
42 //#include <RunInfo.h>
43 //
44 // This program headers
45 //
46 #include <AcCore.h>
47 #include <AcLevel2.h>
48 #include <AcVerl2.h>
49 //
50 using namespace std;
51 //
52 // CORE ROUTINE
53 //
54 //
55 int AcCore(UInt_t run, TFile *file, GL_TABLES *glt, Int_t Acargc, char *Acargv[]){
56 Int_t i = 0;
57 Bool_t verbose = false;
58 Bool_t debug = false;
59 //
60 TString processFolder = Form("AcFolder_%u",run);
61 if ( Acargc > 0 ){
62 i = 0;
63 while ( i < Acargc ){
64 if ( !strcmp(Acargv[i],"-processFolder") ) {
65 if ( Acargc < i+1 ){
66 throw -3;
67 };
68 processFolder = (TString)Acargv[i+1];
69 i++;
70 };
71 if ( !strcmp(Acargv[i],"-v") || !strcmp(Acargv[i],"--verbose") ) {
72 verbose = true;
73 };
74 if ( !strcmp(Acargv[i],"-g") || !strcmp(Acargv[i],"--debug") ) {
75 verbose = true;
76 debug = true;
77 };
78 i++;
79 };
80 };
81 //
82 // Set these to true to have a very verbose output.
83 //
84 //
85 // Output directory is the working directoy.
86 //
87 const char* outdir = gSystem->DirName(gSystem->DirName(file->GetPath()));
88 //
89 // Variables for level2
90 //
91 TTree *ac = 0;
92 UInt_t nevents = 0;
93 //
94 // variables needed to reprocess data
95 //
96 TString acversion;
97 ItoRunInfo *runinfo = 0;
98 TArrayI *runlist = 0;
99 TTree *acclone = 0;
100 Bool_t reproc = false;
101 Bool_t reprocall = false;
102 UInt_t nobefrun = 0;
103 UInt_t noaftrun = 0;
104 UInt_t numbofrun = 0;
105 stringstream ftmpname;
106 TString fname;
107 UInt_t totfileentries = 0;
108 UInt_t idRun = 0;
109 //
110 // variables needed to handle error signals
111 //
112 Int_t code = 0;
113 Int_t sgnl;
114 //
115 // anticounter level2 classes
116 //
117 AcLevel2 *acl2 = new AcLevel2();
118 AcLevel2 *acl2clone = new AcLevel2();
119 // note: the string "mydect" is now "ac", "mydetector" is "anticounter" (mydectversion -> acversion, mydectclone -> acclone);
120 // the string "mydec" (without t) -> acl2 (acl2, acl2clone)
121 //
122 // define variables for opening and reading level0 file
123 //
124 TFile *l0File = 0;
125 TTree *l0tr = 0;
126 TBranch *l0head = 0;
127 TBranch *l0ac = 0;
128 pamela::EventHeader *eh = 0;
129 pamela::PscuHeader *ph = 0;
130 pamela::anticounter::AnticounterEvent *acc = 0;
131 //
132 // Define other basic variables
133 //
134 UInt_t procev = 0;
135 stringstream file2;
136 stringstream file3;
137 stringstream qy;
138 Int_t totevent = 0;
139 UInt_t atime = 0;
140 UInt_t re = 0;
141 //
142 // Working filename
143 //
144 TString outputfile;
145 stringstream name;
146 name.str("");
147 name << outdir << "/";
148 //
149 // temporary file and folder
150 //
151 TFile *tempfile = 0;
152 TTree *tempac = 0;
153 stringstream tempname;
154 stringstream acfolder;
155 Bool_t myfold = false;
156 tempname.str("");
157 tempname << outdir;
158 tempname << "/" << processFolder.Data();
159 acfolder.str("");
160 acfolder << tempname.str().c_str();
161 tempname << "/ac2tree_run";
162 tempname << run << ".root";
163 UInt_t totnorun = 0;
164 //
165 // DB classes
166 //
167 GL_ROOT *glroot = new GL_ROOT();
168 GL_TIMESYNC *dbtime = 0;
169 //
170 UShort_t CRCcheck[2]= {0,0};
171 UShort_t Status[2]= {0,0};
172 UShort_t Hitmap[2]= {0,0};
173 UShort_t Hitstatus[2]= {0,0};
174 UShort_t Trigger[2] = {0,0};
175 UShort_t Trigg_old[2] = {0,0};
176 UShort_t Counter[2][16];
177 UShort_t Counter_old[2][16];
178 UShort_t Shift[2][16];
179 Int_t vec[2][16][16];
180 Int_t tmp = 0;
181 memset(vec, 0, 2*16*16*sizeof(UShort_t));
182 memset(Shift, 0, 2*16*sizeof(UShort_t));
183 memset(Counter, 0, 2*16*sizeof(UShort_t));
184 memset(Counter_old, 0, 2*16*sizeof(UShort_t));
185 //
186 Long64_t maxsize = 10000000000LL;
187 TTree::SetMaxTreeSize(maxsize);
188 //
189 //
190 // Let's start!
191 //
192 //
193 // As a first thing we must check what we have to do: if run = 0 we must process all events in the file has been passed
194 // if run != 0 we must process only that run but first we have to check if the tree Anticounter already exist in the file
195 // if it exists we are reprocessing data and we must delete that entries, if not we must create it.
196 //
197 if ( run == 0 ) reproc = true;
198 //
199 // Output file is "outputfile"
200 //
201 outputfile = name.str().c_str();
202 if ( verbose ) printf("\n Output filename is: \n %s \n\n",outputfile.Data());
203 //
204 //
205 if ( !file->IsOpen() ){
206 if ( verbose ) printf(" ANTICOUNTER - ERROR: cannot open file for writing\n");
207 throw -701;
208 };
209 //
210 // Retrieve GL_RUN variables from the level2 file
211 //
212 acversion = AcInfo(false); // we should decide how to handle versioning system
213 //
214 // create an interface to RunInfo called "runinfo"
215 //
216 runinfo = new ItoRunInfo(file);
217 //
218 // open "Run" tree in level2 file, if not existing return an error (sngl != 0)
219 //
220 sgnl = 0;
221 sgnl = runinfo->Update(run,"AC",acversion);
222 if ( sgnl ){
223 if ( verbose ) printf(" ANTICOUNTER - ERROR: RunInfo exited with non-zero status\n");
224 code = sgnl;
225 goto closeandexit;
226 } else {
227 sgnl = 0;
228 };
229 //
230 // number of events in the file BEFORE the first event of our run
231 //
232 nobefrun = runinfo->GetFirstEntry();
233 //
234 // total number of events in the file
235 //
236 totfileentries = runinfo->GetFileEntries();
237 //
238 // first file entry AFTER the last event of our run
239 //
240 noaftrun = runinfo->GetLastEntry() + 1;
241 //
242 // number of run to be processed
243 //
244 numbofrun = runinfo->GetNoRun();
245 totnorun = runinfo->GetRunEntries();
246 //
247 // Try to access the Anticounter tree in the file, if it exists we are reprocessing data if not we are processing a new run
248 //
249 acclone = (TTree*)file->Get("Anticounter");
250 //
251 if ( !acclone ){
252 //
253 // tree does not exist, we are not reprocessing
254 //
255 reproc = false;
256 if ( run == 0 && verbose ) printf(" ANTICOUNTER - WARNING: you are reprocessing data but AC tree does not exist!\n");
257 if ( verbose && runinfo->IsReprocessing() && run != 0 ) printf(" ANTICOUNTER - WARNING: it seems you are not reprocessing data but Anticounter\n versioning information already exists in RunInfo.\n");
258
259 } else {
260 //
261 // tree exists, we are reprocessing data. Are we reprocessing a single run or all the file?
262 //
263 acclone->SetAutoSave(900000000000000LL);
264 reproc = true;
265 //
266 //
267 if ( verbose ) printf("\n Preparing the pre-processing...\n");
268 //
269 if ( run == 0 || totnorun == 1 ){
270 //
271 // we are reprocessing all the file
272 // if we are reprocessing everything we don't need to copy any old event and we can just work with the new tree and delete the old one immediately
273 //
274 reprocall = true;
275 //
276 if ( verbose ) printf("\n ANTICOUNTER - WARNING: Reprocessing all runs\n");
277 //
278 } else {
279 //
280 // we are reprocessing a single run, we must copy to the new tree the events in the file which preceed the first event of the run
281 //
282 reprocall = false;
283 //
284 if ( verbose ) printf("\n ANTICOUNTER - WARNING: Reprocessing run number %u \n",run);
285 //
286 // copying old tree to a new file
287 //
288 gSystem->MakeDirectory(acfolder.str().c_str());
289 myfold = true;
290 tempfile = new TFile(tempname.str().c_str(),"RECREATE");
291 tempac = acclone->CloneTree(-1,"fast");
292 tempac->SetName("Anticounter-old");
293 tempfile->Write();
294 tempfile->Close();
295 }
296 //
297 // Delete the old tree from old file and memory
298 //
299 acclone->Delete("all");
300 //
301 if ( verbose ) printf(" ...done!\n");
302 //
303 };
304 //
305 // create anticounter tree ac
306 //
307 file->cd();
308 ac = new TTree("Anticounter-new","PAMELA Level2 Anticounter data");
309 ac->SetAutoSave(900000000000000LL);
310 ac->Branch("AcLevel2","AcLevel2",&acl2);
311 //
312 if ( reproc && !reprocall ){
313 //
314 // open new file and retrieve alo tree informations
315 //
316 tempfile = new TFile(tempname.str().c_str(),"READ");
317 acclone = (TTree*)tempfile->Get("Anticounter-old");
318 acclone->SetAutoSave(900000000000000LL);
319 acclone->SetBranchAddress("AcLevel2",&acl2clone);
320 //
321 if ( nobefrun > 0 ){
322 if ( verbose ) {
323 printf("\n Pre-processing: copying events from the old tree before the processed run\n");
324 printf(" Copying %u events in the file which are before the beginning of the run %u \n",nobefrun,run);
325 printf(" Start copying at event number 0, end copying at event number %u \n",nobefrun);
326 };
327 for (UInt_t j = 0; j < nobefrun; j++){
328 //
329 acclone->GetEntry(j);
330 //
331 // copy acl2clone to acl2
332 //
333 acl2->Clear();
334 //
335 memcpy(&acl2,&acl2clone,sizeof(acl2clone));
336 //
337 // Fill entry in the new tree
338 //
339 ac->Fill();
340 //
341 };
342 if ( verbose ) printf(" Finished successful copying!\n");
343 };
344 };
345 //
346 // Get the list of run to be processed, if only one run has to be processed the list will contain one entry only.
347 //
348 runlist = runinfo->GetRunList();
349 //
350 // Loop over the run to be processed
351 //
352 for (UInt_t irun=0; irun < numbofrun; irun++){
353 //
354 // retrieve the first run ID to be processed using the RunInfo list
355 //
356 idRun = runlist->At(irun);
357 if ( verbose ){
358 printf("\n\n\n ####################################################################### \n");
359 printf(" PROCESSING RUN NUMBER %u \n",idRun);
360 printf(" ####################################################################### \n\n\n");
361 };
362 //
363 runinfo->ID_ROOT_L0 = 0;
364 //
365 // store in the runinfo class the GL_RUN variables for our run
366 //
367 sgnl = 0;
368 sgnl = runinfo->GetRunInfo(idRun);
369 if ( sgnl ){
370 if ( verbose ) printf(" ANTICOUNTER - ERROR: RunInfo exited with non-zero status\n");
371 code = sgnl;
372 goto closeandexit;
373 } else {
374 sgnl = 0;
375 };
376 //
377 // now you can access that variables using the RunInfo class this way runinfo->ID_ROOT_L0
378 //
379 if ( runinfo->ID_ROOT_L0 == 0 ){
380 if ( verbose ) printf("\n ANTICOUNTER - ERROR: no run with ID_RUN = %u \n\n Exiting... \n\n",idRun);
381 code = -5;
382 goto closeandexit;
383 };
384 //
385 // prepare the timesync for the db
386 //
387 TString host = glt->CGetHost();
388 TString user = glt->CGetUser();
389 TString psw = glt->CGetPsw();
390 TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
391 if ( !dbc->IsConnected() ) throw -705;
392 stringstream myquery;
393 myquery.str("");
394 myquery << "SET time_zone='+0:00'";
395 dbc->Query(myquery.str().c_str());
396
397 dbtime = new GL_TIMESYNC(runinfo->ID_ROOT_L0,"ID",dbc);
398 //
399 // Search in the DB the path and name of the LEVEL0 file to be processed.
400 //
401 // if ( !dbc->IsConnected() ) throw -705;
402 glroot->Query_GL_ROOT(runinfo->ID_ROOT_L0,dbc);
403 //
404 ftmpname.str("");
405 ftmpname << glroot->PATH.Data() << "/";
406 ftmpname << glroot->NAME.Data();
407 fname = ftmpname.str().c_str();
408 //
409 // print out informations
410 //
411 totevent = runinfo->NEVENTS;
412 if ( verbose ) {
413 printf("\n LEVEL0 data file: %s \n",fname.Data());
414 printf(" RUN HEADER absolute time is: %u \n",runinfo->RUNHEADER_TIME);
415 printf(" RUN TRAILER absolute time is: %u \n",runinfo->RUNTRAILER_TIME);
416 printf(" %i events to be processed for run %u: from %i to %i \n\n",totevent,idRun,runinfo->EV_FROM,runinfo->EV_FROM+totevent);
417 };
418 //
419 // if ( !totevent ) goto closeandexit;
420 //
421 // Open Level0 file
422 //
423 l0File = new TFile(fname.Data());
424 if ( !l0File ) {
425 if ( verbose ) printf(" ANTICOUNTER - ERROR: problems opening Level0 file\n");
426 code = -6;
427 goto closeandexit;
428 };
429 l0tr = (TTree*)l0File->Get("Physics");
430 if ( !l0tr ) {
431 if ( verbose ) printf(" ANTICOUNTER - ERROR: no Physics tree in Level0 file\n");
432 l0File->Close();
433 code = -7;
434 goto closeandexit;
435 };
436 l0head = l0tr->GetBranch("Header");
437 if ( !l0head ) {
438 if ( verbose ) printf(" ANTICOUNTER - ERROR: no Header branch in Level0 tree\n");
439 l0File->Close();
440 code = -8;
441 goto closeandexit;
442 };
443 l0ac = l0tr->GetBranch("Anticounter");
444 if ( !l0ac ) {
445 if ( verbose ) printf(" ANTICOUNTER - ERROR: no Anticounter branch in Level0 tree\n");
446 l0File->Close();
447 code = -704;
448 goto closeandexit;
449 };
450 //
451 l0tr->SetBranchAddress("Anticounter", &acc);
452 l0tr->SetBranchAddress("Header", &eh);
453 //
454 nevents = l0ac->GetEntries();
455 //
456 if ( nevents < 1 && totevent ) {
457 if ( verbose ) printf(" ANTICOUNTER - ERROR: Level0 file is empty\n\n");
458 l0File->Close();
459 code = -11;
460 goto closeandexit;
461 };
462 //
463 if ( runinfo->EV_TO > nevents-1 && totevent ) {
464 if ( verbose ) printf(" ANTICOUNTER - ERROR: too few entries in the tree\n");
465 l0File->Close();
466 code = -12;
467 goto closeandexit;
468 };
469 //
470 // run over all the events of the run
471 //
472 if ( dbc ){
473 dbc->Close();
474 delete dbc;
475 };
476 //
477 if ( verbose ) printf("\n Ready to start! \n\n Processed events: \n\n");
478 //
479 memset(Counter, 0, 2*16*sizeof(UShort_t));
480 memset(Counter_old, 0, 2*16*sizeof(UShort_t));
481 memset(Trigger, 0, 2*sizeof(UShort_t));
482 memset(Trigg_old, 0, 2*sizeof(UShort_t));
483 //
484 for ( re = runinfo->EV_FROM; re < (runinfo->EV_FROM+runinfo->NEVENTS); re++){
485 //
486 if ( procev%1000 == 0 && procev > 0 && verbose ) printf(" %iK \n",procev/1000);
487 //
488 l0head->GetEntry(re);
489 //
490 // absolute time of this event
491 //
492 ph = eh->GetPscuHeader();
493 atime = dbtime->DBabsTime(ph->GetOrbitalTime());
494 //
495 // paranoid check
496 //
497 if ( atime > (runinfo->RUNTRAILER_TIME+1) || atime < (runinfo->RUNHEADER_TIME-1) ) {
498 if ( verbose ) printf(" ANTICOUNTER - WARNING: event at time outside the run time window, skipping it atime %u TR %u HE %u \n",atime,runinfo->RUNTRAILER_TIME,runinfo->RUNHEADER_TIME);
499 if ( verbose ) printf(" %u %u %u %u \n",dbtime->GetTimesync(),dbtime->GetObt0(),dbtime->GetT0(),dbtime->GetType());
500 goto jumpev;
501 };
502 //
503 procev++;
504 //
505 // start processing
506 //
507 acl2->Clear();
508 //
509 l0ac->GetEntry(re);
510 //
511 /***********************************************/
512 // Here starts Anticounter specific code (Silvio)
513 //
514 memset(vec, 0, 2*16*16*sizeof(UShort_t));
515 memset(Shift, 0, 2*16*sizeof(UShort_t));
516 memset(CRCcheck, 0, 2*sizeof(UShort_t));
517 memset(Status, 0, 2*sizeof(UShort_t));
518 memset(Hitmap, 0, 2*sizeof(UShort_t));
519 memset(Hitstatus, 0, 2*sizeof(UShort_t));
520 tmp = 0;
521 //
522 for(Int_t gg = 0; gg < 2; gg++)
523 {
524 Hitstatus[gg] = 0;
525 }
526 //
527 //fetch data
528 //
529 for(Int_t kk = 0; kk < 2; kk++)
530 {
531 if(re>0)
532 {
533 Trigg_old[kk] = Trigger[kk];
534 for(Int_t jj = 0; jj < 16; jj++)
535 Counter_old[kk][jj] = Counter[kk][jj];
536 }
537
538 for(Int_t jj = 0; jj < 16; jj++)
539 {
540 Counter[kk][jj] = acc->counters[kk][jj];
541 Shift[kk][jj] = acc->shift[kk][jj];
542 }
543 Status[kk] = acc->status[kk];
544 Hitmap[kk] = acc->hitmap[kk];
545 Trigger[kk] = acc->trigg[kk];
546 CRCcheck[kk] = acc->CRCcheck[kk];
547 }
548
549 /***********************************************/
550 //process data
551 /***********************************************/
552 //shiftregisters
553 for(Int_t b = 0; b < 2; b++){ //card
554 for(Int_t k = 0; k < 16; k++){ //shift register
555 Int_t cnt=1;
556 for(Int_t l = 0; l < 16; l++){ //bin
557 tmp = ((Shift[b][k] & cnt) > 0 ? 1 : 0);
558 vec[b][k][l]=tmp;
559 cnt=cnt<<1;
560 }
561 //cnt=1;
562 }
563 }
564 //
565 //fill Level1 file
566 /************************************************/
567 for(Int_t s = 0; s < 2; s++) {
568 acl2->hitmap[s] = Hitmap[s];
569 acl2->trigger[s] = Trigger[s];
570 Int_t cnt=1;
571 for(Int_t k = 0; k < 16; k++) {
572 for(Int_t bin = 5; bin < 9; bin++) { //acceptance window
573 if(vec[s][bin][k]==1)
574 Hitstatus[s] = Hitstatus[s] | cnt;
575 }
576 cnt=cnt<<1;
577 }
578 acl2->hitstatus[s] = Hitstatus[s];
579 //
580 //Status
581 /****************************************/
582 if(s==0){
583 if(Trigger[0] != (Trigg_old[0]+1))
584 acl2->status[0] = acl2->status[0] | 0x1;
585 if((Status[0] & 0x001F) < 0x001F)
586 acl2->status[0] = acl2->status[0] | 0x2;
587 if(CRCcheck[0] == 0)
588 acl2->status[0] = acl2->status[0] | 0x4;
589 for(Int_t gg = 0; gg < 16; gg++){
590 if((Counter[0][gg] == Counter_old[0][gg]) && re>0 && Counter[0][gg] !=0)
591 {
592 acl2->status[0] = acl2->status[0] | 0x8;
593 }
594
595 }
596 }
597 else {
598 if(Trigger[1] != (Trigg_old[1]+2)) // this is not working (always true the if condition)
599 acl2->status[1] = acl2->status[1] | 0x1;
600 if((Status[1] & 0x001F) < 0x001F)
601 acl2->status[1] = acl2->status[1] | 0x2;
602 if(CRCcheck[1] == 0)
603 acl2->status[1] = acl2->status[1] | 0x4;
604 for(Int_t gg = 0; gg < 16; gg++){
605 if((Counter[1][gg] == Counter_old[1][gg]) && re>0 && Counter[1][gg] !=0)
606 {
607 acl2->status[1] = acl2->status[1] | 0x8 ;
608 }
609 }
610 }
611 }
612 //
613 // End Anticounter specific code
614 //
615 /************************************************/
616 acl2->unpackError = acc->unpackError;
617 //
618 // Fill the rootple
619 //
620 ac->Fill();
621 //
622 //
623 jumpev:
624 debug = false;
625 //
626 };
627 //
628 // Here you may want to clear some variables before processing another run
629 //
630 delete dbtime;
631 }; // process all the runs
632 //
633 if ( verbose ) printf("\n Finished processing data \n");
634 //
635 closeandexit:
636 //
637 // we have finished processing the run(s). If we processed a single run now we must copy all the events after our run from the old tree to the new one and delete the old tree.
638 //
639 if ( !reprocall && reproc && code >= 0 ){
640 if ( totfileentries > noaftrun ){
641 if ( verbose ){
642 printf("\n Post-processing: copying events from the old tree after the processed run\n");
643 printf(" Copying %i events in the file which are after the end of the run %i \n",(int)(totfileentries-noaftrun),(int)run);
644 printf(" Start copying at event number %i end copying at event number %i \n",(int)noaftrun,(int)totfileentries);
645 };
646 for (UInt_t j = noaftrun; j < totfileentries; j++ ){
647 //
648 // Get entry from old tree
649 //
650 acclone->GetEntry(j);
651 //
652 // copy acl2clone to acl2
653 //
654 acl2->Clear();
655 memcpy(&acl2,&acl2clone,sizeof(acl2clone));
656 //
657 // Fill entry in the new tree
658 //
659 ac->Fill();
660 };
661 if ( verbose ) printf(" Finished successful copying!\n");
662 };
663 };
664 //
665 // Close files, delete old tree(s), write and close level2 file
666 //
667 if ( l0File ) l0File->Close();
668 if ( tempfile ) tempfile->Close();
669 if ( myfold ) gSystem->Unlink(tempname.str().c_str());
670 //
671 if ( code < 0 && verbose ) printf("\n ANTICOUNTER - ERROR: an error occurred, try to save anyway...\n");
672 if ( verbose ) printf("\n Writing and closing rootple\n");
673 if ( runinfo ) runinfo->Close();
674 if ( ac ) ac->SetName("Anticounter");
675 if ( file ){
676 file->cd();
677 file->Write();
678 };
679 //
680 if ( myfold ) gSystem->Unlink(acfolder.str().c_str());
681 //
682 // the end
683 //
684 if ( verbose ) printf("\n Exiting...\n");
685 //
686 if( ac ) ac->Delete();
687 if ( acl2 ) delete acl2;
688 if ( acl2clone ) delete acl2clone;
689 if ( glroot ) delete glroot;
690 if ( runinfo ) delete runinfo;
691 //
692 if(code < 0) throw code;
693 return(code);
694 }
695
696

  ViewVC Help
Powered by ViewVC 1.1.23