/[PAMELA software]/DarthVader/CalorimeterLevel2/src/CaloCore.cpp
ViewVC logotype

Annotation of /DarthVader/CalorimeterLevel2/src/CaloCore.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.10 - (hide annotations) (download)
Thu Sep 28 13:31:50 2006 UTC (18 years, 5 months ago) by mocchiut
Branch: MAIN
CVS Tags: v2r00BETA
Changes since 1.9: +3 -0 lines
Call trk->Clear() before reading tracker data in Calo/ToF-Core.cpp

1 mocchiut 1.1 //
2     // Given a calibration and a data file this program create an ntuple with LEVEL2 calorimeter variables - Emiliano Mocchiutti
3     //
4 mocchiut 1.3 // CaloCore.cxx version 3.05 (2006-05-30)
5 mocchiut 1.1 //
6     // The only input needed is the path to the directory created by YODA for the data file you want to analyze.
7     //
8     // Changelog:
9 mocchiut 1.3 //
10 mocchiut 1.4 // 3.04 - 3.05 (2006-05-30): Qlast and nlast are now calculated using 4 (not 8) strips aournd the shower axis. Small bug fixed.
11 mocchiut 1.2 //
12     // 3.03 - 3.04 (2006-05-23): Forgot to put impx and impy in the PAMELA reference system, fixed.
13 mocchiut 1.1 //
14     // 3.02 - 3.03 (2006-05-18): updated to be called in DarthVader. Output dimension are now in cm and in the PAMELA reference system.
15     //
16     // 3.01 - 3.02 (2006-04-21): when copying entries get size of caclone and not of ca... (shouldn't matter). Fixed increasing file dimension bug when reprocessing.
17     // Added variable planemax[2], plane of maximum energy release (x and y) in final output. Use ItoRunInfo instead of RunInfo.
18     //
19     // 3.00 - 3.01 (2006-04-14): fixed small bug in tagging the track used to determine track-related variables, put in caloprocessing the opening of parameters files, fixed
20     // small bug in fortran routines
21     //
22     // 2.01 - 3.00 (2006-04-14): almost everything has changed. Now it can process one, all or some runs, introduced the final CaloLevel2 class+methods and the
23     // working class "CaloProcessing", linked to the preliminary tracker flight software v0r00, reads YODA unique output files,
24     // reduced the number of installed libraries, F77 programs splitted depending on the function contained, introduced the readout and
25     // processing of self-trigger events, if the tracker provides more than one track all calorimeter track-related variables are saved
26     // as many times as the number of tracks (via the TClonesArray object in the level2 rootple) and many other small changes.
27     //
28     // 2.00 - 2.01 (2006-01-26): bug: wrong calculation of baselines in some cases, fixed.
29     //
30     // 1.00 - 2.00 (2006-01-11): use TSQL ROOT classes instead of directly calling MySQL.
31     //
32     // 0.00 - 1.00 (2005-09-14): seems working.
33     //
34     // 0.00 (2005-09-09): clone of CaloLEVEL2.c .
35     //
36     // C/C++ headers
37     //
38     #include <fstream>
39     #include <string.h>
40     //
41     // ROOT headers
42     //
43     #include <TTree.h>
44     #include <TClassEdit.h>
45     #include <TObject.h>
46     #include <TList.h>
47 mocchiut 1.8 #include <TArrayI.h>
48 mocchiut 1.1 #include <TSystem.h>
49     #include <TSystemDirectory.h>
50     #include <TString.h>
51     #include <TFile.h>
52     #include <TClass.h>
53     #include <TCanvas.h>
54     #include <TH1.h>
55     #include <TH1F.h>
56     #include <TH2D.h>
57     #include <TLatex.h>
58     #include <TPad.h>
59     #include <TSQLServer.h>
60     #include <TSQLRow.h>
61     #include <TSQLResult.h>
62     #include <TClonesArray.h>
63     #include <TStreamerInfo.h>
64     //
65     // YODA headers
66     //
67     #include <PamelaRun.h>
68     #include <physics/trigger/TriggerEvent.h>
69     //
70     // This program headers
71     //
72     #include <RunInfo.h>
73     #include <CaloCore.h>
74     #include <CaloLevel2.h>
75     #include <CaloProcessing.h>
76     #include <CaloVerl2.h>
77     //
78     // Tracker classes headers and definitions
79     //
80     #include <TrkLevel2.h>
81     //
82     using namespace std;
83     //
84     // CORE ROUTINE
85     //
86 mocchiut 1.8 int CaloCore(UInt_t run, TFile *file, TSQLServer *dbc, Int_t calargc, char *calargv[]){
87 mocchiut 1.1 //
88     // Set these to true to have a very verbose output.
89     //
90     Bool_t verbose = false;
91     Bool_t debug = false;
92     //
93     // Output directory is the working directoy.
94     //
95     const char* outdir = gSystem->DirName(gSystem->DirName(file->GetPath()));
96     //
97     Int_t ri = 0;
98     TString processFolder = "calorimeterFolder";
99     if ( calargc > 0 ){
100     ri = 0;
101     while ( ri < calargc ){
102     if ( !strcmp(calargv[ri],"-processFolder") ) {
103     if ( calargc < ri+1 ){
104     throw -3;
105     };
106     processFolder = (TString)calargv[ri+1];
107     ri++;
108     };
109     if ( !strcmp(calargv[ri],"-v") || !strcmp(calargv[ri],"--verbose") ) {
110     verbose = true;
111     };
112     if ( !strcmp(calargv[ri],"-g") || !strcmp(calargv[ri],"--debug") ) {
113     debug = true;
114     };
115     ri++;
116     };
117     };
118     //
119     // Working filename
120     //
121     TString outputfile;
122     stringstream name;
123     name.str("");
124     name << outdir << "/";
125     //
126     // Variables.
127     //
128     // TFile *file = 0;
129     TTree *tracker = 0;
130     TTree *calo = 0;
131     TTree *caloclone = 0;
132     Bool_t reproc = false;
133     Bool_t reprocall = false;
134 mocchiut 1.8 UInt_t nevents = 0;
135 mocchiut 1.1 UInt_t nobefrun = 0;
136     UInt_t noaftrun = 0;
137     UInt_t numbofrun = 0;
138 mocchiut 1.8 UInt_t totnorun = 0;
139 mocchiut 1.1 //
140     Int_t code = 0;
141     Int_t sgnl;
142     //
143     // calorimeter level2 classes
144     //
145     CaloLevel2 *ca = new CaloLevel2();
146     CaloLevel2 *caclone = new CaloLevel2();
147     //
148     TrkLevel2 *trk = new TrkLevel2();
149 mocchiut 1.8 Int_t nevtrkl2 = 0;
150 mocchiut 1.1 //
151     UInt_t procev = 0;
152     //
153 mocchiut 1.8 // define variables where to store the absolute run header and run trailer times (unsigned long long integers, when set to a number use to store the correct number).
154 mocchiut 1.1 //
155 mocchiut 1.8 UInt_t runheadtime = 0;
156     UInt_t runtrailtime = 0;
157 mocchiut 1.1 UInt_t evfrom = 0;
158     UInt_t evto = 0;
159 mocchiut 1.8 UInt_t totfileentries = 0;
160     UInt_t idRun = 0;
161 mocchiut 1.1 Int_t id_reg_run=-1;
162     stringstream ftmpname;
163     TString fname;
164     //
165     // define variables for opening and reading level0 file
166     //
167     TFile *l0File = 0;
168     TTree *l0tr = 0;
169     TBranch *l0head = 0;
170     TBranch *l0calo = 0;
171     TBranch *l0trig = 0;
172 mocchiut 1.8 pamela::EventHeader *eh = 0;
173     pamela::PscuHeader *ph = 0;
174 mocchiut 1.1 pamela::trigger::TriggerEvent *trig = 0;
175     //
176     // Define some basic variables
177     //
178     CaloProcessing *event = new CaloProcessing(); // NOTICE: very important to call here the constructor!
179     stringstream file2;
180     stringstream file3;
181     stringstream qy;
182     // Bool_t imtrack = false;
183     Bool_t filled = false;
184     //
185 mocchiut 1.8 UInt_t caloevents = 0;
186 mocchiut 1.1 stringstream calfile;
187     stringstream aligfile;
188     //
189     Int_t i = -1;
190     Int_t itr = -1;
191     Int_t badevent = 0;
192     Int_t totevent = 0;
193     //
194 mocchiut 1.8 UInt_t atime = 0;
195 mocchiut 1.1 //
196     Int_t S3 = 0;
197     Int_t S2 = 0;
198     Int_t S12 = 0;
199     Int_t S11 = 0;
200     UInt_t re = 0;
201 mocchiut 1.9 UInt_t jumped = 0;
202 mocchiut 1.1 //
203     TString caloversion;
204     ItoRunInfo *runinfo = 0;
205 mocchiut 1.8 TArrayI *runlist = 0;
206 mocchiut 1.1 //
207     Float_t tmptrigty = -1.;
208     Int_t ntrkentry = 0;
209     GL_PARAM *q4 = new GL_PARAM();
210 mocchiut 1.8 UInt_t tttrkpar1 = 0;
211 mocchiut 1.1 Bool_t trkpar1 = true;
212     GL_ROOT *glroot = new GL_ROOT();
213 mocchiut 1.8 GL_TIMESYNC *dbtime = 0;
214 mocchiut 1.1 //
215     //
216     //
217     TFile *tempfile = 0;
218     TTree *tempcalo = 0;
219     stringstream tempname;
220     stringstream calofolder;
221     tempname.str("");
222     tempname << outdir;
223     tempname << "/" << processFolder.Data();
224     calofolder.str("");
225     calofolder << tempname.str().c_str();
226     gSystem->MakeDirectory(calofolder.str().c_str());
227     tempname << "/calotree_run";
228     tempname << run << ".root";
229     //
230     // As a first thing we must check what we have to do: if run = -1 we must process all events in the file has been passed
231     // if run != -1 we must process only that run but first we have to check if the branch calorimeter already exist in the file
232     // if it exists we are reprocessing data and we must delete that entries, if not we must create it.
233     //
234 mocchiut 1.8 if ( run == 0 ) reproc = true;
235 mocchiut 1.1 //
236     //
237     //
238     if ( !file->IsOpen() ){
239     if ( verbose ) printf(" CALORIMETER - ERROR: cannot open file for writing\n");
240     throw -101;
241     };
242     //
243     // Does it contain the Tracker tree?
244     //
245     tracker = (TTree*)file->Get("Tracker");
246     if ( !tracker ) {
247     if ( verbose ) printf(" CALORIMETER - ERROR: no tracker tree\n");
248     code = -102;
249     goto closeandexit;
250     };
251     tracker->SetBranchAddress("TrkLevel2",&trk);
252     nevtrkl2 = tracker->GetEntries();
253     //
254     // Call runinfo
255     //
256     sgnl = 0;
257     runinfo = new ItoRunInfo(file);
258     //
259     // update versioning information and retrieve informations about the run to be processed
260     //
261     caloversion = CaloInfo(false);
262     sgnl = runinfo->Update(run,"CALO",caloversion);
263     //
264     if ( sgnl ){
265     if ( verbose ) printf(" CALORIMETER - ERROR: RunInfo exited with non-zero status\n");
266     code = sgnl;
267     goto closeandexit;
268     } else {
269     sgnl = 0;
270     };
271     //
272     // number of events in the file BEFORE the first event of our run
273     //
274     nobefrun = runinfo->GetFirstEntry();
275     //
276     // total number of events in the file
277     //
278     totfileentries = runinfo->GetFileEntries();
279     //
280     // first file entry AFTER the last event of our run
281     //
282     noaftrun = runinfo->GetLastEntry() + 1;
283     //
284     // number of run to be processed
285     //
286     numbofrun = runinfo->GetNoRun();
287     //
288     // number of runs in the file
289     //
290     totnorun = runinfo->GetRunEntries();
291     //
292     // Does it contain already a Calorimeter branch? if so we are reprocessing data, if not we must create it.
293     //
294     caloclone = (TTree*)file->Get("Calorimeter");
295     //
296     if ( !caloclone ){
297     reproc = false;
298 mocchiut 1.8 if ( run == 0 && verbose ) printf(" CALORIMETER - WARNING: you are reprocessing data but calorimeter tree does not exist!\n");
299     if ( runinfo->IsReprocessing() && run != 0 && verbose ) printf(" CALORIMETER - WARNING: it seems you are not reprocessing data but calorimeter\n versioning information already exists in RunInfo.\n");
300 mocchiut 1.1 //
301     } else {
302     //
303     reproc = true;
304     //
305     if ( verbose ) printf("\n Preparing the pre-processing...\n");
306     //
307 mocchiut 1.8 if ( run == 0 ){
308 mocchiut 1.1 //
309     // if we are reprocessing everything we don't need to copy any old event and we can just create a new branch in the clone tree and jump steps 4/5/7.
310     //
311     if ( verbose ) printf("\n CALORIMETER - WARNING: Reprocessing all runs in the file\n");
312     reprocall = true;
313     //
314     } else {
315     //
316     // we are reprocessing a single run
317     //
318 mocchiut 1.8 if ( verbose ) printf("\n CALORIMETER - WARNING: Reprocessing run number %u \n",run);
319 mocchiut 1.1 reprocall = false;
320     //
321     //
322     //
323     tempfile = new TFile(tempname.str().c_str(),"RECREATE");
324     tempcalo = caloclone->CloneTree(-1,"fast");
325     tempcalo->SetName("Calorimeter-old");
326     tempfile->Write();
327     tempfile->Close();
328     };
329     //
330     // delete old tree
331     //
332     caloclone->Delete("all");
333     //
334     if ( verbose ) printf("\n ...done!\n");
335     //
336     };
337     //
338     // create calorimeter tree calo
339     //
340     file->cd();
341     calo = new TTree("Calorimeter-new","PAMELA Level2 calorimeter data");
342     calo->Branch("CaloLevel2","CaloLevel2",&ca);
343     //
344     if ( reproc && !reprocall ){
345     //
346     //
347     //
348     tempfile = new TFile(tempname.str().c_str(),"READ");
349     caloclone = (TTree*)tempfile->Get("Calorimeter-old");
350     caloclone->SetBranchAddress("CaloLevel2",&caclone);
351     //
352     if ( nobefrun > 0 ){
353     if ( verbose ) printf("\n Pre-processing: copying events from the old tree before the processed run\n");
354 mocchiut 1.8 if ( verbose ) printf(" Copying %u events in the file which are before the beginning of the run %u \n",nobefrun,run);
355 mocchiut 1.1 if ( verbose ) printf(" Start copying at event number 0, end copying at event number %u \n",nobefrun);
356     for (UInt_t j = 0; j < nobefrun; j++){
357     //
358     caloclone->GetEntry(j);
359     //
360     // copy caclone to ca
361     //
362     memcpy(&ca,&caclone,sizeof(caclone));
363     //
364     // Fill entry in the new tree
365     //
366     calo->Fill();
367     //
368 mocchiut 1.6 ca->Clear();
369     //
370 mocchiut 1.1 };
371     if ( verbose ) printf(" Finished successful copying!\n");
372     };
373     };
374     //
375     // Get the list of run to be processed
376     //
377     runlist = runinfo->GetRunList();
378     //
379     // Loop over the run to be processed
380     //
381     for (UInt_t irun=0; irun < numbofrun; irun++){
382     //
383     badevent = 0;
384     //
385     idRun = runlist->At(irun);
386     if ( verbose ) printf("\n\n\n ####################################################################### \n");
387 mocchiut 1.8 if ( verbose ) printf(" PROCESSING RUN NUMBER %u \n",idRun);
388 mocchiut 1.1 if ( verbose ) printf(" ####################################################################### \n\n\n");
389     //
390     sgnl = runinfo->GetRunInfo(idRun);
391     if ( sgnl ){
392     if ( verbose ) printf(" CALORIMETER - ERROR: RunInfo exited with non-zero status\n");
393     code = sgnl;
394     goto closeandexit;
395     } else {
396     sgnl = 0;
397     };
398 mocchiut 1.8 id_reg_run = runinfo->ID_ROOT_L0;
399 mocchiut 1.1 runheadtime = runinfo->RUNHEADER_TIME;
400     runtrailtime = runinfo->RUNTRAILER_TIME;
401 mocchiut 1.8 evfrom = runinfo->EV_FROM;
402     evto = runinfo->EV_TO;
403 mocchiut 1.1 //
404     if ( id_reg_run == -1 ){
405 mocchiut 1.8 if ( verbose ) printf("\n CALORIMETER - ERROR: no run with ID_RUN = %u \n\n Exiting... \n\n",idRun);
406 mocchiut 1.1 code = -5;
407     goto closeandexit;
408     };
409     //
410 mocchiut 1.8 // prepare the timesync for the db
411     //
412     dbtime = new GL_TIMESYNC(runinfo->ID_ROOT_L0,"ID",dbc);
413     //
414 mocchiut 1.1 // Search in the DB the path and name of the LEVEL0 file to be processed.
415     //
416 mocchiut 1.8 glroot->Query_GL_ROOT(runinfo->ID_ROOT_L0,dbc);
417 mocchiut 1.1 //
418     ftmpname.str("");
419     ftmpname << glroot->PATH.Data() << "/";
420     ftmpname << glroot->NAME.Data();
421     fname = ftmpname.str().c_str();
422     //
423     // print out informations
424     //
425 mocchiut 1.8 totevent = runinfo->NEVENTS;
426 mocchiut 1.1 if ( verbose ) printf("\n LEVEL0 data file: %s \n",fname.Data());
427 mocchiut 1.8 if ( verbose ) printf(" RUN HEADER absolute time is: %u \n",runheadtime);
428     if ( verbose ) printf(" RUN TRAILER absolute time is: %u \n",runtrailtime);
429     if ( verbose ) printf(" %i events to be processed for run %u: from %i to %i (reg entries)\n\n",totevent,idRun,evfrom,evfrom+totevent);
430 mocchiut 1.1 //
431     // Open Level0 file
432     //
433     l0File = new TFile(fname.Data());
434     if ( !l0File ) {
435     if ( verbose ) printf(" CALORIMETER - ERROR: problems opening Level0 file\n");
436     code = -6;
437     goto closeandexit;
438     };
439     l0tr = (TTree*)l0File->Get("Physics");
440     if ( !l0tr ) {
441     if ( verbose ) printf(" CALORIMETER - ERROR: no Physics tree in Level0 file\n");
442     l0File->Close();
443     code = -7;
444     goto closeandexit;
445     };
446     l0head = l0tr->GetBranch("Header");
447     if ( !l0head ) {
448     if ( verbose ) printf(" CALORIMETER - ERROR: no Header branch in Level0 tree\n");
449     l0File->Close();
450     code = -8;
451     goto closeandexit;
452     };
453     l0calo = l0tr->GetBranch("Calorimeter");
454     if ( !l0calo ) {
455     if ( verbose ) printf(" CALORIMETER - ERROR: no Calorimeter branch in Level0 tree\n");
456     l0File->Close();
457     code = -103;
458     goto closeandexit;
459     };
460     l0trig = l0tr->GetBranch("Trigger");
461     if ( !l0trig ) {
462     if ( verbose ) printf(" CALORIMETER - ERROR: no Trigger branch in Level0 tree\n");
463     l0File->Close();
464     code = -104;
465     goto closeandexit;
466     };
467     //
468     l0tr->SetBranchAddress("Trigger", &trig);
469 mocchiut 1.8 l0tr->SetBranchAddress("Header", &eh);
470 mocchiut 1.1 //
471     // Construct the event object, look for the calibration which include the first header
472     //
473     sgnl = 0;
474     if ( verbose ) printf(" Check for calorimeter calibrations and initialize event object \n");
475     event->ProcessingInit(dbc,runheadtime,sgnl,l0tr,debug,verbose);
476     if ( verbose ) printf("\n");
477     if ( sgnl == 100 ) {
478     code = sgnl;
479     if ( verbose ) printf(" CALORIMETER - WARNING: run header not included in any calibration interval\n");
480     sgnl = 0;
481     };
482     if ( sgnl ){
483     l0File->Close();
484     code = sgnl;
485     goto closeandexit;
486     };
487     //
488     qy.str("");
489     //
490 mocchiut 1.8 nevents = l0head->GetEntries();
491 mocchiut 1.1 caloevents = l0calo->GetEntries();
492     //
493     if ( nevents < 1 ) {
494     if ( verbose ) printf(" CALORIMETER - ERROR: Level0 file is empty\n\n");
495     l0File->Close();
496     code = -11;
497     goto closeandexit;
498     };
499     //
500     if ( evto > nevents-1 ) {
501     if ( verbose ) printf(" CALORIMETER - ERROR: too few entries in the registry tree\n");
502     l0File->Close();
503     code = -12;
504     goto closeandexit;
505     };
506     //
507     // Check if we have to load parameter files
508     //
509     sgnl = 0;
510     sgnl = event->ChkParam(dbc,runheadtime); // calorimeter parameter files
511     if ( sgnl < 0 ){
512     code = sgnl;
513     l0File->Close();
514     goto closeandexit;
515     };
516     //
517     if ( trkpar1 || ( tttrkpar1 != 0 && tttrkpar1 < runheadtime ) ){
518     trkpar1 = false;
519 mocchiut 1.8 Int_t glpar = q4->Query_GL_PARAM(runinfo->RUNHEADER_TIME,1,dbc);
520 mocchiut 1.4 if ( glpar < 0 ){
521     code = glpar;
522     goto closeandexit;
523     };
524 mocchiut 1.1 tttrkpar1 = q4->TO_TIME;
525     // ----------------------------
526     // Read the magnetic field
527     // ----------------------------
528     if ( verbose ) printf(" Reading magnetic field maps at %s\n",(q4->PATH+q4->NAME).Data());
529     trk->LoadField(q4->PATH+q4->NAME);
530     if ( verbose ) printf("\n");
531     };
532     //
533     // run over all the events of the run
534     //
535     if ( verbose ) printf("\n Ready to start! \n\n Processed events: \n\n");
536     //
537 mocchiut 1.8 //
538     for ( re = runinfo->EV_FROM; re < (runinfo->EV_FROM+runinfo->NEVENTS); re++){
539 mocchiut 1.1 //
540     if ( procev%1000 == 0 && procev > 0 && verbose ) printf(" %iK \n",procev/1000);
541     //
542 mocchiut 1.8 l0head->GetEntry(re);
543 mocchiut 1.1 //
544     // absolute time of this event
545     //
546 mocchiut 1.8 ph = eh->GetPscuHeader();
547     atime = dbtime->DBabsTime(ph->GetOrbitalTime());
548 mocchiut 1.1 //
549     //
550     //
551 mocchiut 1.8 if ( re > caloevents-1 ){
552 mocchiut 1.1 if ( verbose ) printf(" CALORIMETER - ERROR: no physics events with entry = %i in Level0 file\n",i);
553     l0File->Close();
554     code = -112;
555     goto closeandexit;
556     };
557     //
558     if ( atime > runtrailtime || atime < runheadtime ) {
559     if ( verbose ) printf(" CALORIMETER - WARNING: event at time outside the run time window, skipping it\n");
560 mocchiut 1.9 jumped++;
561 mocchiut 1.1 goto jumpev;
562     };
563     //
564     // retrieve tracker informations
565     //
566     if ( !reprocall ){
567 mocchiut 1.9 itr = nobefrun + (re - evfrom - jumped);
568 mocchiut 1.1 } else {
569 mocchiut 1.9 itr = runinfo->GetFirstEntry() + (re - evfrom - jumped);
570 mocchiut 1.1 };
571     if ( itr > nevtrkl2 ){
572     if ( verbose ) printf(" CALORIMETER - ERROR: no tracker events with entry = %i in Level2 file\n",itr);
573     l0File->Close();
574     code = -113;
575     goto closeandexit;
576     };
577 mocchiut 1.10 //
578     trk->Clear();
579     //
580 mocchiut 1.1 tracker->GetEntry(itr);
581     //
582     procev++;
583     //
584     // start processing
585     //
586 mocchiut 1.6 ca->Clear();
587 mocchiut 1.1 //
588     // determine who generate the trigger for this event (TOF, S4/PULSER, CALO)
589     //
590 mocchiut 1.8 l0trig->GetEntry(re);
591 mocchiut 1.1 S3 = 0;
592     S2 = 0;
593     S12 = 0;
594     S11 = 0;
595     S3 = trig->patterntrig[2];
596     S2 = trig->patterntrig[3];
597     S12 = trig->patterntrig[4];
598     S11 = trig->patterntrig[5];
599     if ( trig->patterntrig[0] ) tmptrigty = 2.;
600     if ( S3 || S2 || S12 || S11 ) tmptrigty = 0.;
601     if ( trig->patterntrig[1] & (1<<0) || (!trig->patterntrig[0] && !S3 && !S2 && !S12 && !S11) ) tmptrigty = 1.;
602     event->clevel2->trigty = tmptrigty;
603     //
604     // check if the calibration we are using is still good, if not load another calibration
605     //
606     sgnl = 0;
607     sgnl = event->ChkCalib(dbc,atime);
608     if ( sgnl < 0 ){
609     code = sgnl;
610     goto closeandexit;
611     };
612     if ( sgnl == 100 ){
613     code = sgnl;
614     if ( verbose ) printf(" CALORIMETER - WARNING: data not associated to any calibration interval\n");
615     badevent++;
616     sgnl = 0;
617     };
618     //
619     // do we have at least one track from the tracker?
620     //
621     event->clevel1->good2 = 1;
622 mocchiut 1.8 //
623 mocchiut 1.5 if ( trk->ntrk() > 0 ) event->clevel1->good2 = 1;
624 mocchiut 1.1 //
625 mocchiut 1.8 // Calibrate calorimeter event "re" and store output in the two structures that will be passed to fortran routine
626 mocchiut 1.1 //
627 mocchiut 1.8 event->Calibrate(re);
628 mocchiut 1.1 //
629     // Here we have calibrated data, ready to be passed to the FORTRAN routine which will extract topological variables.
630     //
631     //
632     // Calculate variables common to all tracks (qtot, nstrip, etc.)
633     //
634     event->GetCommonVar();
635     //
636     // Fill common variables
637     //
638     event->FillCommonVar(ca);
639     //
640     // Calculate variables related to tracks only if we have at least one track (from selftrigger and/or tracker)
641     //
642     ntrkentry = 0;
643     //
644     filled = false;
645     //
646     if ( event->clevel1->good2 == 1 || event->clevel2->trigty > 1. ){
647     //
648     if ( event->clevel1->good2 == 1 ){
649     //
650     // We have at least one track
651     //
652     //
653     // Run over tracks
654     //
655     for(Int_t nt=0; nt < trk->ntrk(); nt++){
656     //
657     event->clevel1->good2 = 1;
658     //
659     TrkTrack *ptt = trk->GetStoredTrack(nt);
660     //
661     event->clevel1->trkchi2 = 0;
662     //
663     // Copy the alpha vector in the input structure
664     //
665     for (Int_t e = 0; e < 5 ; e++){
666     event->clevel1->al_p[e][0] = ptt->al[e];
667     };
668     //
669     // Get tracker related variables for this track
670     //
671     event->GetTrkVar();
672     //
673     // Save tracker track sequence number
674     //
675    
676     event->trkseqno = nt;
677     //
678     // Copy values in the class ca from the structure clevel2
679     //
680     event->FillTrkVar(ca,ntrkentry);
681     ntrkentry++;
682     filled = true;
683     //
684     }; // loop on all the tracks
685     };
686     if ( event->clevel2->trigty >= 2. ){
687     if ( verbose ) printf(" Selftrigger event at entry %i \n",itr);
688     //
689     // Disable "track mode" in the fortran routine
690     //
691     event->clevel1->good2 = 0;
692     //
693     // We have a selftrigger event to analyze.
694     //
695     for (Int_t e = 0; e < 5 ; e++){
696     event->clevel1->al_p[e][0] = 0.;
697     event->clevel1->al_p[e][1] = 0.;
698     };
699     event->clevel1->trkchi2 = 0;
700     //
701     event->GetTrkVar();
702     //
703     // if we had no problem (clevel2->good = 0, NOTICE zero, not one in selftrigger mode!), fill and go on
704     //
705     if ( event->clevel1->good2 == 0 ) {
706     //
707     // In selftrigger mode the trkentry variable is set to -1
708     //
709     event->trkseqno = -1;
710     //
711     // Copy values in the class ca from the structure clevel2
712     //
713     event->FillTrkVar(ca,ntrkentry);
714     ntrkentry++;
715     filled = true;
716     //
717     } else {
718     if ( verbose ) printf(" Selftrigger: problems with event at entry %i \n",itr);
719     };
720     };
721     };
722     //
723     if ( !filled ) badevent++;
724     //
725     // Clear structures used to communicate with fortran
726     //
727     event->ClearStructs();
728     //
729     // Fill the rootple
730     //
731     calo->Fill();
732     //
733 mocchiut 1.6 // delete ca;
734 mocchiut 1.1 //
735     jumpev:
736     debug = false;
737     //
738     };
739     //
740     if ( verbose ) printf("\n SUMMARY:\n");
741     if ( verbose ) printf(" Total number of events: %i \n",totevent);
742     if ( verbose ) printf(" Events with at least one track: %i \n",totevent-badevent);
743     if ( verbose ) printf(" Events without tracks: %i \n",badevent);
744     //
745     if ( badevent == totevent ){
746 mocchiut 1.8 if ( verbose ) printf("\n CALORIMETER - WARNING no tracks or good events in run %u \n",idRun);
747 mocchiut 1.1 code = 101;
748     };
749     //
750 mocchiut 1.8 delete dbtime;
751 mocchiut 1.1 //
752     // Clear variables before processing another run (needed to have always the same result when reprocessing data with the same software).
753     //
754     event->RunClose();
755     if ( l0File ) l0File->Close();
756     //
757     }; // process all the runs
758     //
759     if ( verbose ) printf("\n Finished processing data \n");
760     //
761     closeandexit:
762     //
763     if ( !reprocall && reproc && code >= 0 ){
764     if ( totfileentries > noaftrun ){
765     if ( verbose ) printf("\n Post-processing: copying events from the old tree after the processed run\n");
766 mocchiut 1.8 if ( verbose ) printf(" Copying %u events in the file which are after the end of the run %u \n",(totfileentries-noaftrun),run);
767     if ( verbose ) printf(" Start copying at event number %u end copying at event number %u \n",noaftrun,totfileentries);
768 mocchiut 1.1 for (UInt_t j = noaftrun; j < totfileentries; j++ ){
769     //
770     // Get entry from old tree
771     //
772     caloclone->GetEntry(j);
773     //
774     // copy caclone to ca
775     //
776 mocchiut 1.6 ca->Clear();
777 mocchiut 1.8 //
778 mocchiut 1.1 memcpy(&ca,&caclone,sizeof(caclone));
779     //
780     // Fill entry in the new tree
781     //
782     calo->Fill();
783     //
784     };
785     if ( verbose ) printf(" Finished successful copying!\n");
786     };
787     };
788     //
789     // Case of no errors: close files, delete old tree(s), write and close level2 file
790     //
791     if ( l0File ) l0File->Close();
792     if ( tempfile ) tempfile->Close();
793     gSystem->Unlink(tempname.str().c_str());
794     if ( tracker ) tracker->Delete();
795     //
796     if ( code < 0 ) printf("\n CALORIMETER - ERROR: an error occurred, try to save anyway...\n");
797     if ( verbose ) printf("\n Writing and closing rootple\n");
798     if ( runinfo ) runinfo->Close();
799     if ( calo ) calo->SetName("Calorimeter");
800     if ( file ){
801     file->cd();
802     file->Write();
803     };
804     if ( calo ) calo->Delete();
805     //
806     gSystem->Unlink(calofolder.str().c_str());
807     //
808 mocchiut 1.7 if ( ca ) delete ca;
809     if ( caclone ) delete caclone;
810     if ( trk ) delete trk;
811     if ( q4 ) delete q4;
812     if ( glroot ) delete glroot;
813     if ( runinfo ) delete runinfo;
814     //
815 mocchiut 1.1 // the end
816     //
817     if ( verbose ) printf("\n Exiting...\n");
818     if ( code < 0 ) throw code;
819     return(code);
820     }
821    
822    
823    

  ViewVC Help
Powered by ViewVC 1.1.23