/[PAMELA software]/PamelaLevel2/src/PamLevel2.cpp
ViewVC logotype

Contents of /PamelaLevel2/src/PamLevel2.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.24 - (show annotations) (download)
Thu Mar 15 12:18:51 2007 UTC (17 years, 11 months ago) by pam-fi
Branch: MAIN
Changes since 1.23: +55 -19 lines
workaround to handle level0 reprocessing in case of spurious nested physics packets

1 #include <PamLevel2.h>
2 //--------------------------------------
3 //
4 //
5 //--------------------------------------
6 /**
7 * Default constructor
8 */
9 PamTrack::PamTrack(){
10 trk_track = 0;
11 calo_track = 0;
12 tof_track = 0;
13 candeleteobj = 0;
14 };
15 //--------------------------------------
16 //
17 //
18 //--------------------------------------
19 /**
20 * Constructor
21 */
22 PamTrack::PamTrack(TrkTrack* t, CaloTrkVar* c, ToFTrkVar* o){
23
24 trk_track = 0;
25 calo_track = 0;
26 tof_track = 0;
27 // if(t)trk_track = new TrkTrack(*t);
28 // if(c)calo_track = new CaloTrkVar(*c);
29 // if(o)tof_track = new ToFTrkVar(*o);
30 if(t)trk_track = t;
31 if(c)calo_track = c;
32 if(o)tof_track = o;
33 candeleteobj = 0;
34
35 };
36 PamTrack::PamTrack(const PamTrack& track){
37
38 TrkTrack *t = track.trk_track;
39 CaloTrkVar *c = track.calo_track;
40 ToFTrkVar *o = track.tof_track;
41
42 trk_track = 0;
43 calo_track = 0;
44 tof_track = 0;
45 if(t)trk_track = new TrkTrack(*t);
46 if(c)calo_track = new CaloTrkVar(*c);
47 if(o)tof_track = new ToFTrkVar(*o);
48 candeleteobj = 1;
49
50 }
51 void PamTrack::Clear(){
52
53 // cout << "PamTrack::Clear() "<<candeleteobj<<endl;
54 if(candeleteobj){
55 if(trk_track) trk_track->TrkTrack::Clear();
56 if(calo_track) calo_track->CaloTrkVar::Clear();//???
57 if(tof_track) tof_track->ToFTrkVar::Clear();//???
58 }else{
59 trk_track = 0;
60 calo_track = 0;
61 tof_track = 0;
62 }
63 }
64 void PamTrack::Delete(){
65 // cout << "PamTrack::Delete() "<<candeleteobj<<endl;
66 if(candeleteobj){
67 if(trk_track) {
68 trk_track->TrkTrack::Clear();
69 delete trk_track;
70 }
71 if(calo_track){
72 calo_track->CaloTrkVar::Clear();//???
73 delete calo_track;
74 }
75 if(tof_track){
76 tof_track->ToFTrkVar::Clear();//???
77 delete tof_track;
78 }
79 }else{
80 Clear();
81 }
82 }
83 //--------------------------------------
84 //
85 //
86 //--------------------------------------
87 /**
88 * Constructor
89 */
90 PamLevel2::PamLevel2(){
91
92 // trk2_obj = TrkLevel2::GetTrkLevel2();
93 // trk1_obj = TrkLevel1::GetTrkLevel1();
94 // trkh_obj = TrkHough::GetTrkHough();
95 // calo1_obj = CaloLevel1::GetCaloLevel1();
96 // calo2_obj = CaloLevel2::GetCaloLevel2();
97 // tof_obj = ToFLevel2::GetToFLevel2();
98 // trig_obj = TrigLevel2::GetTrigLevel2();
99 // s4_obj = S4Level2::GetS4Level2();
100 // nd_obj = NDLevel2::GetNDLevel2();
101 // ac_obj = AcLevel2::GetAcLevel2();
102 // orb_obj = OrbitalInfo::GetOrbitalInfo();
103
104 h0_obj = 0;
105 trk0_obj = 0;
106
107 trk2_obj = 0;
108 trk1_obj = 0;
109 trkh_obj = 0;
110 calo1_obj = 0;
111 calo2_obj = 0;
112 tof_obj = 0;
113 trig_obj = 0;
114 s4_obj = 0;
115 nd_obj = 0;
116 ac_obj = 0;
117 orb_obj = 0;
118
119 run_obj = 0;//new GL_RUN();
120 soft_obj = 0;// Emiliano
121 irun = -1;
122 runfirstentry = 0ULL;
123 runlastentry = 0ULL;
124
125 l0_file = NULL;
126 l0_tree = NULL;
127 iroot = -1;
128 dbc = 0;
129
130 irun = -1;
131 run_tree = NULL;
132 run_tree_clone = NULL;
133 sel_tree = NULL;
134 sel_tree_clone = NULL;
135
136 irunentry = -1;
137 pam_tree = NULL;
138 for(Int_t i=0; i<NCLONES; i++ )pam_tree_clone[i]=NULL;
139
140 host = "mysql://localhost/pamelaprod";
141 user = "anonymous";
142 psw = "";
143 const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");
144 const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");
145 const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");
146 if ( !pamdbhost ) pamdbhost = "";
147 if ( !pamdbuser ) pamdbuser = "";
148 if ( !pamdbpsw ) pamdbpsw = "";
149 if ( strcmp(pamdbhost,"") ) host = pamdbhost;
150 if ( strcmp(pamdbuser,"") ) user = pamdbuser;
151 if ( strcmp(pamdbpsw,"") ) psw = pamdbpsw;
152
153
154
155 // sorted_tracks = 0;//new TRefArray();
156
157 CAL0 = false;
158 CAL1 = true;
159 CAL2 = true;
160 TRK2 = true;
161 TRK1 = false;
162 TRKh = false;
163 TRKh = false;
164 TRG = true;
165 TOF = true;
166 TOF0 = false;
167 S4 = true;
168 ND = true;
169 AC = true;
170 ORB = true;
171
172 RUN = true;
173
174 SELLI = -1;
175
176 tsorted=0;
177 timage=0;
178
179 };
180 /**
181 * Delete the event (act as Dtor)
182 */
183 void PamLevel2::Delete(){
184
185 if(run_obj)delete run_obj;
186 if(soft_obj)delete soft_obj; //Emiliano
187
188 // cout << "void PamLevel2::Clear()"<<endl;
189 if(h0_obj) delete h0_obj;
190 if(trk0_obj) delete trk0_obj;
191 if(trk1_obj) delete trk1_obj;
192 if(trk2_obj) delete trk2_obj;
193 if(trkh_obj) delete trkh_obj;
194 if(calo1_obj)delete calo1_obj;
195 if(calo2_obj)delete calo2_obj;
196 if(tof_obj) delete tof_obj;
197 if(trig_obj) delete trig_obj;
198 if(s4_obj) delete s4_obj;
199 if(nd_obj) delete nd_obj;
200 if(ac_obj) delete ac_obj;
201 if(orb_obj) delete orb_obj;
202
203 if(tsorted){
204 tsorted->Delete();
205 delete tsorted;
206 }
207 if(timage){
208 timage->Delete();
209 delete timage;
210 }
211
212 if(dbc){
213 dbc->Close();
214 delete dbc;
215 }
216
217 if(l0_file)l0_file->Close();
218 if(pam_tree)pam_tree->Delete();;
219 if(run_tree)run_tree->Delete();;
220 if(sel_tree)sel_tree->Delete();;
221 for(Int_t i=0; i<NCLONES; i++ )if(pam_tree_clone[i])pam_tree_clone[i]->Delete();;
222 if(run_tree_clone)run_tree_clone->Delete();;
223 if(sel_tree_clone)sel_tree_clone->Delete();;
224
225
226 };
227
228 /**
229 * Clear the event (NB! does not deallocate objects)
230 */
231 void PamLevel2::Clear(){
232
233 // cout << "void PamLevel2::Clear()"<<endl;
234
235 //
236 // This method is called once for every entry but RunInfo and SoftInfo do not change until the next run so we cannot clear them here unless we don't
237 // want to load them for each event even if they are the same...
238 //
239 // if(run_obj)delete run_obj;
240 // if(run_obj) run_obj->Clear(); // Emiliano: Do not deallocate run_obj here, it will give segmentation fault! call clear instead
241 // if(soft_obj) soft_obj->Clear();
242
243 if(h0_obj) h0_obj->Clear();
244 if(trk0_obj) trk0_obj->Clear();
245 if(trk1_obj) trk1_obj->Clear();
246 if(trk2_obj) trk2_obj->Clear();
247 if(trkh_obj) trkh_obj->Clear();
248 if(calo1_obj)calo1_obj->Clear();
249 if(calo2_obj)calo2_obj->Clear();
250 if(tof_obj) tof_obj->Clear();
251 if(trig_obj) trig_obj->Clear();
252 if(s4_obj) s4_obj->Clear();
253 if(nd_obj) nd_obj->Clear();
254 if(ac_obj) ac_obj->Clear();
255 if(orb_obj) orb_obj->Clear();
256
257 // if(sorted_tracks)sorted_tracks->Clear();
258 // sorted_tracks.Clear();
259
260 if(tsorted){
261 tsorted->Delete();
262 }
263 if(timage){
264 timage->Delete();
265 }
266
267 };
268
269
270 //--------------------------------------
271 //
272 //
273 //--------------------------------------
274 void *PamLevel2::GetPointerTo(const char* c ){
275
276 TString objname = c;
277
278 if(!objname.CompareTo("TrkLevel1")) {
279 if(!trk1_obj){
280 trk1_obj = new TrkLevel1();
281 trk1_obj->Set();
282 }
283 return &trk1_obj;
284 };
285 if(!objname.CompareTo("TrkLevel2")) {
286 if(!trk2_obj){
287 trk2_obj = new TrkLevel2();
288 trk2_obj->Set();
289 }
290 return &trk2_obj;
291 };
292 if(!objname.CompareTo("TrkHough")) {
293 if(!trkh_obj) trkh_obj = new TrkHough();
294 return &trkh_obj;
295 };
296 if(!objname.CompareTo("CaloLevel1")) {
297 if(!calo1_obj) calo1_obj = new CaloLevel1();
298 return &calo1_obj;
299 };
300 if(!objname.CompareTo("CaloLevel2")) {
301 if(!calo2_obj){
302 calo2_obj = new CaloLevel2();
303 calo2_obj->Set();
304 };
305 return &calo2_obj;
306 };
307 if(!objname.CompareTo("ToFLevel2")) {
308 if(!tof_obj){
309 tof_obj = new ToFLevel2();
310 tof_obj->Set();
311 }
312 return &tof_obj;
313 };
314 if(!objname.CompareTo("TrigLevel2")) {
315 if(!trig_obj) trig_obj = new TrigLevel2();
316 return &trig_obj;
317 };
318 if(!objname.CompareTo("S4Level2")) {
319 if(!s4_obj) s4_obj = new S4Level2();
320 return &s4_obj;
321 };
322 if(!objname.CompareTo("NDLevel2")) {
323 if(!nd_obj) nd_obj = new NDLevel2();
324 return &nd_obj;
325 };
326 if(!objname.CompareTo("AcLevel2")) {
327 if(!ac_obj) ac_obj = new AcLevel2();
328 return &ac_obj;
329 };
330 if(!objname.CompareTo("OrbitalInfo")){
331 if(!orb_obj) orb_obj = new OrbitalInfo();
332 return &orb_obj;
333 };
334
335 if(!objname.CompareTo("RunInfo"))return &run_obj;
336
337 if(!objname.CompareTo("SoftInfo"))return &soft_obj; // Emiliano
338
339 return NULL;
340 };
341 //--------------------------------------
342 //
343 //
344 //--------------------------------------
345 /**
346 * Retrieves the calorimeter track matching the seqno-th tracker stored track.
347 * (If seqno = -1 retrieves the self-trigger calorimeter track)
348 */
349 CaloTrkVar *PamLevel2::GetCaloStoredTrack(int seqno){
350
351 if( !calo2_obj )return 0;
352
353 if( calo2_obj->CaloLevel2::ntrk()==0 ){
354 cout << "PamLevel2::GetCaloStoredTrack(int) : requested tracker SeqNo "<< seqno <<" but no Calorimeter tracks are stored"<<endl;
355 return NULL;
356 };
357
358 CaloTrkVar *c = 0;
359 Int_t it_calo=0;
360
361 do{
362 c = calo2_obj->CaloLevel2::GetCaloTrkVar(it_calo);
363 it_calo++;
364 } while( c && seqno != c->trkseqno && it_calo < calo2_obj->CaloLevel2::ntrk());
365
366 if(!c || seqno != c->trkseqno){
367 c = 0;
368 if(seqno!=-1)cout << "PamLevel2::GetCaloStoredTrack(int) : requested tracker SeqNo "<< seqno <<" does not match Calorimeter stored tracks"<<endl;
369 };
370 return c;
371
372 };
373 //--------------------------------------
374 //
375 //
376 //--------------------------------------
377 /**
378 * Retrieves the ToF track matching the seqno-th tracker stored track.
379 * (If seqno = -1 retrieves the tracker-independent tof track)
380 */
381 ToFTrkVar *PamLevel2::GetToFStoredTrack(int seqno){
382
383 if( !tof_obj )return 0;
384
385 if( tof_obj->ToFLevel2::ntrk()==0 ){
386 cout << "PamLevel2::GetToFStoredTrack(int) : requested tracker SeqNo "<< seqno <<" but no ToF tracks are stored"<<endl;
387 return NULL;
388 };
389
390 ToFTrkVar *c = 0;
391 Int_t it_tof=0;
392
393 do{
394 c = tof_obj->ToFLevel2::GetToFTrkVar(it_tof);
395 it_tof++;
396 } while( c && seqno != c->trkseqno && it_tof < tof_obj->ToFLevel2::ntrk());
397
398 if(!c || seqno != c->trkseqno){
399 c = 0;
400 if(seqno!=-1)cout << "PamLevel2::GetToFStoredTrack(int) : requested tracker SeqNo "<< seqno <<" does not match ToF stored tracks"<<endl;
401 };
402 return c;
403
404 };
405
406 //--------------------------------------
407 //
408 //
409 //--------------------------------------
410 /**
411 * Give the pamela track associated to a tracker track, retrieving related calorimeter and tof track information.
412 */
413 PamTrack* PamLevel2::GetPamTrackAlong(TrkTrack* t){
414
415 cout <<"PamLevel2::GetPamTrackAlong(TrkTrack* t) **obsolete** "<<endl;
416 cout <<"(if you use it, remember to delete the PamTrack object)"<<endl;
417
418 CaloTrkVar *c = 0;
419 ToFTrkVar *o = 0;
420
421 if(CAL2) c = GetCaloStoredTrack(t->GetSeqNo());
422 if(TOF) o = GetToFStoredTrack(t->GetSeqNo());
423
424 // if(t && c && o)track = new PamTrack(t,c,o);
425 PamTrack *track = new PamTrack(t,c,o);
426
427 return track;
428
429 };
430 //--------------------------------------
431 //
432 //
433 //--------------------------------------
434 /**
435 * Retrieves the it-th stored track.
436 * It override TrkLevel2::GetTrack(int it).
437 * @param itrk Track number, ranging from 0 to GetNTracks().
438 */
439
440 PamTrack* PamLevel2::GetStoredTrack(Int_t itrk){
441
442 cout <<"PamLevel2::GetStoredTrack(Int_t itrk) **to-be-updated** "<<endl;
443 cout <<"for the moment, better use separately the methods: TrkLevel2::GetStoredTrack(seqno) CaloLevel2::GetCaloTrkVar(Int_t notrack) ToFLevel2::GetToFTrkVar(Int_t notrack)"<<endl;
444 cout <<"(if you use it, remember to delete the PamTrack object)"<<endl;
445 PamTrack *track = 0;
446
447 if( itrk >=0 && itrk < trk2_obj->TrkLevel2::ntrk() ){
448
449 TrkTrack *t = trk2_obj->TrkLevel2::GetStoredTrack(itrk);
450 track = GetPamTrackAlong(t);
451
452
453
454 }else{
455 cout << "PamLevel2::GetStoredTrack(int) : tracker track SeqNo "<< itrk <<" does not exist (GetNTracks() = "<<trk2_obj->TrkLevel2::GetNTracks()<<")"<<endl;
456 };
457
458 return track;
459
460 }
461 //--------------------------------------
462 //
463 //
464 //--------------------------------------
465 /**
466 * Sort physical (tracker) tracks and stores them in the TRefArray (of TrkTrack objects) which pointer is PamLevel2::sorted_tracks.
467 * @param how String to set the sorting cryterium (es: "CAL" or "TRK+CAL+TOF" ecc...).
468 * Sorting cryteria:
469 * TRK: lower chi**2
470 * CAL: lower Y spatial residual on the first calorimeter plane
471 * TOF: bigger numebr of hit PMTs along the track, on S12 S21 S32 (where paddles are along the Y axis).
472 * The default sorting cryterium is "TOF+CAL".
473 *
474 * The total number of physical tracks is always given by GetNTracks() and the it-th physical track can be retrieved by means of the methods GetTrack(int it) and GetTrack(int it, TString how).
475 */
476 void PamLevel2::SortTracks(TString how){
477
478 // cout <<" PamLevel2::SortTracks(TString how) "<<endl;
479 if( !trk2_obj ){
480 cout << "void PamLevel2::SortTracks(TString how): TrkLevel2 not loaded !!!";
481 return;
482 };
483 // cout << "call SortTracs() "<<endl;
484 //Save current Object count
485 Int_t ObjectNumber = TProcessID::GetObjectCount();
486
487 // cout << "ObjectNumber "<<ObjectNumber <<endl;
488
489 // if(!sorted_tracks)sorted_tracks = new TRefArray();
490 // sorted_tracks->Clear();
491 // sorted_tracks.Clear();
492
493 if(!tsorted)tsorted = new TClonesArray("PamTrack",trk2_obj->GetNTracks());
494 tsorted->Delete();
495 TClonesArray &ttsorted = *tsorted;
496 if(!timage)timage = new TClonesArray("PamTrack",trk2_obj->GetNTracks());
497 timage->Delete();
498 TClonesArray &ttimage = *timage;
499
500
501 // loop over the tracks sorted by the tracker
502 Bool_t use_TRK = how.Contains("TRK", TString::kIgnoreCase);
503 Bool_t use_CAL = how.Contains("CAL", TString::kIgnoreCase);
504 Bool_t use_TOF = how.Contains("TOF", TString::kIgnoreCase);
505
506 if( !CAL2 && use_CAL) use_CAL = false;
507 if( !TOF && use_TOF) use_TOF = false;
508
509 if( !TRK2 ){
510 // cout << "SortTracks() : without tracker does not work!!! (not yet)" << endl;
511 return;
512 };
513
514 // cout << "use_CAL "<<use_CAL<<" use_TOF "<<use_TOF<<" use_TRK "<<use_TRK <<endl;
515
516 for(Int_t i=0; i < trk2_obj->TrkLevel2::GetNTracks(); i++){
517
518 TrkTrack *ts = 0;
519 CaloTrkVar *cs = 0;
520 ToFTrkVar *os = 0;
521
522 // get tracker tracks
523 TrkTrack *tp = trk2_obj->TrkLevel2::GetTrack(i); //tracker
524 CaloTrkVar *cp = GetCaloStoredTrack(tp->GetSeqNo());
525 ToFTrkVar *op = GetToFStoredTrack(tp->GetSeqNo());
526
527 TrkTrack *ti = 0; //tracker (image)
528 CaloTrkVar *ci = 0;
529 ToFTrkVar *oi = 0;
530 // cout << "trk track n. "<<i << " "<<hex<< tp <<dec<< endl;
531 // if track has an image, check image selection
532 if(tp->HasImage()){
533
534 ti = trk2_obj->TrkLevel2::GetTrackImage(i); //tracker (image)
535 ci = GetCaloStoredTrack(ti->GetSeqNo());
536 oi = GetToFStoredTrack(ti->GetSeqNo());
537
538 // cout << "its image "<<i << " "<<hex<< ti <<dec<< endl;
539
540 //assign starting scores
541 Int_t tp_score = 0; //main track sorted by the tracker
542 Int_t ti_score = 0; //image track
543
544 // ------------------------
545 // calorimeter check
546 // ------------------------
547 // check the Y spatial residual on the first calorimeter plane
548 // (cut on calorimeter variables from Emiliano)
549 if( use_CAL && !calo2_obj ){
550 cout << "void PamLevel2::SortTracks(TString how): how= "<<how<<" but CaloLevel2 not loaded !!!";
551 return;
552 };
553 if(
554 use_CAL &&
555 calo2_obj->npcfit[1] > 15 && //no. of fit planes on Y view
556 calo2_obj->varcfit[1] < 1000. && //fit variance on Y view
557 true){
558
559
560 Float_t resy_p = cp->tbar[0][1] - calo2_obj->cbar[0][1]; if(resy_p < 0)resy_p= - resy_p;
561 Float_t resy_i = ci->tbar[0][1] - calo2_obj->cbar[0][1]; if(resy_i < 0)resy_i= - resy_i;
562
563 if(resy_p <= resy_i) tp_score++;
564 else ti_score++;
565
566 // cout << "CALO "<<tp_score<<ti_score<<endl;
567
568 };
569 // ------------------------
570 // TOF check
571 // ------------------------
572 // check the number of hit pmts along the track
573 // on S12 S21 and S32, where paddles are parallel to Y axis
574 if( use_TOF && !tof_obj ){
575 cout << "void PamLevel2::SortTracks(TString how): how= "<<how<<" but ToFLevel2 not loaded !!!";
576 return;
577 };
578 if( use_TOF ){
579
580 Int_t nphit_p =0;
581 Int_t nphit_i =0;
582
583
584 /* cout << "track: npmtadc "<< op->npmtadc << endl;
585 cout << "track: npmttdc "<< op->npmttdc << endl;
586 cout << "image: npmtadc "<< oi->npmtadc << endl;
587 cout << "image: npmttdc "<< oi->npmttdc << endl;*/
588
589 for (Int_t ih=0; ih < op->npmtadc; ih++){
590 Int_t pl = tof_obj->GetPlaneIndex( (op->pmtadc).At(ih) );
591 if(pl == 1 || pl == 2 || pl == 5)nphit_p++;
592 };
593
594 for (Int_t ih=0; ih < oi->npmtadc; ih++){
595 Int_t pl = tof_obj->GetPlaneIndex( (oi->pmtadc).At(ih) );
596 if(pl == 1 || pl == 2 || pl == 5)nphit_i++;
597 };
598
599 if(
600 use_TOF &&
601 (nphit_p+nphit_i) !=0 &&
602 true){
603
604 if( nphit_p >= nphit_i) tp_score++;
605 else ti_score++;
606 };
607 // cout << "TOF "<<tp_score<<ti_score<<endl;
608 };
609 if(tp_score == ti_score) use_TRK = true;
610 // ------------------------
611 // tracker check
612 // ------------------------
613 // chi**2 difference is not always large enough to distinguish among
614 // the real track and its image.
615 // Tracker check will be applied always when calorimeter and tof information is ambiguous.
616 if(use_TRK){
617 if( tp->chi2 > 0 && tp->chi2 < ti->chi2 ) tp_score++ ;
618 else if( ti->chi2 > 0 && ti->chi2 < tp->chi2 ) ti_score++ ;
619 // cout << "TRK "<<tp_score<<ti_score<<endl;
620 };
621
622 // ------------------------
623 // the winner is....
624 // ------------------------
625 if (tp_score > ti_score) {
626 // ts = tp;//the track sorted by the tracker!!
627 // cs = cp;
628 // os = op;
629 }else if (tp_score < ti_score) {
630 ts = ti;//its image!!
631 cs = ci;
632 os = oi;
633
634 ti = tp;//its image!!
635 ci = cp;
636 oi = op;
637
638 tp = ts;//its image!!
639 cp = cs;
640 op = os;
641
642
643 }else {
644 // ts = tp;
645 // cs = cp;
646 // os = op;
647 // cout << "Warning - track image ambiguity not solved" << endl;
648 // cout << ts->GetNtot() << " "<< ts->chi2 << " " << npcfit[1] << " "<< nphit_p << endl;
649 };
650
651 }else{
652 // ts = tp;
653 // cs = cp;
654 // os = op;
655 };
656
657 // cout <<" SortTracks() "<<i<<" -- "<<ts<<endl;
658 // sorted_tracks->Add(ts);//save the track in the sorted array
659 // sorted_tracks.Add(ts);//save the track in the sorted array
660 // sorted_tracks.Add(tp);//save the track in the sorted array
661 // cout << "SortTracks:: sorted_tracks->Add(it) "<<i<<" "<<ts<<endl;
662 // cout<<"o "<<tp<<endl;
663 // cout<<"o "<<cp<<endl;
664 // cout<<"o "<<op<<endl;
665 new(ttsorted[i]) PamTrack(tp,cp,op);
666 new(ttimage[i]) PamTrack(ti,ci,oi);
667 };
668
669 if( tsorted->GetEntries() != trk2_obj->GetNTracks() ){
670 cout << "void PamLevel2::SortTracks(TString how): tsorted->GetEntries() "<<tsorted->GetEntries()<<" != trk2_obj->GetNTracks() = "<<trk2_obj->GetNTracks() <<endl;
671 tsorted->Delete(); tsorted=0;
672 timage->Delete(); timage=0;
673 }
674
675 //Restore Object count
676 //To save space in the table keeping track of all referenced objects
677 //We reset the object count to what it was at the beginning of the event.
678 TProcessID::SetObjectCount(ObjectNumber);
679
680 };
681 //--------------------------------------
682 //
683 //
684 //--------------------------------------
685 /**
686 * This method overrides TrkLevel2::GetTracks(), where sorting is done by decreasing number of fit points and increasing chi^2.
687 * PamLevel2::GetTracks() keeps the same track order given by TrkLevel2::GetTracks(), but checks image selection by using calorimeter and ToF tracking information.
688 */
689 // TRefArray *PamLevel2::GetTracks(){
690
691 // // *-*-*-*-*-*-*-*-*-*-*-*-*
692 // SortTracks("+CAL+TOF");
693 // // *-*-*-*-*-*-*-*-*-*-*-*-*
694
695 // // return sorted_tracks;
696 // return &sorted_tracks;
697
698 // };
699 TClonesArray *PamLevel2::GetTracks(){
700
701 // *-*-*-*-*-*-*-*-*-*-*-*-*
702 SortTracks("+CAL+TOF");
703 // *-*-*-*-*-*-*-*-*-*-*-*-*
704
705 return tsorted;
706
707 };
708 //--------------------------------------
709 //
710 //
711 //--------------------------------------
712 /**
713 * Retrieves the it-th Pamela "physical" track.
714 * It override TrkLevel2::GetTrack(int it).
715 * @param it Track number, ranging from 0 to GetNTracks().
716 */
717 PamTrack *PamLevel2::GetTrack(int it){
718
719 // if(!trk2_obj) return 0;
720
721 // // *-*-*-*-*-*-*-*-*-*-*-*-*
722 // SortTracks("+CAL+TOF");
723 // // *-*-*-*-*-*-*-*-*-*-*-*-*
724 // // if(!sorted_tracks)return 0;
725 // if(sorted_tracks.IsEmpty())return 0;
726
727 // PamTrack *track = 0;
728
729 // if( it >=0 && it < trk2_obj->TrkLevel2::GetNTracks() && it<sorted_tracks.GetEntriesFast() ){
730 // TrkTrack *t = (TrkTrack*)sorted_tracks.At(it);
731 // track = GetPamTrackAlong(t);
732 // }else{
733 // cout << "PamLevel2::GetTrack(int) : tracker track SeqNo "<< it <<" does not exist (GetNTracks() = "<<trk2_obj->TrkLevel2::GetNTracks()<<")"<<endl;
734 // };
735
736 // return track;
737
738 // cout << "PamLevel2::GetTrack(int it) "<<endl;
739 // *-*-*-*-*-*-*-*-*-*-*-*-*
740 SortTracks("+CAL+TOF");
741 // *-*-*-*-*-*-*-*-*-*-*-*-*
742 if(!tsorted)return 0;
743 if(!tsorted->GetEntries())return 0;
744
745 PamTrack *track = 0;
746
747 if( it >=0 && it < trk2_obj->TrkLevel2::GetNTracks()){
748 // TrkTrack *t = (TrkTrack*)sorted_tracks.At(it);
749 // track = GetPamTrackAlong(t);
750 TClonesArray &t = *(tsorted);
751 track = (PamTrack*)t[it];
752
753 }else{
754 cout << "PamLevel2::GetTrack(int) : tracker track SeqNo "<< it <<" does not exist (GetNTracks() = "<<trk2_obj->TrkLevel2::GetNTracks()<<")"<<endl;
755 };
756
757 return track;
758
759 };
760
761 //--------------------------------------
762 //
763 //
764 //--------------------------------------
765 /**
766 * Retrieves (if present) the image of the it-th Pamela "physical" track, sorted by the method PamLevel2::SortTracks().
767 * @param it Track number, ranging from 0 to GetNTracks().
768 */
769 PamTrack *PamLevel2::GetTrackImage(int it){
770
771 // if(!trk2_obj) return 0;
772
773 // // *-*-*-*-*-*-*-*-*-*-*-*-*
774 // SortTracks("+CAL+TOF");
775 // // *-*-*-*-*-*-*-*-*-*-*-*-*
776 // // if(!sorted_tracks)return 0;
777 // if(sorted_tracks.IsEmpty())return 0;
778
779 // PamTrack *image = 0;
780
781 // if( it >=0 && it < trk2_obj->TrkLevel2::GetNTracks() ){
782 // TrkTrack *temp = (TrkTrack*)sorted_tracks.At(it);
783 // if( temp->HasImage() ){
784 // TrkTrack *t = trk2_obj->TrkLevel2::GetStoredTrack(temp->GetImageSeqNo());
785 // image = GetPamTrackAlong(t);
786 // }else{
787 // cout <<"PamLevel2::GetTrackImage(int) : Track SeqNo "<<it<<" does not have image"<<endl;
788 // };
789 // }else{
790 // cout << "PamLevel2::GetTrackImage(int) : Tracker track SeqNo "<< it <<" does not exist (GetNTracks() = "<<trk2_obj->TrkLevel2::GetNTracks()<<")"<<endl;
791 // };
792
793 // return image;
794
795
796 // *-*-*-*-*-*-*-*-*-*-*-*-*
797 SortTracks("+CAL+TOF");
798 // *-*-*-*-*-*-*-*-*-*-*-*-*
799 if(!timage)return 0;
800 if(!timage->GetEntries())return 0;
801
802 PamTrack *image = 0;
803
804 if( it >=0 && it < trk2_obj->TrkLevel2::GetNTracks() ){
805 TClonesArray &t = *(tsorted);
806 PamTrack *temp = (PamTrack*)t[it];
807 if( temp->GetTrkTrack()->HasImage() ){
808 TClonesArray &t = *(timage);
809 image = (PamTrack*)t[it];
810 }else{
811 // cout <<"PamLevel2::GetTrackImage(int) : Track SeqNo "<<it<<" does not have image"<<endl;
812 };
813 }else{
814 cout << "PamLevel2::GetTrackImage(int) : Tracker track SeqNo "<< it <<" does not exist (GetNTracks() = "<<trk2_obj->TrkLevel2::GetNTracks()<<")"<<endl;
815 };
816
817 return image;
818 }
819
820 //--------------------------------------
821 //
822 //
823 //--------------------------------------
824 /**
825 * Get the Pamela detector trees in a single file and make them friends.
826 * @param f TFile pointer
827 * @param detlist String to select trees to be included
828 * @return Pointer to a TTree
829 */
830 TTree *PamLevel2::GetPamTree(TFile *f, TString detlist ){
831
832 // if( !detlist.IsNull() ) SetWhichTrees(detlist);
833 // else GetWhichTrees(f);
834
835 cout << "TTree *PamLevel2::GetPamTree(TFile *f, TString detlist ) -- obsolte "<<endl;
836
837 SetWhichTrees(detlist);
838
839 TTree *Trout =0;
840
841 TString fname = f->GetName();
842 if(!CheckLevel2File(fname))return NULL;
843
844 // UInt_t *found=0;
845
846 cout<< "GetPamTree(TFile*,TString): detector list --> ";
847 if(TRK1)cout<<"TRK1 ";
848 if(TRK2)cout<<"TRK2 ";
849 if(TRKh)cout<<"TRKH ";
850 if(CAL1)cout<<"CAL1 ";
851 if(CAL2)cout<<"CAL2 ";
852 if(TOF)cout<<"TOF ";
853 if(TRG)cout<<"TRG ";
854 if(AC)cout<<"AC ";
855 if(ND)cout<<"ND ";
856 if(S4)cout<<"S4 ";
857 if(ORB)cout<<"ORB ";
858 cout << endl;
859 if(SELLI)cout<<">>> Found selection-list <<<"<<endl;
860
861 f->cd();
862
863 // Tracker
864 TTree *T = (TTree*)f->Get("Tracker");
865 if(T && (TRK2||TRK1||TRKh)) {
866 if(TRK2)T->SetBranchAddress("TrkLevel2", GetPointerTo("TrkLevel2"));
867 // else T->SetBranchStatus("TrkLevel2",0,found);
868 if(TRK2)cout << "Tracker : set branch address TrkLevel2"<<endl;
869 if(TRK1)T->SetBranchAddress("TrkLevel1", GetPointerTo("TrkLevel1"));
870 // else T->SetBranchStatus("TrkLevel1",0,found);
871 if(TRK1)cout << "Tracker : set branch address TrkLevel1"<<endl;
872 if(TRKh)T->SetBranchAddress("TrkHough", GetPointerTo("TrkHough"));
873 // else T->SetBranchStatus("TrkHough",0,found);
874 if(TRKh)cout << "Tracker : set branch address TrkHough"<<endl;
875 if(!Trout)Trout=T;
876 else Trout->AddFriend(T);
877 }else{
878 cout << "Tracker : missing tree"<<endl;
879 };
880 // Calorimeter
881 TTree *C = (TTree*)f->Get("Calorimeter");
882 if(C && (CAL2||CAL1)) {
883 if(CAL2)C->SetBranchAddress("CaloLevel2", GetPointerTo("CaloLevel2"));
884 // else C->SetBranchStatus("CaloLevel2",0,found);
885 if(CAL2)cout << "Calorimeter : set branch address CaloLevel2"<<endl;
886 if(CAL1)C->SetBranchAddress("CaloLevel1", GetPointerTo("CaloLevel1"));
887 // else C->SetBranchStatus("CaloLevel1",0,found);
888 if(CAL1)cout << "Calorimeter : set branch address CaloLevel1"<<endl;
889 if(!Trout)Trout=C;
890 else Trout->AddFriend(C);
891 }else{
892 cout << "Calorimeter : missing tree"<<endl;
893 };
894
895 // ToF
896 TTree *O = (TTree*)f->Get("ToF");
897 if(O && TOF) {
898 O->SetBranchAddress("ToFLevel2", GetPointerTo("ToFLevel2"));
899 cout << "ToF : set branch address ToFLevel2"<<endl;
900 if(!Trout)Trout=O;
901 else Trout->AddFriend(O);
902 }else{
903 cout << "ToF : missing tree"<<endl;
904 };
905 // Trigger
906 TTree *R = (TTree*)f->Get("Trigger");
907 if(R && TRG) {
908 R->SetBranchAddress("TrigLevel2", GetPointerTo("TrigLevel2"));
909 cout << "Trigger : set branch address TrigLevel2"<<endl;
910 if(!Trout)Trout=O;
911 else Trout->AddFriend(R);
912 }else{
913 cout << "Trigger : missing tree"<<endl;
914 };
915 // S4
916 TTree *S = (TTree*)f->Get("S4");
917 if(S && S4) {
918 S->SetBranchAddress("S4Level2", GetPointerTo("S4Level2"));
919 cout << "S4 : set branch address S4Level2"<<endl;
920 if(!Trout)Trout=O;
921 else Trout->AddFriend(S);
922 }else{
923 cout << "S4 : missing tree"<<endl;
924 };
925 // Neutron Detector
926 TTree *N = (TTree*)f->Get("NeutronD");
927 if(N && ND) {
928 N->SetBranchAddress("NDLevel2", GetPointerTo("NDLevel2"));
929 cout << "NeutronD : set branch address NDLevel2"<<endl;
930 if(!Trout)Trout=O;
931 else Trout->AddFriend(N);
932 }else{
933 cout << "NeutronD : missing tree"<<endl;
934 };
935 // Anticounters
936 TTree *A = (TTree*)f->Get("Anticounter");
937 if(A && AC) {
938 A->SetBranchAddress("AcLevel2", GetPointerTo("AcLevel2"));
939 cout << "Anticounter : set branch address AcLevel2"<<endl;
940 if(!Trout)Trout=O;
941 else Trout->AddFriend(A);
942 }else{
943 cout << "Anticounter : missing tree"<<endl;
944 };
945 // Orbital Info
946 TTree *B = (TTree*)f->Get("OrbitalInfo");
947 if(B && ORB) {
948 B->SetBranchAddress("OrbitalInfo", GetPointerTo("OrbitalInfo"));
949 cout << "OrbitalInfo : set branch address OrbitalInfo"<<endl;
950 if(!Trout)Trout=O;
951 else Trout->AddFriend(B);
952 }else{
953 cout << "OrbitalInfo : missing tree"<<endl;
954 };
955
956 TTree *L = (TTree*)f->Get("SelectionList");
957 if(L && SELLI==1) {
958 // L->SetBranchAddress("RunEntry",&irun);
959 // cout << "SelectionList: set branch address RunEntry"<<endl;
960 // L->SetBranchAddress("EventEntry",&irunentry);
961 // cout << "SelectionList: set branch address EventEntry"<<endl;
962 // if(!Trout)Trout=O;
963 // else Trout->AddFriend("SelectionList");
964 cout << " TTree *PamLevel2::GetPamTree(TFile, TString) >>> SelectionList not implemente!!!!"<<endl;
965 sel_tree = 0;
966 }else{
967 cout << "SelectionList : missing tree"<<endl;
968 };
969
970 cout<<endl<<" Number of entries: "<<Trout->GetEntries()<<endl<<endl;
971
972 pam_tree = (TChain*)Trout;
973
974 return Trout;
975
976 }
977 //--------------------------------------
978 //
979 //
980 //--------------------------------------
981 /**
982 * Get list of Level2 files.
983 * @param ddir Level2 data directory.
984 * @param flisttxt Name of txt file containing file list.
985 * @return Pointer to a TList of TSystemFiles
986 * If no input file list is given , all the Level2 files inside the directory are processed.
987 */
988 TList* PamLevel2::GetListOfLevel2Files(TString ddir, TString flisttxt = ""){
989
990 TString wdir = gSystem->WorkingDirectory();
991
992 if(ddir=="")ddir = wdir;
993 // TSystemDirectory *datadir = new TSystemDirectory(gSystem->BaseName(ddir),ddir);
994 cout << "Level2 data directory : "<< ddir << endl;
995
996 TList *contents = new TList; // create output list
997 contents->SetOwner();
998
999 // char *fullpath;
1000 // const char *fullpath;
1001
1002 // if no input file list is given:
1003 if ( flisttxt != "" ){
1004
1005 // if( !gSystem->IsFileInIncludePath(flisttxt,&fullpath) ){
1006 // if( !(fullpath = gSystem->FindFile("./",flisttxt)) ){
1007 // cout <<"File "<<flisttxt<<" not found"<<endl;
1008 // return 0;
1009 // }
1010 // flisttxt = fullpath;
1011
1012 flisttxt = gSystem->ConcatFileName(gSystem->DirName(flisttxt),gSystem->BaseName(flisttxt));
1013
1014 if( !gSystem->ChangeDirectory(ddir) ){
1015 cout << "Cannot change directory : "<<ddir<<endl;
1016 return 0;
1017 }
1018
1019 cout <<"Input file list : " << flisttxt <<endl;
1020 ifstream in;
1021 in.open(flisttxt, ios::in); //open input file list
1022 if(!in.good()){
1023 cout <<" ERROR opening the file "<<endl;
1024 gSystem->ChangeDirectory(wdir); // back to the working directory
1025 return 0;
1026 }
1027 int line=0;
1028 while (1) {
1029 TString file;
1030 in >> file;
1031 if (!in.good()) break;
1032 line++;
1033 // cout <<"(1) " << file << endl;
1034 if(file.IsNull()){
1035 cout << "-- list interrupted at line "<<line <<endl;
1036 break;
1037 }
1038 if(file.Contains("#"))file = file(0,file.First("#"));
1039 // cout <<"(2) " << file << endl;
1040 // if( gSystem->IsFileInIncludePath(file,&fullpath) ){
1041 // if( (fullpath = gSystem->FindFile(ddir,file)) ){
1042 if( file.EndsWith(".root") ){
1043 char *fullpath = gSystem->ConcatFileName(gSystem->DirName(ddir),gSystem->BaseName(file));
1044 contents->Add(new TSystemFile(fullpath,gSystem->DirName(fullpath)));// add file to the list
1045 delete fullpath;
1046 }
1047 // }else{
1048 // if(file.Data()!="")cout << "File: "<<file<<" ---> missing "<< endl;
1049 // };
1050 };
1051 in.close();
1052
1053 }else{
1054
1055 cout << "No input file list given."<<endl;
1056 cout << "Check for existing root files."<<endl;
1057 // cout << "Warking directory: "<< gSystem->WorkingDirectory()<< endl;
1058
1059 TSystemDirectory *datadir = new TSystemDirectory(gSystem->BaseName(ddir),ddir);
1060 TList *temp = datadir->GetListOfFiles();
1061 // temp->Print();
1062 // cout << "*************************************" << endl;
1063
1064 TIter next(temp);
1065 TSystemFile *questo = 0;
1066
1067
1068 while ( (questo = (TSystemFile*) next()) ) {
1069 TString name = questo-> GetName();
1070 if( name.EndsWith(".root") ){
1071 // const char *fullpath = gSystem->FindFile(ddir,name);
1072 // char *fullpath;
1073 // gSystem->IsFileInIncludePath(name,&fullpath);
1074 char *fullpath = gSystem->ConcatFileName(gSystem->DirName(ddir),gSystem->BaseName(name));
1075 contents->Add(new TSystemFile(fullpath,gSystem->DirName(fullpath)));
1076 delete fullpath;
1077 };
1078 }
1079 delete temp;
1080 delete datadir;
1081
1082 };
1083 gSystem->ChangeDirectory(wdir); // back to the working directory
1084 // cout << endl << "Selected files:" << endl;
1085 // contents->Print();
1086 cout << contents->GetEntries()<<" files \n";
1087 // cout << endl;
1088 // cout << "Working directory: "<< gSystem->WorkingDirectory()<< endl;
1089 return contents;
1090 };
1091 //--------------------------------------
1092 //
1093 //
1094 //--------------------------------------
1095 /**
1096 * Get the Pamela detector chains from a list of files and make them friends.
1097 * @param fl Pointer to a TList of TSystemFiles
1098 * @param detlist String to select trees to be included
1099 * @return Pointer to a TChain
1100 */
1101 TChain *PamLevel2::GetPamTree(TList *fl, TString detlist ){
1102
1103 TChain *Trout =0;
1104
1105 // if( !detlist.IsNull() )SetWhichTrees(detlist);
1106 SetWhichTrees(detlist);
1107
1108 cout<< "GetPamTree(TList*,TString): input detector list --> ";
1109 if(TRK1)cout<<"TRK1 ";
1110 if(TRK2)cout<<"TRK2 ";
1111 if(TRKh)cout<<"TRKH ";
1112 if(CAL1)cout<<"CAL1 ";
1113 if(CAL2)cout<<"CAL2 ";
1114 if(TOF)cout<<"TOF ";
1115 if(TRG)cout<<"TRG ";
1116 if(AC)cout<<"AC ";
1117 if(ND)cout<<"ND ";
1118 if(S4)cout<<"S4 ";
1119 if(ORB)cout<<"ORB ";
1120 cout << endl;
1121
1122 TChain *T = 0;
1123 TChain *C = 0;
1124 TChain *O = 0;
1125 TChain *R = 0;
1126 TChain *S = 0;
1127 TChain *N = 0;
1128 TChain *A = 0;
1129 TChain *B = 0;
1130
1131 TChain *L = 0;
1132
1133 if(TRK2||TRK1||TRKh) T = new TChain("Tracker");
1134 if(CAL2||CAL1) C = new TChain("Calorimeter");
1135 if(TOF) O = new TChain("ToF");
1136 if(TRG) R = new TChain("Trigger");
1137 if(S4) S = new TChain("S4");
1138 if(ND) N = new TChain("NeutronD");
1139 if(AC) A = new TChain("Anticounter");
1140 if(ORB) B = new TChain("OrbitalInfo");
1141
1142 L = new TChain("SelectionList");
1143
1144 // loop over files and create chains
1145 TIter next(fl);
1146 TSystemFile *questo = 0;
1147 while ( (questo = (TSystemFile*) next()) ) {
1148 TString name = questo->GetName();
1149 cout << "File: "<< name << endl;
1150 if( CheckLevel2File(name) ){
1151 if(TRK2||TRK1||TRKh) T->Add(name);
1152 if(CAL1||CAL2) C->Add(name);
1153 if(TOF) O->Add(name);
1154 if(TRG) R->Add(name);
1155 if(S4) S->Add(name);
1156 if(ND) N->Add(name);
1157 if(AC) A->Add(name);
1158 if(ORB) B->Add(name);
1159 if(SELLI==1) L->Add(name);
1160 };
1161 }
1162
1163 cout << "done chain \n";
1164
1165 // UInt_t *found=0;
1166 // Tracker
1167 if(T && (TRK2||TRK1||TRKh)) {
1168 if(TRK2)T->SetBranchAddress("TrkLevel2", GetPointerTo("TrkLevel2"));
1169 // else T->SetBranchStatus("TrkLevel2",0,found);
1170 if(TRK2)cout << "Tracker : set branch address TrkLevel2"<<endl;
1171 if(TRK1)T->SetBranchAddress("TrkLevel1", GetPointerTo("TrkLevel1"));
1172 // else T->SetBranchStatus("TrkLevel1",0,found);
1173 if(TRK1)cout << "Tracker : set branch address TrkLevel1"<<endl;
1174 if(TRKh)T->SetBranchAddress("TrkHough", GetPointerTo("TrkHough"));
1175 // else T->SetBranchStatus("TrkHough",0,found);
1176 if(TRKh)cout << "Tracker : set branch address TrkHough"<<endl;
1177 if(!Trout)Trout=T;
1178 else Trout->AddFriend("Tracker");
1179 }else{
1180 cout << "Tracker : missing tree"<<endl;
1181 };
1182 // Calorimeter
1183 if(C && (CAL2||CAL1)) {
1184 if(CAL2)C->SetBranchAddress("CaloLevel2", GetPointerTo("CaloLevel2"));
1185 // else C->SetBranchStatus("CaloLevel2",0,found);
1186 if(CAL2)cout << "Calorimeter : set branch address CaloLevel2"<<endl;
1187 if(CAL1)C->SetBranchAddress("CaloLevel1", GetPointerTo("CaloLevel1"));
1188 // else C->SetBranchStatus("CaloLevel1",0,found);
1189 if(CAL1)cout << "Calorimeter : set branch address CaloLevel1"<<endl;
1190 if(!Trout)Trout=C;
1191 else Trout->AddFriend("Calorimeter");
1192 }else{
1193 cout << "Calorimeter : missing tree"<<endl;
1194 };
1195 // ToF
1196 if(O && TOF) {
1197 O->SetBranchAddress("ToFLevel2", GetPointerTo("ToFLevel2"));
1198 cout << "ToF : set branch address ToFLevel2"<<endl;
1199 if(!Trout)Trout=O;
1200 else Trout->AddFriend("ToF");
1201 }else{
1202 cout << "ToF : missing tree"<<endl;
1203 };
1204 // Trigger
1205 if(R && TRG) {
1206 R->SetBranchAddress("TrigLevel2", GetPointerTo("TrigLevel2"));
1207 cout << "Trigger : set branch address TrigLevel2"<<endl;
1208 if(!Trout)Trout=O;
1209 else Trout->AddFriend("Trigger");
1210 }else{
1211 cout << "Trigger : missing tree"<<endl;
1212 };
1213 // S4
1214 if(S && S4) {
1215 S->SetBranchAddress("S4Level2", GetPointerTo("S4Level2"));
1216 cout << "S4 : set branch address S4Level2"<<endl;
1217 if(!Trout)Trout=O;
1218 else Trout->AddFriend("S4");
1219 }else{
1220 cout << "S4 : missing tree"<<endl;
1221 };
1222 // Neutron Detector
1223 if(N && ND) {
1224 N->SetBranchAddress("NDLevel2", GetPointerTo("NDLevel2"));
1225 cout << "NeutronD : set branch address NDLevel2"<<endl;
1226 if(!Trout)Trout=O;
1227 else Trout->AddFriend("NeutronD");
1228 }else{
1229 cout << "NeutronD : missing tree"<<endl;
1230 };
1231 // Anticounters
1232 if(A && AC) {
1233 A->SetBranchAddress("AcLevel2", GetPointerTo("AcLevel2"));
1234 cout << "Anticounter : set branch address AcLevel2"<<endl;
1235 if(!Trout)Trout=O;
1236 else Trout->AddFriend("Anticounter");
1237 }else{
1238 cout << "Anticounter : missing tree"<<endl;
1239 };
1240 // Orbital Info
1241 if(B && ORB) {
1242 B->SetBranchAddress("OrbitalInfo", GetPointerTo("OrbitalInfo"));
1243 cout << "OrbitalInfo : set branch address OrbitalInfo"<<endl;
1244 if(!Trout)Trout=O;
1245 else Trout->AddFriend("OrbitalInfo");
1246 }else{
1247 cout << "OrbitalInfo : missing tree"<<endl;
1248 };
1249
1250 // Selection List
1251 if(L && SELLI==1) {
1252 cout<<">>> Found selection-list <<<"<<endl;
1253 L->SetBranchAddress("RunEntry",&irun);
1254 cout << "SelectionList: set branch address RunEntry"<<endl;
1255 L->SetBranchAddress("EventEntry",&irunentry);
1256 cout << "SelectionList: set branch address EventEntry"<<endl;
1257 sel_tree = L;
1258 // if(!Trout)Trout=O;
1259 // else Trout->AddFriend("SelectionList");
1260 }else{
1261 // cout << "SelectionList : missing tree"<<endl;
1262 if(L)L->Delete();
1263 };
1264
1265 // cout<<endl<<" Number of entries: "<<Trout->GetEntries()<<endl<<endl;
1266
1267 pam_tree = Trout;
1268
1269 return Trout;
1270 }
1271
1272
1273
1274 //--------------------------------------
1275 //
1276 //
1277 //--------------------------------------
1278 /**
1279 * Set branch addresses for Pamela friend trees
1280 */
1281 void PamLevel2::SetBranchAddress(TTree *t){
1282
1283 TRK2 = TRK2 & t->GetBranchStatus("TrkLevel2");
1284 TRK1 = TRK1 & t->GetBranchStatus("TrkLevel1");
1285 TRKh = TRKh & t->GetBranchStatus("TrkHough");
1286 CAL2 = CAL2 & t->GetBranchStatus("CaloLevel2");
1287 CAL1 = CAL1 & t->GetBranchStatus("CaloLevel1");
1288 TOF = TOF & t->GetBranchStatus("ToFLevel2");
1289 TRG = TRG & t->GetBranchStatus("TrigLevel2");
1290 S4 = S4 & t->GetBranchStatus("S4Level2");
1291 ND = ND & t->GetBranchStatus("NDLevel2");
1292 AC = AC & t->GetBranchStatus("AcLevel2");
1293 ORB = ORB & t->GetBranchStatus("OrbitalInfo");
1294
1295
1296 // Tracker
1297 if(TRK1) {
1298 t->SetBranchAddress("TrkLevel1", GetPointerTo("TrkLevel2"));
1299 cout << "Tracker : set branch address TrkLevel1"<<endl;
1300 };
1301 if(TRK2) {
1302 t->SetBranchAddress("TrkLevel2", GetPointerTo("TrkLevel1"));
1303 cout << "Tracker : set branch address TrkLevel2"<<endl;
1304 };
1305 if(TRKh) {
1306 t->SetBranchAddress("TrkHough", GetPointerTo("TrkHough"));
1307 cout << "Tracker : set branch address TrkHough"<<endl;
1308 };
1309
1310 // Calorimeter
1311 if(CAL1) {
1312 t->SetBranchAddress("CaloLevel1", GetPointerTo("CaloLevel1"));
1313 cout << "Calorimeter : set branch address CaloLevel1"<<endl;
1314 };
1315 if(CAL2) {
1316 t->SetBranchAddress("CaloLevel2", GetPointerTo("CaloLevel2"));
1317 cout << "Calorimeter : set branch address CaloLevel2"<<endl;
1318 };
1319
1320 // ToF
1321 if(TOF) {
1322 t->SetBranchAddress("ToFLevel2", GetPointerTo("ToFLevel2"));
1323 cout << "ToF : set branch address ToFLevel2"<<endl;
1324 };
1325 // Trigger
1326 if(TRG) {
1327 t->SetBranchAddress("TrigLevel2", GetPointerTo("TrigLevel2"));
1328 cout << "Trigger : set branch address TrigLevel2"<<endl;
1329 };
1330 // S4
1331 if(S4) {
1332 t->SetBranchAddress("S4Level2", GetPointerTo("S4Level2"));
1333 cout << "S4 : set branch address S4Level2"<<endl;
1334 };
1335 // Neutron Detector
1336 if(ND) {
1337 t->SetBranchAddress("NDLevel2", GetPointerTo("NDLevel2"));
1338 cout << "NeutronD : set branch address NDLevel2"<<endl;
1339 };
1340 // Anticounters
1341 if(AC) {
1342 t->SetBranchAddress("AcLevel2", GetPointerTo("AcLevel2"));
1343 cout << "Anticounter : set branch address AcLevel2"<<endl;
1344 };
1345 // OrbitalInfo
1346 if(ORB) {
1347 t->SetBranchAddress("OrbitalInfo", GetPointerTo("OrbitalInfo"));
1348 cout << "OrbitalInfo : set branch address OrbitalInfo"<<endl;
1349 };
1350 // SelectionList
1351 if(SELLI==1) {
1352 t->SetBranchAddress("RunEntry", &irun);
1353 cout << "SelectionList: set branch address RunEntry"<<endl;
1354 t->SetBranchAddress("EventEntry", &irunentry);
1355 cout << "SelectionList: set branch address EventEntry"<<endl;
1356 };
1357
1358 }
1359 /**
1360 * Set branch addresses for Pamela friend trees
1361 */
1362 void PamLevel2::SetBranchAddress(TChain *t){
1363
1364 TRK2 = TRK2 & t->GetBranchStatus("TrkLevel2");
1365 TRK1 = TRK1 & t->GetBranchStatus("TrkLevel1");
1366 TRKh = TRKh & t->GetBranchStatus("TrkHough");
1367 CAL1 = CAL1 & t->GetBranchStatus("CaloLevel1");
1368 CAL2 = CAL2 & t->GetBranchStatus("CaloLevel2");
1369 TOF = TOF & t->GetBranchStatus("ToFLevel2");
1370 TRG = TRG & t->GetBranchStatus("TrigLevel2");
1371 S4 = S4 & t->GetBranchStatus("S4Level2");
1372 ND = ND & t->GetBranchStatus("NDLevel2");
1373 AC = AC & t->GetBranchStatus("AcLevel2");
1374 ORB = ORB & t->GetBranchStatus("OrbitalInfo");
1375
1376 // Tracker
1377 if(TRK2) {
1378 t->SetBranchAddress("TrkLevel2", GetPointerTo("TrkLevel2"));
1379 cout << "Tracker : set branch address TrkLevel2"<<endl;
1380 };
1381 if(TRK1) {
1382 t->SetBranchAddress("TrkLevel1", GetPointerTo("TrkLevel1"));
1383 cout << "Tracker : set branch address TrkLevel1"<<endl;
1384 };
1385 if(TRKh) {
1386 t->SetBranchAddress("TrkHough", GetPointerTo("TrkHough"));
1387 cout << "Tracker : set branch address TrkHough"<<endl;
1388 };
1389
1390 // Calorimeter
1391 if(CAL2) {
1392 t->SetBranchAddress("CaloLevel2", GetPointerTo("CaloLevel2"));
1393 cout << "Calorimeter : set branch address CaloLevel2"<<endl;
1394 };
1395 if(CAL1) {
1396 t->SetBranchAddress("CaloLevel1", GetPointerTo("CaloLevel1"));
1397 cout << "Calorimeter : set branch address CaloLevel1"<<endl;
1398 };
1399
1400 // ToF
1401 if(TOF) {
1402 t->SetBranchAddress("ToFLevel2", GetPointerTo("ToFLevel2"));
1403 cout << "ToF : set branch address ToFLevel2"<<endl;
1404 };
1405 // Trigger
1406 if(TRG) {
1407 t->SetBranchAddress("TrigLevel2", GetPointerTo("TrigLevel2"));
1408 cout << "Trigger : set branch address TrigLevel2"<<endl;
1409 };
1410 // S4
1411 if(S4) {
1412 t->SetBranchAddress("S4Level2", GetPointerTo("S4Level2"));
1413 cout << "S4 : set branch address S4Level2"<<endl;
1414 };
1415 // Neutron Detector
1416 if(ND) {
1417 t->SetBranchAddress("NDLevel2", GetPointerTo("NDLevel2"));
1418 cout << "NeutronD : set branch address NDLevel2"<<endl;
1419 };
1420 // Anticounters
1421 if(AC) {
1422 t->SetBranchAddress("AcLevel2", GetPointerTo("AcLevel2"));
1423 cout << "Anticounter : set branch address AcLevel2"<<endl;
1424 };
1425 // OrbitalInfo
1426 if(ORB) {
1427 t->SetBranchAddress("OrbitalInfo", GetPointerTo("OrbitalInfo"));
1428 cout << "OrbitalInfo : set branch address OrbitalInfo"<<endl;
1429 };
1430 // SelectionList
1431 if(SELLI==1) {
1432 t->SetBranchAddress("RunEntry", &irun);
1433 cout << "SelectionList: set branch address RunEntry"<<endl;
1434 t->SetBranchAddress("EventEntry", &irunentry);
1435 cout << "SelectionList: set branch address EventEntry"<<endl;
1436 };
1437
1438 }
1439
1440
1441 //--------------------------------------
1442 //
1443 //
1444 //--------------------------------------
1445 /**
1446 * Get the Run tree chain from a list of files.
1447 * @param fl Pointer to a TList of TSystemFiles
1448 * @return Pointer to a TChain
1449 */
1450 TChain *PamLevel2::GetRunTree(TList *fl){
1451
1452 TChain *R = new TChain("Run");
1453
1454 // loop over files and create chains
1455 TIter next(fl);
1456 TSystemFile *questo = 0;
1457 while ( (questo = (TSystemFile*) next()) ) {
1458 TString name = questo->GetName();
1459 // cout << "File: "<< name << endl;
1460 if( CheckLevel2File(name) ){
1461 R->Add(name);
1462 };
1463 }
1464
1465 if(R->GetNtrees()){
1466
1467 R->SetBranchAddress("RunInfo", GetPointerTo("RunInfo"));
1468 cout << "Run : set branch address RunInfo"<<endl;
1469 R->SetBranchAddress("SoftInfo", GetPointerTo("SoftInfo")); // Emiliano
1470 cout << "Software : set branch address SoftInfo"<<endl; // Emiliano
1471 }else{
1472 delete R;
1473 R=0;
1474 }
1475
1476 run_tree = R;
1477
1478 return R;
1479
1480 }
1481 //--------------------------------------
1482 //
1483 //
1484 //--------------------------------------
1485 /**
1486 * Get the Run tree from a file.
1487 * @param f Pointer to a TFile
1488 * @return Pointer to a TTree
1489 */
1490 TTree *PamLevel2::GetRunTree(TFile *f){
1491
1492 cout << "TTree *PamLevel2::GetRunTree(TFile *f) -- obsolte "<<endl;
1493
1494 TTree *R = (TTree*)f->Get("Run");
1495
1496 if(R){
1497 R->SetBranchAddress("RunInfo", GetPointerTo("RunInfo"));
1498 cout << "Run : set branch address RunInfo"<<endl;
1499 R->SetBranchAddress("SoftInfo", GetPointerTo("SoftInfo")); // Emiliano
1500 cout << "Software : set branch address SoftInfo"<<endl; // Emiliano
1501 }
1502
1503 run_tree = (TChain*)R;
1504
1505 return R;
1506
1507 }
1508 /**
1509 * Update the runinfo informations (to be used to have Run infos event by event basis)
1510 * @param run Pointer to the chain/tree which contains run infos
1511 * @return true if a new run has been read, false if it is still the same run
1512 */
1513 Bool_t PamLevel2::UpdateRunInfo(TChain *run, ULong64_t iev){
1514 //
1515 // check if we have already called once GetEntry, if not call it
1516 //
1517 if ( run->GetEntries() <= 0 ) return(false);
1518 //
1519
1520 Int_t oldrun = irun;
1521 // --------------------------------------
1522 // if it is a full file (not preselected)
1523 // --------------------------------------
1524 if(SELLI==0){
1525 if ( irun < 0 ){
1526 irun = 0;
1527 run->GetEntry(0);
1528 runfirstentry = 0ULL;
1529 runlastentry += (ULong64_t)(this->GetRunInfo()->NEVENTS) - 1ULL;
1530 };
1531
1532 if( !GetOrbitalInfo() ){
1533 cout << "Bool_t PamLevel2::UpdateRunInfo(TChain *run, ULong64_t iev) -- ERROR -- missing OrbitalInfo "<<endl;
1534 return(false);
1535 }
1536 // modificato il controllo sull'aggiornamento del run, per evitare problemi
1537 // dovuti agli eventi annidati (NB! NEVENTS conta anche questi!!)
1538 while ( GetOrbitalInfo()->absTime > GetRunInfo()->RUNTRAILER_TIME && irun < run->GetEntries() ){
1539 // while ( iev > (runfirstentry+(ULong64_t)(this->GetRunInfo()->NEVENTS-1)) && irun < run->GetEntries() ){
1540 // printf(" iev %llu %u %llu \n",iev,this->GetRunInfo()->NEVENTS,(ULong64_t)(runfirstentry+(ULong64_t)(this->GetRunInfo()->NEVENTS)));
1541 irun++;
1542 run->GetEntry(irun);
1543 runfirstentry = runlastentry+1ULL;
1544 runlastentry += (ULong64_t)(this->GetRunInfo()->NEVENTS);
1545 };
1546
1547 //
1548 if ( irun == oldrun || irun >= run->GetEntries() ) return(false);
1549 //
1550 // printf(" iev %llu irun %i nevents %u 1st %llu last %llu \n",iev,irun,this->GetRunInfo()->NEVENTS,(ULong64_t)runfirstentry,(ULong64_t)runlastentry);
1551 //
1552 return(true);
1553 };
1554 // ----------------------------------------------------
1555 // if it is a preselected file (there is SelectionList)
1556 // NBNB - the event tree MUST be read first
1557 // ----------------------------------------------------
1558 if(SELLI==1){
1559 sel_tree->GetEntry(iev);
1560 if(irun != oldrun){
1561 run->GetEntry(irun);
1562 return true;
1563 }
1564 return false;
1565 }
1566
1567 return false;
1568 //
1569 };
1570 /**
1571 * Update the runinfo informations (to be used to have Run infos event by event basis)
1572 * @param run Pointer to the chain/tree which contains run infos
1573 * @return true if a new run has been read, false if it is still the same run
1574 */
1575 Bool_t PamLevel2::UpdateRunInfo(TTree *run, ULong64_t iev){
1576 return(UpdateRunInfo((TChain*)run,iev));
1577 };
1578
1579 //--------------------------------------
1580 //
1581 //
1582 //--------------------------------------
1583 /**
1584 * Set which trees shoul be analysed
1585 * @param detlist TString containing the sequence of trees required
1586 */
1587 void PamLevel2::SetWhichTrees(TString detlist){
1588
1589 if(detlist.IsNull() || detlist.Contains("+ALL", TString::kIgnoreCase)){
1590 CAL0 = false;
1591 CAL1 = true;
1592 CAL2 = true;
1593 TRK2 = true;
1594 TRK1 = false;
1595 TRKh = false;
1596 TRK0 = false;
1597 TRG = true;
1598 TOF = true;
1599 TOF0 = false;
1600 S4 = true;
1601 ND = true;
1602 AC = true;
1603 ORB = true;
1604 }else if( detlist.Contains("-ALL", TString::kIgnoreCase) ){
1605 CAL0 = false;
1606 CAL1 = false;
1607 CAL2 = false;
1608 TRK2 = false;
1609 TRK1 = false;
1610 TRKh = false;
1611 TRK0 = false;
1612 TRG = false;
1613 TOF = false;
1614 TOF0 = false;
1615 S4 = false;
1616 ND = false;
1617 AC = false;
1618 ORB = false;
1619 };
1620
1621 // -------------------------------------------------------------------------
1622 if( detlist.Contains("CAL1", TString::kIgnoreCase) ){
1623 if ( detlist.Contains("-CAL1", TString::kIgnoreCase) )CAL1=false;
1624 if ( detlist.Contains("+CAL1", TString::kIgnoreCase) )CAL1=true;
1625 };
1626
1627 if( detlist.Contains("CAL0", TString::kIgnoreCase) ){
1628 if ( detlist.Contains("-CAL0", TString::kIgnoreCase) )CAL0=false;
1629 if ( detlist.Contains("+CAL0", TString::kIgnoreCase) )CAL0=true;
1630 };
1631
1632 if( detlist.Contains("CAL2", TString::kIgnoreCase)){
1633 if ( detlist.Contains("-CAL2", TString::kIgnoreCase) )CAL2=false;
1634 if ( detlist.Contains("+CAL2", TString::kIgnoreCase) )CAL2=true;
1635 };
1636
1637 if( detlist.Contains("+CAL", TString::kIgnoreCase) && !CAL1 && !CAL2 )CAL2=true;
1638 if( detlist.Contains("-CAL", TString::kIgnoreCase) && CAL1 && CAL2 ){
1639 CAL2=false;
1640 CAL1=false;
1641 }
1642 // -------------------------------------------------------------------------
1643 if( detlist.Contains("TRK0", TString::kIgnoreCase) ){
1644 if ( detlist.Contains("-TRK0", TString::kIgnoreCase) )TRK0=false;
1645 if ( detlist.Contains("+TRK0", TString::kIgnoreCase) )TRK0=true;
1646 };
1647
1648 if( detlist.Contains("TRK1", TString::kIgnoreCase) ){
1649 if ( detlist.Contains("-TRK1", TString::kIgnoreCase) )TRK1=false;
1650 if ( detlist.Contains("+TRK1", TString::kIgnoreCase) )TRK1=true;
1651 };
1652
1653 if( detlist.Contains("TRK2", TString::kIgnoreCase)){
1654 if ( detlist.Contains("-TRK2", TString::kIgnoreCase) )TRK2=false;
1655 if ( detlist.Contains("+TRK2", TString::kIgnoreCase) )TRK2=true;
1656 };
1657
1658 if( detlist.Contains("TRKh", TString::kIgnoreCase)){
1659 if ( detlist.Contains("-TRKh", TString::kIgnoreCase) )TRKh=false;
1660 if ( detlist.Contains("+TRKh", TString::kIgnoreCase) )TRKh=true;
1661 };
1662
1663 if( detlist.Contains("+TRK", TString::kIgnoreCase) && !TRK1 && !TRK2 && !TRKh )TRK2=true;
1664 if( detlist.Contains("-TRK", TString::kIgnoreCase) && TRK1 && TRK2 && TRKh){
1665 TRK2=false;
1666 TRK1=false;
1667 TRKh=false;
1668 }
1669 // -------------------------------------------------------------------------
1670
1671 if( detlist.Contains("-TRG", TString::kIgnoreCase) )TRG = false;
1672 else if( detlist.Contains("+TRG", TString::kIgnoreCase) )TRG = true;
1673
1674 if( detlist.Contains("-TOF", TString::kIgnoreCase) )TOF = false;
1675 else if( detlist.Contains("+TOF", TString::kIgnoreCase) )TOF = true;
1676
1677 if( detlist.Contains("-TOF0", TString::kIgnoreCase) )TOF0 = false;
1678 else if( detlist.Contains("+TOF0", TString::kIgnoreCase) )TOF0 = true;
1679
1680 if( detlist.Contains("-S4", TString::kIgnoreCase) )S4 = false;
1681 else if( detlist.Contains("+S4", TString::kIgnoreCase) )S4 = true;
1682
1683 if( detlist.Contains("-ND", TString::kIgnoreCase) )ND = false;
1684 else if( detlist.Contains("+ND", TString::kIgnoreCase) )ND = true;
1685
1686 if( detlist.Contains("-AC", TString::kIgnoreCase) )AC = false;
1687 else if( detlist.Contains("+AC", TString::kIgnoreCase) )AC = true;
1688
1689 if( detlist.Contains("-ORB", TString::kIgnoreCase) )ORB = false;
1690 else if( detlist.Contains("+ORB", TString::kIgnoreCase) )ORB = true;
1691
1692 // cout<< "Set detector list --> ";
1693 // if(TRK1)cout<<"TRK1 ";
1694 // if(TRK2)cout<<"TRK2 ";
1695 // if(TRKh)cout<<"TRKH ";
1696 // if(CAL1)cout<<"CAL1 ";
1697 // if(CAL2)cout<<"CAL2 ";
1698 // if(TOF)cout<<"TOF ";
1699 // if(TRG)cout<<"TRG ";
1700 // if(AC)cout<<"AC ";
1701 // if(ND)cout<<"ND ";
1702 // if(S4)cout<<"S4 ";
1703 // if(ORB)cout<<"ORB ";
1704 // cout << endl;
1705
1706 };
1707
1708
1709 /**
1710 * Set tree/branch detector flags from the content of a tree
1711 */
1712 void PamLevel2::GetWhichTrees(TFile* f){
1713
1714
1715
1716 cout << "void PamLevel2::GetWhichTrees(TFile* f) --- WARNING!! --- ...potrebbe non funzionare "<<endl;
1717 // -----------
1718 // reset flags
1719 // -----------
1720 CAL1 = false;
1721 CAL2 = false;
1722 TRK2 = false;
1723 TRK1 = false;
1724 TRKh = false;
1725 TRG = false;
1726 TOF = false;
1727 S4 = false;
1728 ND = false;
1729 AC = false;
1730 ORB = false;
1731
1732 RUN = false;
1733
1734 cout << "Checking file: "<<f->GetName()<<endl;
1735 if( !f || f->IsZombie() ){
1736 cout << "File: "<< f->GetName() <<" Non valid root file"<< endl;
1737 return;
1738 }
1739
1740 TList *lk = f->GetListOfKeys();
1741 TIter next(lk);
1742 TKey *key =0;
1743
1744 Int_t nev = 0;
1745
1746 while( (key = (TKey*)next()) ){
1747
1748 if( !strcmp(key->GetName(),"Run" ) )RUN = true;
1749
1750 //=========================================================
1751 if( !strcmp(key->GetName(),"Trigger" ) ){
1752 TRG = true;
1753 Int_t nevt = ((TTree*)f->Get("Trigger"))->GetEntries();
1754 if( nev && nevt!=nev){
1755 cout << "File: "<< f->GetName() <<" Trigger tree has "<<nevt<<" events instead of "<<nev<< endl;
1756 TRG = false;
1757 }else nev=nevt;
1758 }
1759 //=========================================================
1760 if( !strcmp(key->GetName(),"ToF" ) ){
1761 TOF = true;
1762 Int_t nevt = ((TTree*)f->Get("ToF"))->GetEntries();
1763 if( nev && nevt!=nev){
1764 cout << "File: "<< f->GetName() <<" ToF tree has "<<nevt<<" events instead of "<<nev<< endl;
1765 TOF = false;
1766 }else nev=nevt;
1767 }
1768 //=========================================================
1769 if( !strcmp(key->GetName(),"S4" ) ){
1770 S4 = true;
1771 Int_t nevt = ((TTree*)f->Get("S4"))->GetEntries();
1772 if( nev && nevt!=nev){
1773 cout << "File: "<< f->GetName() <<" S4 tree has "<<nevt<<" events instead of "<<nev<< endl;
1774 S4 = false;
1775 }else nev=nevt;
1776 }
1777 //=========================================================
1778
1779 if( !strcmp(key->GetName(),"NeutronD" ) ){
1780 ND = true;
1781 Int_t nevt = ((TTree*)f->Get("NeutronD"))->GetEntries();
1782 if( nev && nevt!=nev){
1783 cout << "File: "<< f->GetName() <<"NeutronD tree has "<<nevt<<" events instead of "<<nev<< endl;
1784 ND =false;
1785 }else nev=nevt;
1786 }
1787 //=========================================================
1788 if( !strcmp(key->GetName(),"Anticounter") ){
1789 AC = true;
1790 Int_t nevt = ((TTree*)f->Get("Anticounter"))->GetEntries();
1791 if( nev && nevt!=nev){
1792 cout << "File: "<< f->GetName() <<" Anticounter tree has "<<nevt<<" events instead of "<<nev<< endl;
1793 AC =false;
1794 }else nev=nevt;
1795 }
1796 //=========================================================
1797 if( !strcmp(key->GetName(),"OrbitalInfo") ){
1798 ORB = true;
1799 Int_t nevt = ((TTree*)f->Get("OrbitalInfo"))->GetEntries();
1800 if( nev && nevt!=nev){
1801 cout << "File: "<< f->GetName() <<" OrbitalInfo tree has "<<nevt<<" events instead of "<<nev<< endl;
1802 ORB = false;
1803 }else nev=nevt;
1804 }
1805 //=========================================================
1806 if( !strcmp(key->GetName(),"Tracker" ) ){
1807 TTree *T = (TTree*)f->Get("Tracker");
1808 for(Int_t i=0; i<T->GetListOfBranches()->GetEntries(); i++){
1809 TString name = T->GetListOfBranches()->At(i)->GetName();
1810 if( !name.CompareTo("TrkLevel1") )TRK1=true;
1811 if( !name.CompareTo("TrkLevel2") )TRK2=true;
1812 if( !name.CompareTo("TrkHough") )TRKh=true;
1813 };
1814 Int_t nevt = T->GetEntries();
1815 if( nev && nevt!=nev){
1816 cout << "File: "<< f->GetName() <<" Tracker tree has "<<nevt<<" events instead of "<<nev<< endl;
1817 TRK1 = false;
1818 TRK2 = false;
1819 TRKh = false;
1820 }else nev=nevt;
1821 T->Delete();
1822 };
1823 //=========================================================
1824 if( !strcmp(key->GetName(),"Calorimeter" ) ){
1825 TTree *T = (TTree*)f->Get("Calorimeter");
1826 for(Int_t i=0; i<T->GetListOfBranches()->GetEntries(); i++){
1827 TString name = T->GetListOfBranches()->At(i)->GetName();
1828 if( !name.CompareTo("CaloLevel1") )CAL1=true;
1829 if( !name.CompareTo("CaloLevel2") )CAL2=true;
1830 };
1831 Int_t nevt = T->GetEntries();
1832 if( nev && nevt!=nev){
1833 cout << "File: "<< f->GetName() <<" Calorimeter tree has "<<nevt<<" events instead of "<<nev<< endl;
1834 CAL1 = false;
1835 CAL2 = false;
1836 }else nev=nevt;
1837 T->Delete();
1838 };
1839
1840 };
1841
1842 delete lk;
1843
1844 // cout<< "Get detector list from input file --> ";
1845 // if(TRK1)cout<<"TRK1 ";
1846 // if(TRK2)cout<<"TRK2 ";
1847 // if(TRKh)cout<<"TRKH ";
1848 // if(CAL1)cout<<"CAL1 ";
1849 // if(CAL2)cout<<"CAL2 ";
1850 // if(TOF)cout<<"TOF ";
1851 // if(TRG)cout<<"TRG ";
1852 // if(AC)cout<<"AC ";
1853 // if(ND)cout<<"ND ";
1854 // if(S4)cout<<"S4 ";
1855 // if(ORB)cout<<"ORB ";
1856 // cout << endl;
1857
1858 return ;
1859
1860 };
1861
1862
1863 //--------------------------------------
1864 //
1865 //
1866 //--------------------------------------
1867 /**
1868 * Check if a file contains selected Pamela Level2 trees.
1869 * @param name File name
1870 * @return true if the file is ok.
1871 */
1872 Bool_t PamLevel2::CheckLevel2File(TString name){
1873
1874 Bool_t CAL1__ok = false;
1875 Bool_t CAL2__ok = false;
1876 Bool_t TRK2__ok = false;
1877 Bool_t TRK1__ok = false;
1878 Bool_t TRKh__ok = false;
1879 Bool_t TRG__ok = false;
1880 Bool_t TOF__ok = false;
1881 Bool_t S4__ok = false;
1882 Bool_t ND__ok = false;
1883 Bool_t AC__ok = false;
1884 Bool_t ORB__ok = false;
1885
1886 Bool_t RUN__ok = false;
1887
1888 Bool_t SELLI__ok = false;
1889
1890 cout << "Checking file: "<<name<<endl;
1891 TFile *f = new TFile(name.Data());
1892 if( !f || f->IsZombie() ){
1893 cout << "File: "<< f->GetName() <<" discarded ---- Non valid root file"<< endl; return false;
1894 }
1895 // cout << "Get list of keys: "<<f<<endl;
1896 TList *lk = f->GetListOfKeys();
1897 // lk->Print();
1898 TIter next(lk);
1899 TKey *key =0;
1900
1901 Int_t nev = 0;
1902
1903 while( (key = (TKey*)next()) ){
1904
1905 // cout << key->GetName() << endl;
1906 // cout << key->GetName() << ""<<key->GetClassName()<<endl;
1907 // cout << " Get tree: " << f->Get(key->GetName())<<endl;
1908 // nev_previous = nev;
1909 // cout << " n.entries "<< nev <<endl;
1910 // if( key->GetClassName()=="TTree" && nev_previous && nev != nev_previous ){
1911 // nev = ((TTree*)f->Get(key->GetName()))->GetEntries();
1912 // cout << "File: "<< f->GetName() <<" discarded ---- "<< key->GetName() << " tree: n.entries does not match "<<nev<<" "<<nev_previous<< endl;
1913 // return false;
1914 // };
1915
1916
1917 if( !strcmp(key->GetName(),"Run" ) )RUN__ok = true;
1918
1919 //=========================================================
1920 if( !strcmp(key->GetName(),"SelectionList" ) ){
1921 SELLI__ok = true;
1922 if(SELLI==1){
1923 Int_t nevt = ((TTree*)f->Get("SelectionList"))->GetEntries();
1924 if( nev && nevt!=nev){
1925 cout << "File: "<< f->GetName() <<" discarded ---- SelectionList tree has "<<nevt<<" events instead of "<<nev<< endl;
1926 return false;
1927 }
1928 nev=nevt;
1929 }
1930 }
1931
1932 //=========================================================
1933 if( !strcmp(key->GetName(),"Trigger" ) ){
1934 TRG__ok = true;
1935 if(TRG){
1936 Int_t nevt = ((TTree*)f->Get("Trigger"))->GetEntries();
1937 if( nev && nevt!=nev){
1938 cout << "File: "<< f->GetName() <<" discarded ---- Trigger tree has "<<nevt<<" events instead of "<<nev<< endl;
1939 return false;
1940 }
1941 nev=nevt;
1942 }
1943 }
1944 //=========================================================
1945 if( !strcmp(key->GetName(),"ToF" ) ){
1946 TOF__ok = true;
1947 if(TOF){
1948 Int_t nevt = ((TTree*)f->Get("ToF"))->GetEntries();
1949 if( nev && nevt!=nev){
1950 cout << "File: "<< f->GetName() <<" discarded ---- ToF tree has "<<nevt<<" events instead of "<<nev<< endl;
1951 return false;
1952 }
1953 nev=nevt;
1954 }
1955 }
1956 //=========================================================
1957 if( !strcmp(key->GetName(),"S4" ) ){
1958 S4__ok = true;
1959 if(S4){
1960 Int_t nevt = ((TTree*)f->Get("S4"))->GetEntries();
1961 if( nev && nevt!=nev){
1962 cout << "File: "<< f->GetName() <<" discarded ---- S4 tree has "<<nevt<<" events instead of "<<nev<< endl;
1963 return false;
1964 }
1965 nev=nevt;
1966 }
1967 }
1968 //=========================================================
1969
1970 if( !strcmp(key->GetName(),"NeutronD" ) ){
1971 ND__ok = true;
1972 if(ND){
1973 Int_t nevt = ((TTree*)f->Get("NeutronD"))->GetEntries();
1974 if( nev && nevt!=nev){
1975 cout << "File: "<< f->GetName() <<" discarded ---- NeutronD tree has "<<nevt<<" events instead of "<<nev<< endl;
1976 return false;
1977 }
1978 nev=nevt;
1979 }
1980 }
1981 //=========================================================
1982 if( !strcmp(key->GetName(),"Anticounter") ){
1983 AC__ok = true;
1984 if(AC){
1985 Int_t nevt = ((TTree*)f->Get("Anticounter"))->GetEntries();
1986 if( nev && nevt!=nev){
1987 cout << "File: "<< f->GetName() <<" discarded ---- Anticounter tree has "<<nevt<<" events instead of "<<nev<< endl;
1988 return false;
1989 }
1990 nev=nevt;
1991 }
1992 }
1993 //=========================================================
1994 if( !strcmp(key->GetName(),"OrbitalInfo") ){
1995 ORB__ok = true;
1996 if(ORB){
1997 Int_t nevt = ((TTree*)f->Get("OrbitalInfo"))->GetEntries();
1998 if( nev && nevt!=nev){
1999 cout << "File: "<< f->GetName() <<" discarded ---- OrbitalInfo tree has "<<nevt<<" events instead of "<<nev<< endl;
2000 return false;
2001 }
2002 nev=nevt;
2003 }
2004 }
2005 //=========================================================
2006 if( !strcmp(key->GetName(),"Tracker" ) ){
2007 TTree *T = (TTree*)f->Get("Tracker");
2008 if(TRK1||TRK2||TRKh){
2009 Int_t nevt = T->GetEntries();
2010 if( nev && nevt!=nev){
2011 cout << "File: "<< f->GetName() <<" discarded ---- Tracker tree has "<<nevt<<" events instead of "<<nev<< endl;
2012 return false;
2013 }
2014 nev=nevt;
2015 }
2016 for(Int_t i=0; i<T->GetListOfBranches()->GetEntries(); i++){
2017 TString name = T->GetListOfBranches()->At(i)->GetName();
2018 if( !name.CompareTo("TrkLevel1") )TRK1__ok=true;
2019 if( !name.CompareTo("TrkLevel2") )TRK2__ok=true;
2020 if( !name.CompareTo("TrkHough") )TRKh__ok=true;
2021 };
2022 T->Delete();
2023 };
2024 //=========================================================
2025 if( !strcmp(key->GetName(),"Calorimeter" ) ){
2026 TTree *T = (TTree*)f->Get("Calorimeter");
2027 if(CAL1||CAL2){
2028 Int_t nevt = T->GetEntries();
2029 if( nev && nevt!=nev){
2030 cout << "File: "<< f->GetName() <<" discarded ---- Calorimeter tree has "<<nevt<<" events instead of "<<nev<< endl;
2031 return false;
2032 }
2033 nev=nevt;
2034 }
2035 for(Int_t i=0; i<T->GetListOfBranches()->GetEntries(); i++){
2036 TString name = T->GetListOfBranches()->At(i)->GetName();
2037 if( !name.CompareTo("CaloLevel1") )CAL1__ok=true;
2038 if( !name.CompareTo("CaloLevel2") )CAL2__ok=true;
2039 };
2040 T->Delete();
2041 };
2042
2043 };
2044
2045 if( SELLI==-1 )SELLI = (Int_t)SELLI__ok;
2046 if( SELLI==0 && SELLI__ok ){
2047 cout << "File: "<< f->GetName() <<" discarded ---- found SelectionList (it is not a full-event file)" << endl;
2048 return false;
2049 }
2050 if( SELLI==1 && !SELLI__ok ){
2051 cout << "File: "<< f->GetName() <<" discarded ---- SelectionList missing" << endl;
2052 return false;
2053 }
2054
2055 // cout << "SELLI "<<SELLI<<endl;
2056
2057 // cout<< "CheckLevel2File(TString): detector list --> ";
2058 // if(TRK1__ok)cout<<"TRK1 ";
2059 // if(TRK2__ok)cout<<"TRK2 ";
2060 // if(TRKh__ok)cout<<"TRKH ";
2061 // if(CAL1__ok)cout<<"CAL1 ";
2062 // if(CAL2__ok)cout<<"CAL2 ";
2063 // if(TOF__ok)cout<<"TOF ";
2064 // if(TRG__ok)cout<<"TRG ";
2065 // if(AC__ok)cout<<"AC ";
2066 // if(ND__ok)cout<<"ND ";
2067 // if(S4__ok)cout<<"S4 ";
2068 // if(ORB__ok)cout<<"ORB ";
2069 // cout << endl;
2070
2071
2072 if(TRK2 && TRK1__ok)TRK1=1;
2073 // ----------------------------------------------------------------------------
2074 // NOTA
2075 // se c'e` il level1, lo devo necessarimente leggere.
2076 // infatti (non ho capito perche`) i cluster vengono letti e allocati in memoria
2077 // comunque, ma non vengono disallocati da PamLevel2::Clear()
2078 // ----------------------------------------------------------------------------
2079
2080
2081 if(!RUN__ok) {
2082 cout << "File: "<< f->GetName() <<" *WARNING* ---- Missing RunInfo tree"<< endl;
2083 // return false;
2084 };
2085
2086 if(CAL1 && !CAL1__ok){
2087 cout << "File: "<< f->GetName() <<" discarded ---- Missing CaloLevel1 branch"<< endl;
2088 return false;
2089 };
2090 if(CAL2 && !CAL2__ok){
2091 cout << "File: "<< f->GetName() <<" discarded ---- Missing CaloLevel2 branch"<< endl;
2092 return false;
2093 };
2094 if(TRK2 && !TRK2__ok){
2095 cout << "File: "<< f->GetName() <<" discarded ---- Missing TrkLevel2 branch"<< endl;
2096 return false;
2097 };
2098 if(TRK1 && !TRK1__ok){
2099 cout << "File: "<< f->GetName() <<" discarded ---- Missing TrkLevel1 branch"<< endl;
2100 return false;
2101 };
2102 if(TRKh && !TRKh__ok){
2103 cout << "File: "<< f->GetName() <<" discarded ---- Missing TrkHough branch"<< endl;
2104 return false;
2105 };
2106 if(ORB && !ORB__ok){
2107 cout << "File: "<< f->GetName() <<" discarded ---- Missing ORB tree"<< endl;
2108 return false;
2109 };
2110 if(AC && !AC__ok){
2111 cout << "File: "<< f->GetName() <<" discarded ---- Missing AC tree"<< endl;
2112 return false;
2113 };
2114 if(S4 && !S4__ok){
2115 cout << "File: "<< f->GetName() <<" discarded ---- Missing S4 tree"<< endl;
2116 return false;
2117 };
2118 if(TOF && !TOF__ok){
2119 cout << "File: "<< f->GetName() <<" discarded ---- Missing ToF tree"<< endl;
2120 return false;
2121 };
2122
2123 if(ND && !ND__ok){
2124 cout << "File: "<< f->GetName() <<" discarded ---- Missing ND tree"<< endl;
2125 return false;
2126 };
2127 if(TRG && !TRG__ok){
2128 cout << "File: "<< f->GetName() <<" discarded ---- Missing Trigger tree"<< endl;
2129 return false;
2130 };
2131
2132
2133 // lk->Delete();
2134 // delete lk;
2135 f->Close();
2136
2137 // cout<< "CheckLevel2File(TString): detector list --> ";
2138 // if(TRK1)cout<<"TRK1 ";
2139 // if(TRK2)cout<<"TRK2 ";
2140 // if(TRKh)cout<<"TRKH ";
2141 // if(CAL1)cout<<"CAL1 ";
2142 // if(CAL2)cout<<"CAL2 ";
2143 // if(TOF)cout<<"TOF ";
2144 // if(TRG)cout<<"TRG ";
2145 // if(AC)cout<<"AC ";
2146 // if(ND)cout<<"ND ";
2147 // if(S4)cout<<"S4 ";
2148 // if(ORB)cout<<"ORB ";
2149 // cout << endl;
2150
2151 return true;
2152
2153 };
2154
2155
2156 /**
2157 * Create clone-trees
2158 */
2159 void PamLevel2::CreateCloneTrees0( TChain *fChain, TFile *ofile ){
2160
2161 cout << "+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+" <<endl;
2162 cout << "Create clones of PAMELA trees "<<endl;
2163
2164 Int_t i=0;
2165 pam_tree_clone[i] = fChain->GetTree()->CloneTree(0);
2166 TString name = pam_tree_clone[i]->GetName();
2167 name.Append("_clone");
2168 // pam_tree_clone[i]->SetName(name.Data());
2169 cout << pam_tree_clone[i]->GetName() <<endl;
2170 i++;
2171
2172 TList *li = fChain->GetListOfFriends();
2173 TIter next(li);
2174 TFriendElement* T_friend=0;
2175 ofile->cd();
2176 while( (T_friend = (TFriendElement*)next()) ){
2177 // cout<<T_friend->IsA()->GetName()<<" "<<T_friend->GetName()<<hex << T_friend->GetTree() << dec<<endl;
2178 // cout<<T_friend->GetTree()->GetName()<< endl;
2179 pam_tree_clone[i] = T_friend->GetTree()->CloneTree(0);
2180 pam_tree_clone[i]->SetAutoSave(1000000);
2181 name = pam_tree_clone[i]->GetName();
2182 name.Append("_clone");
2183 // pam_tree_clone[i]->SetName(name.Data());
2184 cout << pam_tree_clone[i]->GetName() << endl;
2185 i++;
2186 }
2187
2188 delete li;
2189
2190 cout << "+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+" <<endl;
2191
2192 }
2193
2194 /**
2195 * Create clone-trees
2196 */
2197 void PamLevel2::CreateCloneTrees(TFile *ofile){
2198
2199 ofile->cd();
2200
2201 cout << "+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+" <<endl;
2202 cout << "Create new PAMELA trees "<<endl;
2203
2204
2205 run_tree_clone = new TTree("Run","PAMELA Level2 data from the GL_RUN table ");
2206 run_tree_clone->Branch("RunInfo","GL_RUN",GetPointerTo("RunInfo"));
2207 cout << "Run : branch RunInfo"<<endl;
2208 run_tree_clone->Branch("SoftInfo","SoftInfo",GetPointerTo("SoftInfo"));
2209 cout << "Run : branch SoftInfo"<<endl;
2210
2211
2212
2213 sel_tree_clone = new TTree("SelectionList","List of selected events ");
2214 sel_tree_clone->Branch("RunEntry",&irun,"runentry/I");
2215 sel_tree_clone->Branch("EventEntry",&irunentry,"eventry/I");
2216
2217
2218 Int_t i=0;
2219 if(TRK1||TRK2||TRKh){
2220 pam_tree_clone[i] = new TTree("Tracker","PAMELA tracker level2 data ");
2221 if(TRK1) {
2222 pam_tree_clone[i]->Branch("TrkLevel1","TrkLevel1", GetPointerTo("TrkLevel1"));
2223 pam_tree_clone[i]->BranchRef();
2224 cout << "Tracker : branch TrkLevel1"<<endl;
2225 cout << "CreateCloneTrees " << GetTrkLevel1()<<endl;
2226 };
2227 if(TRK2) {
2228 pam_tree_clone[i]->Branch("TrkLevel2", "TrkLevel2",GetPointerTo("TrkLevel2"));
2229 cout << "Tracker : branch TrkLevel2"<<endl;
2230 };
2231 if(TRKh) {
2232 pam_tree_clone[i]->Branch("TrkHough","TrkHough", GetPointerTo("TrkHough"));
2233 cout << "Tracker : branch TrkHough"<<endl;
2234 };
2235 i++;
2236 }
2237
2238 // Calorimeter
2239 if(CAL1||CAL2){
2240 pam_tree_clone[i] = new TTree("Calorimeter","PAMELA calorimeter level2 data ");
2241 if(CAL1) {
2242 pam_tree_clone[i]->Branch("CaloLevel1", "CaloLevel1", GetPointerTo("CaloLevel1"));
2243 cout << "Calorimeter : branch CaloLevel1"<<endl;
2244 };
2245 if(CAL2) {
2246 pam_tree_clone[i]->Branch("CaloLevel2","CaloLevel2", GetPointerTo("CaloLevel2"));
2247 cout << "Calorimeter : branch CaloLevel2"<<endl;
2248 };
2249 i++;
2250 }
2251
2252 // ToF
2253 if(TOF) {
2254 pam_tree_clone[i] = new TTree("ToF","PAMELA ToF level2 data ");
2255 pam_tree_clone[i]->Branch("ToFLevel2","ToFLevel2", GetPointerTo("ToFLevel2"));
2256 cout << "ToF : branch ToFLevel2"<<endl;
2257 i++;
2258 };
2259 // Trigger
2260 if(TRG) {
2261 pam_tree_clone[i] = new TTree("Trigger","PAMELA trigger level2 data ");
2262 pam_tree_clone[i]->Branch("TrigLevel2","TrigLevel2", GetPointerTo("TrigLevel2"));
2263 cout << "Trigger : branch TrigLevel2"<<endl;
2264 i++;
2265 };
2266 // S4
2267 if(S4) {
2268 pam_tree_clone[i] = new TTree("S4","PAMELA S4 level2 data ");
2269 pam_tree_clone[i]->Branch("S4Level2","S4Level2", GetPointerTo("S4Level2"));
2270 cout << "S4 : branch S4Level2"<<endl;
2271 i++;
2272 };
2273 // Neutron Detector
2274 if(ND) {
2275 pam_tree_clone[i] = new TTree("NeutronD","PAMELA neutron detector level2 data ");
2276 pam_tree_clone[i]->Branch("NDLevel2","NDLevel2", GetPointerTo("NDLevel2"));
2277 cout << "NeutronD : branch NDLevel2"<<endl;
2278 i++;
2279 };
2280 // Anticounters
2281 if(AC) {
2282 pam_tree_clone[i] = new TTree("Anticounter","PAMELA anticounter detector level2 data ");
2283 pam_tree_clone[i]->Branch("AcLevel2","AcLevel2", GetPointerTo("AcLevel2"));
2284 cout << "Anticounter : branch AcLevel2"<<endl;
2285 i++;
2286 };
2287 // OrbitalInfo
2288 if(ORB) {
2289 pam_tree_clone[i] = new TTree("OrbitalInfo","PAMELA oribital info ");
2290 pam_tree_clone[i]->Branch("OrbitalInfo","OrbitalInfo", GetPointerTo("OrbitalInfo"));
2291 cout << "OrbitalInfo : branch OrbitalInfo"<<endl;
2292 i++;
2293 };
2294 cout << "+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+" <<endl;
2295
2296 }
2297
2298
2299 /**
2300 * Fill tree (created with CreateCloneTrees)
2301 *
2302 */
2303 //void PamLevel2::FillNewPamTree(TTree *T){
2304 void PamLevel2::FillCloneTrees(){
2305
2306 // cout << "PamLevel2::FillCloneTrees()" << irunentry << endl;
2307
2308 for(Int_t i=0; i<NCLONES; i++){
2309 if(pam_tree_clone[i])pam_tree_clone[i]->Fill();
2310 }
2311 if(sel_tree_clone)sel_tree_clone->Fill();
2312
2313 }
2314
2315
2316 TTree* PamLevel2::GetCloneTree(TString name){
2317
2318 for(Int_t i=0; i<NCLONES; i++){
2319 if(pam_tree_clone[i]){
2320 TString na = pam_tree_clone[i]->GetName();
2321 if(!name.CompareTo(na))return pam_tree_clone[i];
2322 };
2323 }
2324 if(run_tree_clone){
2325 TString na = run_tree_clone->GetName();
2326 if(!name.CompareTo(na))return run_tree_clone;
2327 }
2328 if(sel_tree_clone){
2329 TString na = sel_tree_clone->GetName();
2330 if(!name.CompareTo(na))return sel_tree_clone;
2331 }
2332 return NULL;
2333
2334 }
2335 void PamLevel2::WriteCloneTrees(){
2336 cout << "+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+" <<endl;
2337 cout << "Write clones of PAMELA trees "<<endl;
2338 cout << run_tree_clone->GetName()<<endl;
2339 run_tree_clone->Write();
2340 cout << sel_tree_clone->GetName()<<endl;
2341 sel_tree_clone->Write();
2342 for(Int_t i=0; i<NCLONES; i++){
2343 if(pam_tree_clone[i]){
2344 cout << pam_tree_clone[i]->GetName()<<endl;
2345 pam_tree_clone[i]->Write();
2346 };
2347 }
2348 cout << "+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+" <<endl;
2349
2350 }
2351
2352 /**
2353 * Method to get level2-trees entry, the corresponding run entry and (if required) the level0 entry.
2354 */
2355 Int_t PamLevel2::GetEntry(Int_t iee){
2356
2357 if(!pam_tree){
2358 cout << " Int_t PamLevel2::GetEntry(Int_t) -- ERROR -- level2 trees not loaded"<<endl;
2359 return 0;
2360 }
2361
2362 Int_t ii=0;
2363 //-------------------------------
2364 ii = iee;
2365 if( !pam_tree->GetEntry(ii) ) return 0;
2366 //-------------------------------
2367
2368 if(!run_tree ){
2369 cout << " Int_t PamLevel2::GetEntry(Int_t) -- ERROR -- run tree not loaded"<<endl;
2370 return 0;
2371 }
2372
2373 ii = iee;
2374 Bool_t UPDATED = UpdateRunInfo(run_tree,ii);
2375 if(SELLI==0)irunentry = iee-runfirstentry;
2376 if(UPDATED && run_tree_clone)run_tree_clone->Fill();
2377
2378 // cout << "PamLevel2::GetEntry("<<iee<<") "<<irun<<" "<<runfirstentry<<" "<<irunentry<<endl;
2379
2380 if( TRK0 || CAL0 || TOF0 )GetYodaEntry( );
2381
2382 return 1;
2383
2384 }
2385
2386 /**
2387 * Method to retrieve the level0 tree (YODA tree) that contains the current event.
2388 * Given the run ID (...), if needed it query the DB and load the proper file.
2389 * @return Pointer to the tree
2390 */
2391
2392
2393 TTree* PamLevel2::GetYodaTree( ){
2394
2395 // cout << "TTree* PamLevel2::GetYodaTree( )"<<endl;
2396 //===================================
2397 // check if iroot has changed
2398 //===================================
2399 if( irun<0 ){
2400 cout << "PamLevel2::GetYodaTree() -- ERROR "<<endl;
2401 cout << "In order to use this method you have to load the RunInfo tree "<<endl;
2402 cout << "with the method TChain* PamLevel2::GetRunTree(TString, TString)"<<endl;
2403 // cout << " - read the event with PamLevel2::GetEntry(Int_t)"<<endl;
2404 return NULL;
2405 }
2406 Int_t irootnew = run_obj->ID_ROOT_L0;
2407 // cout << "iroot "<<iroot<<endl;
2408 // cout << "irootnew "<<irootnew<<endl;
2409
2410 //===================================
2411 // load the level0 file
2412 // (if not already loaded)
2413 //===================================
2414 if( iroot != irootnew || !l0_tree){
2415 iroot = irootnew;
2416 //===================================
2417 // open the DB connection
2418 // (if not already opened)
2419 //===================================
2420 if(!dbc || (dbc && !dbc->IsConnected())){
2421 cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
2422 cout<<"Connecting to DB"<<endl;
2423 cout<<"HOST "<<host<<endl;
2424 cout<<"USER "<<user<<endl;
2425 cout<<"PSW "<<psw<<endl;
2426 dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
2427 if( !dbc )return NULL;
2428 if( !dbc->IsConnected() )return NULL;
2429 // cout<<"...done"<<endl;
2430 cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
2431 }else{
2432 // cout<<"DB already connected"<<endl;
2433 }
2434 GL_ROOT glroot = GL_ROOT();
2435 if( glroot.Query_GL_ROOT(iroot,dbc) ){
2436 cout << "TTree* PamLevel2::GetYodaTree( ) -- ERROR -- level0 file iroot = "<<iroot<< " does not exists"<<endl;
2437 return NULL;
2438 };
2439 TString filename = glroot.PATH + glroot.NAME;
2440 if(l0_file){
2441 l0_file->Close();
2442 l0_file->Delete();
2443 }
2444 cout << "Opening LEVEL0 file: "<< filename << endl;
2445 FileStat_t t;
2446 if( gSystem->GetPathInfo(filename.Data(),t) ){
2447 cout << " PamLevel2::GetYodaTree() -- ERROR opening file "<<endl;
2448 return NULL;
2449 }
2450 l0_file = new TFile(filename);
2451 if( !l0_file )return NULL;
2452 l0_tree = (TTree*)l0_file->Get("Physics");
2453 if(!h0_obj)h0_obj = new EventHeader();
2454 l0_tree->SetBranchAddress("Header" ,&h0_obj);
2455 //---------------------------------------------------
2456 // TRACKER:
2457 if(TRK0){
2458 if(!trk0_obj){
2459 trk0_obj = new TrkLevel0();
2460 trk0_obj->Set();
2461 };
2462 l0_tree->SetBranchAddress("Tracker" ,trk0_obj->GetPointerToTrackerEvent());
2463 TrkParams::SetCalib(run_obj,dbc);
2464 }
2465 //---------------------------------------------------
2466 // CALORIMETER:
2467 if(CAL0){
2468 cout << "PamLevel2::GetYodaTree() --- level0 calorimeter not implemented "<<endl;
2469 }
2470 //---------------------------------------------------
2471 // TOF:
2472 if(TOF0){
2473 cout << "PamLevel2::GetYodaTree() --- level0 TOF not implemented "<<endl;
2474 }
2475
2476 };
2477
2478 // cout << l0_tree << endl;
2479
2480 return l0_tree;
2481
2482 }
2483
2484 /**
2485 * Method to retrieve the level0 tree (YODA tree) that contains the current event.
2486 */
2487 Int_t PamLevel2::GetYodaEntry(){
2488
2489 // cout << "Int_t PamLevel2::GetYodaEntry()"<<endl;
2490 if(!GetYodaTree())return 0;
2491
2492 // ---------------------------------
2493 // if file is NOT a preselected file
2494 // ---------------------------------
2495 Int_t quellagiusta = irunentry + run_obj->EV_FROM;
2496
2497 if( !GetOrbitalInfo() ){
2498 cout << "Int_t PamLevel2::GetYodaEntry() -- ERROR -- missing OrbitalInfo "<<endl;
2499 return 0;
2500 }
2501
2502 // ---------------------------------------------------------------------
2503 // ATTENTION!!!
2504 // If data are not pre-processed with cleaner, the level0 tree may contain
2505 // spurious nested physics packets.
2506 // The GL_RUN variables EV_FROM, EV_TO and NEVENTS counts also these entries
2507 // while level2 tree DOES NOT!!
2508 // This means that "quellagiusta" in these cases is not correct.
2509 // In order to retrieve the correct level0 event, I implemented a check
2510 // of the OBT and pkt-number. In case of mismatch, the level0 entry number
2511 // is shift forward until when the packets match.
2512 // ---------------------------------------------------------------------
2513 Int_t answer = 0;
2514 Int_t shift =0;
2515 do{
2516 // if(shift>0){
2517 // cout << " level0 <--> level2 mismatch ( irun "<<irun<<" irunentry "<<irunentry<<" shift "<<shift<<" )"<<endl;
2518 // }
2519 answer = GetYodaTree()->GetEntry(quellagiusta+shift);
2520 shift++;
2521 if( !GetEventHeader() ){
2522 cout << "Int_t PamLevel2::GetYodaEntry() -- ERROR -- missing EventHeader "<<endl;
2523 return 0;
2524 }
2525 // if( (quellagiusta+shift) == GetYodaTree()->GetEntries()+1 )cout << ">>> end of level0 tree <<<"<<endl;
2526 }while( ( (UInt_t)(GetOrbitalInfo()->OBT) != (UInt_t)(GetEventHeader()->GetPscuHeader()->GetOrbitalTime()) || GetOrbitalInfo()->pkt_num != (UInt_t)(GetEventHeader()->GetPscuHeader()->GetCounter())) && (quellagiusta+shift) < (UInt_t)(GetYodaTree()->GetEntries()) );
2527
2528 // cout << "LA ENTRY GIUSTA E`: "<<quellagiusta<<" (spero...)"<<endl;
2529 // return GetYodaTree()->GetEntry(quellagiusta);
2530
2531 return answer;
2532
2533 }

  ViewVC Help
Powered by ViewVC 1.1.23