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

Diff of /PamelaLevel2/src/PamLevel2.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by pam-fi, Fri Jun 16 16:43:55 2006 UTC revision 1.5 by pam-fi, Mon Oct 9 08:57:42 2006 UTC
# Line 24  PamTrack::PamTrack(TrkTrack* t, CaloTrkV Line 24  PamTrack::PamTrack(TrkTrack* t, CaloTrkV
24      tof_track  = this->ToFTrkVar::GetToFTrkVar();      tof_track  = this->ToFTrkVar::GetToFTrkVar();
25      if(t) *trk_track  = *t;      if(t) *trk_track  = *t;
26      if(c) *calo_track = *c;      if(c) *calo_track = *c;
27      if(o) *tof_track  = *o;      if(o) *tof_track  = *o;    
28  };  };
29    
30  //--------------------------------------  //--------------------------------------
# Line 35  PamTrack::PamTrack(TrkTrack* t, CaloTrkV Line 35  PamTrack::PamTrack(TrkTrack* t, CaloTrkV
35   * Constructor   * Constructor
36   */   */
37  PamLevel2::PamLevel2(){  PamLevel2::PamLevel2(){
38      trk_obj  = this->TrkLevel2::GetTrkLevel2();          
39      calo_obj = this->CaloLevel2::GetCaloLevel2();      trk_l1_obj  = this->TrkLevel1::GetTrkLevel1();      
40      tof_obj  = this->ToFLevel2::GetToFLevel2();          trk_obj     = this->TrkLevel2::GetTrkLevel2();
41      trig_obj = this->TrigLevel2::GetTrigLevel2();          calo_obj    = this->CaloLevel2::GetCaloLevel2();
42      s4_obj   = this->S4Level2::GetS4Level2();      tof_obj     = this->ToFLevel2::GetToFLevel2();
43      nd_obj   = this->NDLevel2::GetNDLevel2();      trig_obj    = this->TrigLevel2::GetTrigLevel2();
44      ac_obj   = this->AcLevel2::GetAcLevel2();      s4_obj      = this->S4Level2::GetS4Level2();
45        nd_obj      = this->NDLevel2::GetNDLevel2();
46        ac_obj      = this->AcLevel2::GetAcLevel2();
47            orb_obj     = this->OrbitalInfo::GetOrbitalInfo();
48    
49            run_obj     = new GL_RUN();
50            
51            sorted_tracks = new TRefArray();
52    
53            CAL = true;
54            TRK = true;
55            TRG = true;
56            TOF = true;
57            S4  = true;
58            ND  = true;
59            AC  = true;
60            ORB = true;
61    
62            TRK_L1 = false;
63    
64            Tout  = NULL;
65    };
66    /**
67     * Destructor
68     */
69    PamLevel2::~PamLevel2(){
70                    
71            TrkLevel1::Clear();
72            
73            TrkLevel2::Clear();
74            CaloLevel2::Clear();
75            ToFLevel2::Clear();
76            TrigLevel2::Clear();
77            S4Level2::Clear();
78            NDLevel2::Clear();
79            AcLevel2::Clear();
80            OrbitalInfo::Clear();
81            
82            delete run_obj;
83            
84    //      delete sorted_tracks;
85            sorted_tracks->Delete(); // clean the reference array
86            
87            if(Tout)Tout->Delete(); // delete loaded tree from memory
88            
89    };
90    /**
91     * Clear the event
92     */
93    void PamLevel2::Clear(){
94            
95            TrkLevel1::Clear();
96            
97            TrkLevel2::Clear();
98            CaloLevel2::Clear();
99            ToFLevel2::Clear();
100            TrigLevel2::Clear();
101            S4Level2::Clear();
102            NDLevel2::Clear();
103            AcLevel2::Clear();
104            OrbitalInfo::Clear();
105            
106            sorted_tracks->Delete(); // clean the reference array
107            
108  };  };
109    
110    
111    //--------------------------------------
112    //
113    //
114    //--------------------------------------
115    /**
116     * Retrieves the calorimeter track matching the seqno-th tracker stored track.
117     * (If seqno = -1 retrieves the self-trigger calorimeter track)
118     */
119     CaloTrkVar *PamLevel2::GetCaloStoredTrack(int seqno){
120            
121             if( CaloLevel2::ntrk()==0 ){
122                     cout << "PamLevel2::GetCaloStoredTrack(int) : requested tracker SeqNo "<< seqno <<" but no Calorimeter tracks are stored"<<endl;
123                     return NULL;
124             };
125            
126             CaloTrkVar *c = 0;
127             Int_t it_calo=0;
128            
129             do{
130                     c = CaloLevel2::GetCaloTrkVar(it_calo);
131                     it_calo++;
132             } while( seqno != c->trkseqno && it_calo < CaloLevel2::ntrk());        
133            
134             if(seqno != c->trkseqno){
135                     c = 0;
136                     if(seqno!=-1)cout << "PamLevel2::GetCaloStoredTrack(int) : requested tracker SeqNo "<< seqno <<" does not match Calorimeter stored tracks"<<endl;
137             };
138             return c;
139    
140     };
141    //--------------------------------------
142     //
143     //
144    //--------------------------------------
145    /**
146      * Retrieves the ToF track matching the seqno-th tracker stored track.
147      * (If seqno = -1 retrieves the tracker-independent tof track)
148     */
149     ToFTrkVar *PamLevel2::GetToFStoredTrack(int seqno){
150            
151             if( ToFLevel2::ntrk()==0 ){
152                     cout << "PamLevel2::GetToFStoredTrack(int) : requested tracker SeqNo "<< seqno <<" but no ToF tracks are stored"<<endl;
153                     return NULL;
154             };
155            
156             ToFTrkVar *c = 0;
157             Int_t it_tof=0;
158            
159             do{
160                     c = ToFLevel2::GetToFTrkVar(it_tof);
161                     it_tof++;
162             } while( seqno != c->trkseqno && it_tof < ToFLevel2::ntrk());  
163            
164             if(seqno != c->trkseqno){
165                     c = 0;
166                     if(seqno!=-1)cout << "PamLevel2::GetToFStoredTrack(int) : requested tracker SeqNo "<< seqno <<" does not match ToF stored tracks"<<endl;
167             };
168             return c;
169    
170     };
171    
172    //--------------------------------------
173     //
174     //
175    //--------------------------------------
176    /**
177     * Give the pamela track associated to a tracker track, retrieving related calorimeter and tof track information.
178     */
179     PamTrack* PamLevel2::GetPamTrackAlong(TrkTrack* t){
180            
181             CaloTrkVar *c = 0;
182             ToFTrkVar  *o = 0;
183            
184             if(CAL) c = GetCaloStoredTrack(t->GetSeqNo());
185             if(TOF) o = GetToFStoredTrack(t->GetSeqNo());
186            
187    //    if(t && c && o)track = new PamTrack(t,c,o);
188             PamTrack *track = new PamTrack(t,c,o);
189            
190             return track;
191    
192     };
193  //--------------------------------------  //--------------------------------------
194  //  //
195  //  //
# Line 55  PamLevel2::PamLevel2(){ Line 202  PamLevel2::PamLevel2(){
202    
203  PamTrack* PamLevel2::GetStoredTrack(Int_t itrk){  PamTrack* PamLevel2::GetStoredTrack(Int_t itrk){
204            
205      // retrieve itrk-th tracker stored track          PamTrack *track = 0;
206      TrkTrack   *t = 0;  
207      CaloTrkVar *c = 0;          if( itrk >=0 && itrk < TrkLevel2::ntrk() ){
208      ToFTrkVar  *o = 0;                  
209                    TrkTrack *t = TrkLevel2::GetStoredTrack(itrk);
210      if( itrk >=0 && itrk < TrkLevel2::ntrk() ){                  track = GetPamTrackAlong(t);
211          t = TrkLevel2::GetStoredTrack(itrk);              
212          c = CaloLevel2::GetCaloTrkVar(t->GetSeqNo());          }else{
213          o = ToFLevel2::GetToFTrkVar(t->GetSeqNo());                  cout << "PamLevel2::GetStoredTrack(int) : tracker track SeqNo "<< itrk <<" does not exist (GetNTracks() = "<<TrkLevel2::GetNTracks()<<")"<<endl;
214      };          };
215      //  retrieve related ToF-track  
216                return track;
217      // hence create a "PamTrack" object          
     PamTrack *track = 0;  
     if(t && c && o)track = new PamTrack(t,c,o);  
     return track;  
       
218  }  }
219  //--------------------------------------  //--------------------------------------
220  //  //
221  //  //
222  //--------------------------------------  //--------------------------------------
223  /**  /**
224   * Sort physical (tracker) tracks and stores them in a TObjectArray (of TrkTrack objects).   * Sort physical (tracker) tracks and stores them in the TRefArray (of TrkTrack objects) which pointer is  PamLevel2::sorted_tracks.
225   * The total number of physical tracks is given by GetNTracks() and the it-th physical track can be retrieved by means of the method GetTrack(int it).   * @param how String to set the sorting cryterium (es: "CAL" or "TRK+CAL+TOF" ecc...).
226   * This method overrides TrkLevel2::GetTracks(), where sorting is done by decreasing number of fit points and increasing chi^2.   * Sorting cryteria:
227   * PamLevel2::GetTracks() keeps the same track order given by TrkLevel2::GetTracks(), but checks image selection by using calorimeter and ToF tracking information.   * TRK: lower chi**2
228     * CAL: lower Y spatial residual on the first calorimeter plane
229     * TOF: bigger numebr of hit PMTs along the track, on S12 S21 S32 (where paddles are along the Y axis).
230     * The default sorting cryterium is "TOF+CAL".
231     *
232     * 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).
233   */   */
234  TClonesArray *PamLevel2::GetTracks(){  void PamLevel2::SortTracks(TString how){
   
     // define new array for sorted tracker tracks  
     TClonesArray *aa = new TClonesArray("TrkTrack");  
     TClonesArray &sorted = *aa;  
235    
236      //Save current Object count
237            Int_t ObjectNumber = TProcessID::GetObjectCount();
238            
239            sorted_tracks->Delete(); //temporaneo???
240            
241      // loop over the tracks sorted by the tracker      // loop over the tracks sorted by the tracker
242      for(Int_t i=0; i < TrkLevel2::GetNTracks(); i++){          Bool_t use_TRK = how.Contains("TRK", TString::kIgnoreCase);
243            Bool_t use_CAL = how.Contains("CAL", TString::kIgnoreCase);
244            Bool_t use_TOF = how.Contains("TOF", TString::kIgnoreCase);
245            
246            if( !CAL &&  use_CAL) use_CAL = false;
247            if( !TOF &&  use_TOF) use_TOF = false;
248            
249            if( !TRK ){
250                    cout << "SortTracks() : without tracker does not work!!! (not yet)" << endl;
251                    return;
252            };
253            
254            for(Int_t i=0; i < TrkLevel2::GetNTracks(); i++){
255    
256          TrkTrack *ts=0;                  TrkTrack *ts = 0;
257    
258          // get tracker tracks          // get tracker tracks
259          TrkTrack   *tp = TrkLevel2::GetTrack(i);                    //tracker                  TrkTrack   *tp = TrkLevel2::GetTrack(i);                    //tracker
260          CaloTrkVar *cp = CaloLevel2::GetCaloTrkVar(tp->GetSeqNo()); //calorimeter  //              CaloTrkVar *cp = GetCaloStoredTrack(tp->GetSeqNo());
261          ToFTrkVar  *op = ToFLevel2::GetToFTrkVar(tp->GetSeqNo());   //tof  //              ToFTrkVar  *op = GetToFStoredTrack(tp->GetSeqNo());
262                    CaloTrkVar *cp = 0;
263                    ToFTrkVar  *op = 0;
264    
265          // if track has an image, check image selection          // if track has an image, check image selection
266          if(tp->HasImage()){                  if(tp->HasImage()){
267              TrkTrack   *ti = TrkLevel2::GetTrackImage(i);              //tracker (image)                          
268              CaloTrkVar *ci = CaloLevel2::GetCaloTrkVar(ti->GetSeqNo());//calorimeter (image)                          TrkTrack   *ti = TrkLevel2::GetTrackImage(i);              //tracker (image)
269              ToFTrkVar  *oi = ToFLevel2::GetToFTrkVar(ti->GetSeqNo());  //tof (image)  //                      CaloTrkVar *ci = GetCaloStoredTrack(ti->GetSeqNo());
270    //                      ToFTrkVar  *oi = GetToFStoredTrack(ti->GetSeqNo());
271                            CaloTrkVar *ci = 0;
272                            ToFTrkVar  *oi = 0;
273    
274              //assign starting scores              //assign starting scores
275              Int_t tp_score = 1;                          Int_t tp_score = 0;  //main track sorted by the tracker
276              Int_t ti_score = 0;                          Int_t ti_score = 0;  //image track
277                                                    
278              // ------------------------              // ------------------------
279              // calorimeter check              // calorimeter check
280              // ------------------------              // ------------------------
281              if(                  // check the Y spatial residual on the first calorimeter plane
282                        npcfit[1] > 3   &&  //no. of fit planes on Y view                  // (cut on calorimeter variables from Emiliano)
283  //              varcfit[1] < 50.&&  //fit variance on Y view                          if(
284                        true){                                  use_CAL            &&
285                                    npcfit[1] > 15     &&   //no. of fit planes on Y view
286                  Float_t resy_p = cp->tbar[0][1] - cbar[0][1];if(resy_p < 0)resy_p= - resy_p;                                  varcfit[1] < 1000. &&  //fit variance on Y view
287                  Float_t resy_i = ci->tbar[0][1] - cbar[0][1];if(resy_i < 0)resy_i= - resy_i;                                  true){
288    
289                  if(resy_p <= resy_i) tp_score++;                                  cp = GetCaloStoredTrack(tp->GetSeqNo());
290                  else                 ti_score++;                                  ci = GetCaloStoredTrack(ti->GetSeqNo());
291                        };                                  
292                                    Float_t resy_p = cp->tbar[0][1] - cbar[0][1]; if(resy_p < 0)resy_p= - resy_p;
293                                    Float_t resy_i = ci->tbar[0][1] - cbar[0][1]; if(resy_i < 0)resy_i= - resy_i;
294    
295                                    if(resy_p <= resy_i) tp_score++;
296                                    else                 ti_score++;
297                            };
298              // ------------------------              // ------------------------
299              // TOF check              // TOF check
300              // ------------------------                  // ------------------------    
301                    // check the number of hit pmts along the track
302                    // on S12 S21 and S32, where paddles are parallel to Y axis
303                            if( use_TOF ){
304                            
305                                    Int_t nphit_p =0;
306                                    Int_t nphit_i =0;
307                                            
308                                    op = GetToFStoredTrack(tp->GetSeqNo());
309                                    oi = GetToFStoredTrack(ti->GetSeqNo());
310                                    
311    /*                              cout << "track: npmtadc "<< op->npmtadc << endl;
312                                    cout << "track: npmttdc "<< op->npmttdc << endl;
313                                    cout << "image: npmtadc "<< oi->npmtadc << endl;
314                                    cout << "image: npmttdc "<< oi->npmttdc << endl;*/
315                                    
316                                    for (Int_t ih=0; ih < op->npmtadc; ih++){
317                                            Int_t pl = GetPlaneIndex( (op->pmtadc).At(ih) );
318                                            if(pl == 1 || pl == 2 || pl == 5)nphit_p++;
319                                    };
320                                                            
321                                    for (Int_t ih=0; ih < oi->npmtadc; ih++){
322                                            Int_t pl = GetPlaneIndex( (oi->pmtadc).At(ih) );
323                                            if(pl == 1 || pl == 2 || pl == 5)nphit_i++;    
324                                    };
325                                    
326                                    if(
327                                            use_TOF            &&
328                                            (nphit_p+nphit_i) !=0 &&        
329                                            true){
330                                            
331                                            if( nphit_p >= nphit_i) tp_score++;
332                                            else                                              ti_score++;
333                                    };
334                            };
335                            if(tp_score == ti_score) use_TRK = true;
336                    // ------------------------
337                // tracker check
338                // ------------------------
339                    // chi**2 difference is not always large enough to distinguish among
340                    // the real track and its image.
341                    // Tracker check will be applied always when calorimeter and tof information is ambiguous.
342                            if(use_TRK){
343                                    if(      tp->chi2 > 0 && tp->chi2 < ti->chi2 ) tp_score++ ;
344                                    else if( ti->chi2 > 0 && ti->chi2 < tp->chi2 ) ti_score++ ;
345                            };
346    
347              // ------------------------              // ------------------------
348              // the winner is....              // the winner is....
349              // ------------------------                  // ------------------------    
350                        if(tp_score > ti_score) ts = tp;//the track sorted by the tracker!!                          if      (tp_score > ti_score) ts = tp;//the track sorted by the tracker!!
351                        else                    ts = ti;//its image!!                          else if (tp_score < ti_score) ts = ti;//its image!!
352                            else {
353          }else{                                  ts = tp;
354              ts = tp;  //                              cout << "Warning - track image ambiguity not solved" << endl;
355    //                              cout << ts->GetNtot() << " "<< ts->chi2 << " " << npcfit[1] << " "<< nphit_p << endl;
356                            };
357    
358                    }else{
359                            ts = tp;
360                    };
361                    
362    //              cout <<" SortTracks() "<<i<<" -- "<<ts<<endl;
363                    sorted_tracks->Add(ts);//save the track in the sorted array
364    //              cout << "SortTracks:: sorted_tracks->Add(it) "<<i<<" "<<ts<<endl;
365                    
366          };          };
367              //Restore Object count
368          new(sorted[i]) TrkTrack(*ts); //save the track in the sorted array    //To save space in the table keeping track of all referenced objects
369      };    //we assume that our events do not address each other. We reset the
370      //object count to what it was at the beginning of the event.
371            TProcessID::SetObjectCount(ObjectNumber);
372    
     return aa;  
373  };  };
374  //--------------------------------------  //--------------------------------------
375  //  //
376  //  //
377  //--------------------------------------  //--------------------------------------
378  /**  /**
379     * This method overrides TrkLevel2::GetTracks(), where sorting is done by decreasing number of fit points and increasing chi^2.
380     * PamLevel2::GetTracks() keeps the same track order given by TrkLevel2::GetTracks(), but checks image selection by using calorimeter and ToF tracking information.
381     */
382     TRefArray *PamLevel2::GetTracks(){
383             //
384    //      SortTracks("+CAL+TOF");
385             SortTracks("+CAL+TRK");//TEMP!!!!!!!!!!!!!
386            //
387            return sorted_tracks;
388     };
389    //--------------------------------------
390     //
391     //
392    //--------------------------------------
393    /**
394   * Retrieves the it-th Pamela "physical" track.   * Retrieves the it-th Pamela "physical" track.
395   * It override TrkLevel2::GetTrack(int it).   * It override TrkLevel2::GetTrack(int it).
396   * @param it Track number, ranging from 0 to GetNTracks().   * @param it Track number, ranging from 0 to GetNTracks().
397   */   */
398  PamTrack *PamLevel2::GetTrack(int it){  PamTrack *PamLevel2::GetTrack(int it){
399            
400    //  *-*-*-*-*-*-*
401    //      SortTracks("+CAL+TOF");
402            SortTracks("+CAL+TRK");//TEMP!!!!!!!!!!!!!
403    //  *-*-*-*-*-*-*
404    
405      TClonesArray *aa = this->GetTracks();          PamTrack *track = 0;
406      TClonesArray &sorted = *aa;          
407            if( it >=0 && it < TrkLevel2::GetNTracks() ){
408      TrkTrack   *t = 0;                  TrkTrack   *t = (TrkTrack*)sorted_tracks->At(it);
409      CaloTrkVar *c = 0;  //              cout << "GetTrack(int it):: sorted_tracks->At(it) "<<it<<" "<<t<<endl;
410      ToFTrkVar  *o = 0;                  track = GetPamTrackAlong(t);
411            }else{
412      if( it >=0 && it < TrkLevel2::GetNTracks() ){                  cout << "PamLevel2::GetTrack(int) : tracker track SeqNo "<< it <<" does not exist (GetNTracks() = "<<TrkLevel2::GetNTracks()<<")"<<endl;
413          t = (TrkTrack*)sorted[it];          };
414          c = CaloLevel2::GetCaloTrkVar(t->GetSeqNo());          
415          o = ToFLevel2::GetToFTrkVar(t->GetSeqNo());          return track;
     };  
       
     // hence create a "PamTrack" object  
     PamTrack *track = 0;  
     if(t && c && o)track = new PamTrack(t,c,o);  
     return track;  
416    
417  };  };
418    
419  //--------------------------------------  //--------------------------------------
420  //  //
421  //  //
422  //--------------------------------------  //--------------------------------------
423  /**  /**
424   * Retrieves (if present) the image of the it-th Pamela "physical" track, sorted by the method PamLevel2::GetTracks().   * Retrieves (if present) the image of the it-th Pamela "physical" track, sorted by the method PamLevel2::SortTracks().
425   * @param it Track number, ranging from 0 to GetNTracks().   * @param it Track number, ranging from 0 to GetNTracks().
426   */   */
427  PamTrack *PamLevel2::GetTrackImage(int it){  PamTrack *PamLevel2::GetTrackImage(int it){
428    
429      TClonesArray *aa = this->GetTracks();  //      SortTracks("+CAL+TOF");
430      TClonesArray &sorted = *aa;          SortTracks("+CAL+TRK");//TEMP!!!!!!!!!!!!!
431            
432            PamTrack *image = 0;
433    
434      TrkTrack   *t = 0;          if( it >=0 && it < TrkLevel2::GetNTracks() ){
435      CaloTrkVar *c = 0;                  TrkTrack *temp = (TrkTrack*)sorted_tracks->At(it);
436      ToFTrkVar  *o = 0;                  if( temp->HasImage() ){
437                            TrkTrack   *t = TrkLevel2::GetStoredTrack(temp->GetImageSeqNo());
438      if( it >=0 && it < TrkLevel2::GetNTracks() ){                          image = GetPamTrackAlong(t);
439          TrkTrack *temp = (TrkTrack*)sorted[it];                  }else{
440          if( temp->HasImage() ){                          cout <<"PamLevel2::GetTrackImage(int) : Track SeqNo "<<it<<" does not have image"<<endl;
441              t = TrkLevel2::GetStoredTrack(temp->GetImageSeqNo());                  };
442              c = CaloLevel2::GetCaloTrkVar(temp->GetImageSeqNo());          }else{
443              o = ToFLevel2::GetToFTrkVar(temp->GetImageSeqNo());                  cout << "PamLevel2::GetTrackImage(int) : Tracker track SeqNo "<< it <<" does not exist (GetNTracks() = "<<TrkLevel2::GetNTracks()<<")"<<endl;
444          };          };
     };  
       
     // hence create a "PamTrack" object  
     PamTrack *image = 0;  
     if(t && c && o)image = new PamTrack(t,c,o);  
     return image;  
445            
446            return image;
447  }  }
448    
449  //--------------------------------------  //--------------------------------------
# Line 209  PamTrack *PamLevel2::GetTrackImage(int i Line 451  PamTrack *PamLevel2::GetTrackImage(int i
451  //  //
452  //--------------------------------------  //--------------------------------------
453  /**  /**
454   * Get the Pamela detector trees and make them friends.   * Get the Pamela detector trees in a single file and make them friends.
455     * @param f TFile pointer
456     * @param detlist String to select trees to be included
457     * @return Pointer to a TTree
458   */   */
459  TTree *PamLevel2::LoadPamTrees(TFile *f){  TTree *PamLevel2::GetPamTree(TFile *f, TString detlist="+ALL"){
460        
461      TTree *Tout =0;  //      cout << "WARNING!!! -- obsolete method -- \n";
462        //      cout << "better use TChain *PamLevel2::GetPamTree(TList*, TString) \n";
463      // Tracker          
464            TTree *Trout =0;
465            
466            SetWhichTrees(detlist);
467    // Tracker
468      TTree *T = (TTree*)f->Get("Tracker");      TTree *T = (TTree*)f->Get("Tracker");
469      if(T) {      if(T && TRK) {
470          T->SetBranchAddress("TrkLevel2", GetPointerToTrk());                  if(TRK_L1){
471          cout << "Tracker      : set branch address TrkLevel2"<<endl;                          T->SetBranchAddress("TrkLevel1", GetPointerToTrk(1));
472          if(!Tout)Tout=T;                          cout << "Tracker      : set branch address TrkLevel1"<<endl;
473                    };
474                    T->SetBranchAddress("TrkLevel2", GetPointerToTrk(2));
475                    cout << "Tracker      : set branch address TrkLevel2"<<endl;
476                    Trout=T;
477      }else{      }else{
478          cout << "Tracker      : missing tree"<<endl;          cout << "Tracker      : missing tree"<<endl;
479      };      };
480      // Calorimeter      // Calorimeter
481      TTree *C = (TTree*)f->Get("Calorimeter");      TTree *C = (TTree*)f->Get("Calorimeter");
482      if(C) {      if(C && CAL) {
483          C->SetBranchAddress("CaloLevel2", GetPointerToCalo());          C->SetBranchAddress("CaloLevel2", GetPointerToCalo());
484          cout << "Calorimeter  : set branch address CaloLevel2"<<endl;          cout << "Calorimeter  : set branch address CaloLevel2"<<endl;
485          if(!Tout)Tout=C;          if(!Trout)Trout=C;
486          else Tout->AddFriend(C);          else Trout->AddFriend(C);
487      }else{      }else{
488          cout << "Calorimeter  : missing tree"<<endl;          cout << "Calorimeter  : missing tree"<<endl;
489      };      };
490      // ToF          // ToF    
491      TTree *O = (TTree*)f->Get("ToF");      TTree *O = (TTree*)f->Get("ToF");
492      if(O) {      if(O && TOF) {
493          O->SetBranchAddress("ToFLevel2", GetPointerToToF());          O->SetBranchAddress("ToFLevel2", GetPointerToToF());
494          cout << "ToF          : set branch address ToFLevel2"<<endl;          cout << "ToF          : set branch address ToFLevel2"<<endl;
495          if(!Tout)Tout=O;          if(!Trout)Trout=O;
496          else Tout->AddFriend(O);          else Trout->AddFriend(O);
497      }else{      }else{
498          cout << "ToF         : missing tree"<<endl;          cout << "ToF         : missing tree"<<endl;
499      };      };
500      // Trigger      // Trigger
501      TTree *R = (TTree*)f->Get("Trigger");      TTree *R = (TTree*)f->Get("Trigger");
502      if(R) {      if(R && TRG) {
503          R->SetBranchAddress("TrigLevel2", GetPointerToTrig());          R->SetBranchAddress("TrigLevel2", GetPointerToTrig());
504          cout << "Trigger      : set branch address TrigLevel2"<<endl;          cout << "Trigger      : set branch address TrigLevel2"<<endl;
505          if(!Tout)Tout=O;          if(!Trout)Trout=O;
506          else Tout->AddFriend(R);          else Trout->AddFriend(R);
507      }else{      }else{
508          cout << "Trigger      : missing tree"<<endl;          cout << "Trigger      : missing tree"<<endl;
509      };      };
510      // S4      // S4
511      TTree *S = (TTree*)f->Get("S4");      TTree *S = (TTree*)f->Get("S4");
512      if(S) {      if(S && S4) {
513          S->SetBranchAddress("S4Level2", GetPointerToS4());          S->SetBranchAddress("S4Level2", GetPointerToS4());
514          cout << "S4           : set branch address S4Level2"<<endl;          cout << "S4           : set branch address S4Level2"<<endl;
515          if(!Tout)Tout=O;          if(!Trout)Trout=O;
516          else Tout->AddFriend(S);          else Trout->AddFriend(S);
517      }else{      }else{
518          cout << "S4           : missing tree"<<endl;          cout << "S4           : missing tree"<<endl;
519      };      };
520      // Neutron Detector      // Neutron Detector
521      TTree *N = (TTree*)f->Get("NeutronD");      TTree *N = (TTree*)f->Get("NeutronD");
522      if(N) {      if(N && ND) {
523          N->SetBranchAddress("NDLevel2", GetPointerToND());          N->SetBranchAddress("NDLevel2", GetPointerToND());
524          cout << "NeutronD     : set branch address NDLevel2"<<endl;          cout << "NeutronD     : set branch address NDLevel2"<<endl;
525          if(!Tout)Tout=O;          if(!Trout)Trout=O;
526          else Tout->AddFriend(N);          else Trout->AddFriend(N);
527      }else{      }else{
528          cout << "NeutronD     : missing tree"<<endl;          cout << "NeutronD     : missing tree"<<endl;
529      };      };
530      // Anticounters      // Anticounters
531      TTree *A = (TTree*)f->Get("Anticounter");      TTree *A = (TTree*)f->Get("Anticounter");
532      if(A) {      if(A && AC) {
533          A->SetBranchAddress("AcLevel2", GetPointerToAc());          A->SetBranchAddress("AcLevel2", GetPointerToAc());
534          cout << "Anticounter  : set branch address AcLevel2"<<endl;          cout << "Anticounter  : set branch address AcLevel2"<<endl;
535          if(!Tout)Tout=O;          if(!Trout)Trout=O;
536          else Tout->AddFriend(A);          else Trout->AddFriend(A);
537      }else{      }else{
538          cout << "Anticounter  : missing tree"<<endl;          cout << "Anticounter  : missing tree"<<endl;
539      };      };
540        // Orbital Info
541            TTree *B = (TTree*)f->Get("OrbitalInfo");
542            if(B && ORB) {
543                    B->SetBranchAddress("OrbitalInfo", GetPointerToOrb());
544                    cout << "OrbitalInfo  : set branch address OrbitalInfo"<<endl;
545                    if(!Trout)Trout=O;
546                    else Trout->AddFriend(B);
547            }else{
548                    cout << "OrbitalInfo  : missing tree"<<endl;
549            };
550            
551      return Tout;          cout<<endl<<" Number of entries: "<<Trout->GetEntries()<<endl<<endl;
552            
553            return Trout;
554            
555  }  }
556    //--------------------------------------
557    //
558    //
559    //--------------------------------------
560    /**
561     * Get list of Level2 files.
562     * @param ddir Level2 data directory.
563     * @param flisttxt Name of txt file containing file list.
564     * @return Pointer to a TList of TSystemFiles
565     * If no input file list is given , all the Level2 files inside the directory are processed.
566     */
567    TList*  PamLevel2::GetListOfLevel2Files(TString ddir, TString flisttxt = ""){
568            
569            TString wdir = gSystem->WorkingDirectory();    
570            
571            if(ddir=="")ddir = wdir;
572    //      TSystemDirectory *datadir = new TSystemDirectory(gSystem->BaseName(ddir),ddir);
573            cout << "Level2 data directory : "<<  ddir << endl;
574                    
575            TList *contents  = new TList; // create output list
576            contents->SetOwner();
577            
578            char *fullpath;
579                    
580            // if no input file list is given:      
581            if ( flisttxt != "" ){
582                                    
583                    if( !gSystem->IsFileInIncludePath(flisttxt,&fullpath) )return 0;
584                    
585    //              flisttxt = gSystem->ConcatFileName(gSystem->DirName(flisttxt),gSystem->BaseName(flisttxt));
586                    flisttxt = fullpath;
587                    
588                    if( !gSystem->ChangeDirectory(ddir) )return 0;
589            
590                    cout <<"Input file list : " << flisttxt <<endl;
591                    ifstream in;
592                    in.open(flisttxt, ios::in); //open input file list
593                    while (1) {
594                            TString file;
595                            in >> file;
596                            if (!in.good()) break;
597                            if( gSystem->IsFileInIncludePath(file,&fullpath) ){
598    //                              contents->Add(new TSystemDirectory(fullpath,ddir)); // add file to the list
599    //                              contents->Add(new TSystemFile(fullpath,ddir)); // add file to the list
600                                    contents->Add(new TSystemFile(fullpath,gSystem->DirName(fullpath)));// add file to the list
601                            }else{
602                                    cout << "warning! --- File "<<file<<" does not exists"<< endl;
603                            };
604                    };
605                    in.close();
606                    
607            }else{
608            
609                    cout << "No input file list given."<<endl;
610                    cout << "Check for existing root files."<<endl;
611    //              cout << "Warking directory: "<< gSystem->WorkingDirectory()<< endl;
612                    
613                    TSystemDirectory *datadir = new TSystemDirectory(gSystem->BaseName(ddir),ddir);
614                    TList *temp = datadir->GetListOfFiles();
615    //              temp->Print();
616    //              cout << "*************************************" << endl;
617                    
618                    TIter next(temp);
619                    TSystemFile *questo = 0;
620                    
621                    
622                    while ( (questo = (TSystemFile*) next()) ) {
623                            TString name =  questo-> GetName();
624                            if( name.EndsWith(".root") ){
625                                    char *fullpath;
626                                    gSystem->IsFileInIncludePath(name,&fullpath);
627                                    contents->Add(new TSystemFile(fullpath,gSystem->DirName(fullpath)));
628                            };
629                    }
630                    delete temp;
631                    delete datadir;
632            
633            };
634            gSystem->ChangeDirectory(wdir); // back to the working directory
635    //      cout << endl << "Selected files:" << endl;
636    //      contents->Print();
637            cout << contents->GetEntries()<<" files selected\n";
638    //      cout << endl;
639    //      cout << "Working directory: "<< gSystem->WorkingDirectory()<< endl;
640            return contents;
641    };
642    //--------------------------------------
643    //
644    //
645    //--------------------------------------
646    /**
647     * Get the Pamela detector chains from a list of files and make them friends.
648     * @param fl Pointer to a TList of TSystemFiles
649     * @param detlist String to select trees to be included
650     * @return Pointer to a TChain
651     */
652    TChain *PamLevel2::GetPamTree(TList *fl, TString detlist="+ALL"){
653    
654    //      TChain *Tout=0;
655            if(Tout)Tout->Delete();
656            Tout = NULL;
657            
658            SetWhichTrees(detlist);
659            
660            TChain *T = 0;  
661            TChain *C = 0;
662            TChain *O = 0;
663            TChain *R = 0;
664            TChain *S = 0;
665            TChain *N = 0;
666            TChain *A = 0;
667            TChain *B = 0;
668            
669            if(TRK) T = new TChain("Tracker");      
670            if(CAL) C = new TChain("Calorimeter");
671            if(TOF) O = new TChain("ToF");
672            if(TRG) R = new TChain("Trigger");
673            if(S4)  S = new TChain("S4");
674            if(ND)  N = new TChain("NeutronD");
675            if(AC)  A = new TChain("Anticounter");
676            if(ORB) B = new TChain("OrbitalInfo");
677            
678            // loop over files and create chains    
679            TIter next(fl);
680            TSystemFile *questo = 0;
681            while ( (questo = (TSystemFile*) next()) ) {
682                    TString name =  questo->GetName();
683    //              cout << "File: "<< name << endl;
684                    if( CheckLevel2File(name) ){
685                            if(TRK) T->Add(name);
686                            if(CAL) C->Add(name);
687                            if(TOF) O->Add(name);
688                            if(TRG) R->Add(name);
689                            if(S4)  S->Add(name);
690                            if(ND)  N->Add(name);
691                            if(AC)  A->Add(name);
692                            if(ORB) B->Add(name);
693                    };
694            }
695                    
696                // Tracker
697            if(TRK) if(!Tout)Tout=T;
698                
699            // Calorimeter
700            if(CAL) {              
701                    if(!Tout)Tout=C;
702                    else Tout->AddFriend("Calorimeter");
703            };
704            
705        // ToF    
706            if(TOF) {
707                    if(!Tout)Tout=O;
708                    else Tout->AddFriend("ToF");
709            };
710        // Trigger
711            if(TRG) {
712                    if(!Tout)Tout=O;
713                    else Tout->AddFriend("Trigger");
714            };
715        // S4
716            if(S4) {
717                    if(!Tout)Tout=O;
718                    else Tout->AddFriend("S4");
719            };
720        // Neutron Detector
721            if(ND) {
722                    if(!Tout)Tout=O;
723                    else Tout->AddFriend("NeutronD");
724            };
725        // Anticounters
726            if(AC) {
727                    if(!Tout)Tout=O;
728                    else Tout->AddFriend("Anticounter");
729            };
730        // OrbitalInfo
731            if(ORB) {
732                    if(!Tout)Tout=O;
733                    else Tout->AddFriend("OrbitalInfo");
734            };
735            
736            cout<<endl<<" Number of entries: "<<Tout->GetEntries()<<endl<<endl;
737            
738            PamLevel2::SetBranchAddress();
739            
740            return Tout;
741    }
742    //--------------------------------------
743    //
744    //
745    //--------------------------------------
746    /**
747     * Set branch addresses for Pamela friend trees
748     */
749    void PamLevel2::SetBranchAddress(){
750        // Tracker
751            if(TRK) {
752                    if(TRK_L1){
753                            Tout->SetBranchAddress("TrkLevel1", GetPointerToTrk(1));
754                            cout << "Tracker      : set branch address TrkLevel1"<<endl;
755                    };
756                    Tout->SetBranchAddress("TrkLevel2", GetPointerToTrk(2));
757                    cout << "Tracker      : set branch address TrkLevel2"<<endl;
758            };
759                
760            // Calorimeter
761            if(CAL) {
762                    Tout->SetBranchAddress("CaloLevel2", GetPointerToCalo());
763                    cout << "Calorimeter  : set branch address CaloLevel2"<<endl;
764            };
765            
766        // ToF    
767            if(TOF) {
768                    Tout->SetBranchAddress("ToFLevel2", GetPointerToToF());
769                    cout << "ToF          : set branch address ToFLevel2"<<endl;
770            };
771        // Trigger
772            if(TRG) {
773                    Tout->SetBranchAddress("TrigLevel2", GetPointerToTrig());
774                    cout << "Trigger      : set branch address TrigLevel2"<<endl;
775            };
776        // S4
777            if(S4) {
778                    Tout->SetBranchAddress("S4Level2", GetPointerToS4());
779                    cout << "S4           : set branch address S4Level2"<<endl;
780            };
781        // Neutron Detector
782            if(ND) {
783                    Tout->SetBranchAddress("NDLevel2", GetPointerToND());
784                    cout << "NeutronD     : set branch address NDLevel2"<<endl;
785            };
786        // Anticounters
787            if(AC) {
788                    Tout->SetBranchAddress("AcLevel2", GetPointerToAc());
789                    cout << "Anticounter  : set branch address AcLevel2"<<endl;
790            };
791        // OrbitalInfo
792            if(ORB) {
793                    Tout->SetBranchAddress("OrbitalInfo", GetPointerToOrb());
794                    cout << "OrbitalInfo  : set branch address OrbitalInfo"<<endl;
795            };
796            
797    }
798    
799    //--------------------------------------
800    //
801    //
802    //--------------------------------------
803    void *PamLevel2::GetPointerTo(const char* c ){
804    //      cout << "objname "<< objname << endl;
805            TString objname = c;
806            if(!objname.CompareTo("TrkLevel1"))return &trk_l1_obj;
807            if(!objname.CompareTo("TrkLevel2"))return &trk_obj;
808            
809            return NULL;
810    };
811    //--------------------------------------
812    //
813    //
814    //--------------------------------------
815    /**
816     * Get the Run tree chain from a list of files.
817     * @param fl Pointer to a TList of TSystemFiles
818     * @return Pointer to a TChain
819     */
820    TChain *PamLevel2::GetRunTree(TList *fl){
821            
822            TChain *R = new TChain("Run");
823    
824            // loop over files and create chains    
825            TIter next(fl);
826            TSystemFile *questo = 0;
827            while ( (questo = (TSystemFile*) next()) ) {
828                    TString name =  questo->GetName();
829    //              cout << "File: "<< name << endl;
830                    if( CheckLevel2File(name) ){
831                            R->Add(name);
832                    };
833            }
834            
835            R->SetBranchAddress("RunInfo", GetPointerToRun());
836            cout << "Run         : set branch address RunInfo"<<endl;
837        
838            return R;
839        
840    }
841    //--------------------------------------
842    //
843    //
844    //--------------------------------------
845    /**
846     * Get the Run tree  from a file.
847     * @param f Pointer to a TFile
848     * @return Pointer to a TTree
849     */
850    TTree *PamLevel2::GetRunTree(TFile *f){
851    
852    
853            TTree *R = (TTree*)f->Get("Run");
854    
855            R->SetBranchAddress("RunInfo", GetPointerToRun());
856            cout << "Run         : set branch address RunInfo"<<endl;
857        
858            return R;
859        
860    }
861    //--------------------------------------
862    //
863    //
864    //--------------------------------------
865    /**
866     * Set which trees should be analysed
867     * @param detlist TString containing the sequence of trees required
868    */
869    void PamLevel2::SetWhichTrees(TString detlist){
870            
871            if(detlist.Contains("+ALL", TString::kIgnoreCase)){
872                    CAL = true;
873                    TRK = true;
874                    TRK_L1 = false;
875                    TRG = true;
876                    TOF = true;
877                    S4  = true;
878                    ND  = true;
879                    AC  = true;
880                    ORB = true;
881            }else if( detlist.Contains("-ALL", TString::kIgnoreCase) ){
882                    CAL = false;
883                    TRK = false;
884                    TRK_L1 = false;
885                    TRG = false;
886                    TOF = false;
887                    S4  = false;
888                    ND  = false;
889                    AC  = false;
890                    ORB = false;
891            };
892            
893            if( detlist.Contains("-CAL", TString::kIgnoreCase) )CAL = false;
894            else if( detlist.Contains("+CAL", TString::kIgnoreCase) )CAL = true;
895            
896            if( detlist.Contains("-TRK", TString::kIgnoreCase) )TRK = false;
897            else if( detlist.Contains("+TRK", TString::kIgnoreCase) )TRK = true;
898            
899            if( detlist.Contains("-TRK1", TString::kIgnoreCase) )TRK_L1 = false;
900            else if( detlist.Contains("+TRK1", TString::kIgnoreCase) )TRK_L1 = true;
901            
902            if( detlist.Contains("-TRG", TString::kIgnoreCase) )TRG = false;
903            else if( detlist.Contains("+TRG", TString::kIgnoreCase) )TRG = true;
904            
905            if( detlist.Contains("-TOF", TString::kIgnoreCase) )TOF = false;
906            else if( detlist.Contains("+TOF", TString::kIgnoreCase) )TOF = true;
907            
908            if( detlist.Contains("-S4",  TString::kIgnoreCase) )S4  = false;
909            else if( detlist.Contains("+S4",  TString::kIgnoreCase) )S4  = true;
910            
911            if( detlist.Contains("-ND",  TString::kIgnoreCase) )ND  = false;
912            else if( detlist.Contains("+ND",  TString::kIgnoreCase) )ND  = true;
913            
914            if( detlist.Contains("-AC",  TString::kIgnoreCase) )AC  = false;
915            else if( detlist.Contains("+AC",  TString::kIgnoreCase) )AC  = true;
916            
917            if( detlist.Contains("-ORB", TString::kIgnoreCase) )ORB = false;
918            else if( detlist.Contains("+ORB", TString::kIgnoreCase) )ORB = true;
919            
920    };
921    //--------------------------------------
922    //
923    //
924    //--------------------------------------
925    /**
926     * Check if a file contains selected Pamela Level2 trees.
927     * @param name File name
928     * @return true if the file is ok.
929     */
930    Bool_t  PamLevel2::CheckLevel2File(TString name){
931            
932            Bool_t CAL__ok = false;
933            Bool_t TRK__ok = false;
934            Bool_t TRK_L1__ok = false;
935            Bool_t TRG__ok = false;
936            Bool_t TOF__ok = false;
937            Bool_t S4__ok  = false;
938            Bool_t ND__ok  = false;
939            Bool_t AC__ok  = false;
940            Bool_t ORB__ok = false;
941            
942            Bool_t RUN__ok = false;
943            
944            TFile *f = new TFile(name.Data());
945            TList *lk = f->GetListOfKeys();
946    //      lk->Print();
947            TIter next(lk);
948            TKey *key =0;
949            while( (key = (TKey*)next()) ){
950    //              cout << key->GetName() << endl;
951                    if( !strcmp(key->GetName(),"Calorimeter") )CAL__ok = true;
952    //              if( !strcmp(key->GetName(),"Tracker"    ) )TRK__ok = true;
953                    if( !strcmp(key->GetName(),"Trigger"    ) )TRG__ok = true;
954                    if( !strcmp(key->GetName(),"ToF"        ) )TOF__ok = true;
955                    if( !strcmp(key->GetName(),"S4"         ) )S4__ok = true;
956                    if( !strcmp(key->GetName(),"NeutronD"   ) )ND__ok = true;
957                    if( !strcmp(key->GetName(),"Anticounter") )AC__ok = true;
958                    if( !strcmp(key->GetName(),"OrbitalInfo") )ORB__ok = true;
959                    if( !strcmp(key->GetName(),"Run"        ) )RUN__ok = true;
960                    
961                    if( !strcmp(key->GetName(),"Tracker"    ) ){
962                            TRK__ok = true;
963                            TTree *T = (TTree*)f->Get("Tracker");
964                            for(Int_t i=0; i<T->GetListOfBranches()->GetEntries(); i++){
965                                    TString name = T->GetListOfBranches()->At(i)->GetName();
966                                    if( !name.CompareTo("TrkLevel1") )TRK_L1__ok=true;
967                            };
968                    };
969    
970            };
971                    
972            lk->Delete();
973            f->Close();
974            
975            Bool_t FLAG = true;
976            if(!RUN__ok) {
977                    cout << "File: "<< f->GetName() <<" discarded ---- Missing RunInfo tree"<< endl;
978                    FLAG = false;
979            };
980            if(CAL && !CAL__ok){
981                    cout << "File: "<< f->GetName() <<" discarded ---- Missing Calorimeter tree"<< endl;
982                    FLAG = false;
983            };
984            if(TRK && !TRK__ok){
985                    cout << "File: "<< f->GetName() <<" discarded ---- Missing Tracker tree"<< endl;
986                    FLAG = false;
987            };
988            if(TRK_L1 && !TRK_L1__ok){
989                    cout << "File: "<< f->GetName() <<" discarded ---- Missing Tracker Level1 Branch"<< endl;
990                    FLAG = false;
991            };
992            if(TRG && !TRG__ok){
993                    cout << "File: "<< f->GetName() <<" discarded ---- Missing Trigger tree"<< endl;
994                    FLAG = false;
995            };
996            if(TOF && !TOF__ok){
997                    cout << "File: "<< f->GetName() <<" discarded ---- Missing ToF tree"<< endl;
998                    FLAG = false;
999            };
1000            if(S4 && !S4__ok){
1001                    cout << "File: "<< f->GetName() <<" discarded ---- Missing S4 tree"<< endl;
1002                    FLAG = false;
1003            };
1004            if(ND && !ND__ok){
1005                    cout << "File: "<< f->GetName() <<" discarded ---- Missing ND tree"<< endl;
1006                    FLAG = false;
1007            };
1008            if(AC && !AC__ok){
1009                    cout << "File: "<< f->GetName() <<" discarded ---- Missing AC tree"<< endl;
1010                    FLAG = false;
1011            };
1012            if(ORB && !ORB__ok){
1013                    cout << "File: "<< f->GetName() <<" discarded ---- Missing ORB tree"<< endl;
1014                    FLAG = false;
1015            };
1016            
1017            return FLAG;
1018            
1019    };
1020    
1021    
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.5
  ViewVC Help
Powered by ViewVC 1.1.23