/[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.4 by pam-fi, Fri Sep 29 10:02:30 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             c = GetCaloStoredTrack(t->GetSeqNo());
185             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            
247            for(Int_t i=0; i < TrkLevel2::GetNTracks(); i++){
248    
249          TrkTrack *ts=0;                  TrkTrack *ts = 0;
250    
251          // get tracker tracks          // get tracker tracks
252          TrkTrack   *tp = TrkLevel2::GetTrack(i);                    //tracker                  TrkTrack   *tp = TrkLevel2::GetTrack(i);                    //tracker
253          CaloTrkVar *cp = CaloLevel2::GetCaloTrkVar(tp->GetSeqNo()); //calorimeter                  CaloTrkVar *cp = GetCaloStoredTrack(tp->GetSeqNo());
254          ToFTrkVar  *op = ToFLevel2::GetToFTrkVar(tp->GetSeqNo());   //tof                  ToFTrkVar  *op = GetToFStoredTrack(tp->GetSeqNo());
255    
256          // if track has an image, check image selection          // if track has an image, check image selection
257          if(tp->HasImage()){                  if(tp->HasImage()){
258              TrkTrack   *ti = TrkLevel2::GetTrackImage(i);              //tracker (image)                          
259              CaloTrkVar *ci = CaloLevel2::GetCaloTrkVar(ti->GetSeqNo());//calorimeter (image)                          TrkTrack   *ti = TrkLevel2::GetTrackImage(i);              //tracker (image)
260              ToFTrkVar  *oi = ToFLevel2::GetToFTrkVar(ti->GetSeqNo());  //tof (image)                          CaloTrkVar *ci = GetCaloStoredTrack(ti->GetSeqNo());
261                            ToFTrkVar  *oi = GetToFStoredTrack(ti->GetSeqNo());
262    
263              //assign starting scores              //assign starting scores
264              Int_t tp_score = 1;                          Int_t tp_score = 0;  //main track sorted by the tracker
265              Int_t ti_score = 0;                          Int_t ti_score = 0;  //image track
266                                                    
267              // ------------------------              // ------------------------
268              // calorimeter check              // calorimeter check
269              // ------------------------              // ------------------------
270              if(                  // check the Y spatial residual on the first calorimeter plane
271                        npcfit[1] > 3   &&  //no. of fit planes on Y view                  // (cut on calorimeter variables from Emiliano)
272  //              varcfit[1] < 50.&&  //fit variance on Y view                          if(
273                        true){                                  use_CAL            &&
274                                    npcfit[1] > 15     &&   //no. of fit planes on Y view
275                  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
276                  Float_t resy_i = ci->tbar[0][1] - cbar[0][1];if(resy_i < 0)resy_i= - resy_i;                                  true){
277    
278                  if(resy_p <= resy_i) tp_score++;                                  Float_t resy_p = cp->tbar[0][1] - cbar[0][1]; if(resy_p < 0)resy_p= - resy_p;
279                  else                 ti_score++;                                  Float_t resy_i = ci->tbar[0][1] - cbar[0][1]; if(resy_i < 0)resy_i= - resy_i;
280                        };  
281                                    if(resy_p <= resy_i) tp_score++;
282                                    else                 ti_score++;
283                            };
284              // ------------------------              // ------------------------
285              // TOF check              // TOF check
286              // ------------------------                  // ------------------------    
287                    // check the number of hit pmts along the track
288                    // on S12 S21 and S32, where paddles are parallel to Y axis
289                            Int_t nphit_p =0;
290                            Int_t nphit_i =0;
291                                    
292                            for (Int_t ih=0; ih < op->npmtadc; ih++){
293                                    Int_t pl = GetPlaneIndex( (op->pmtadc).At(ih) );
294                                    if(pl == 1 || pl == 2 || pl == 5)nphit_p++;
295                            };
296                                                    
297                            for (Int_t ih=0; ih < oi->npmtadc; ih++){
298                                    Int_t pl = GetPlaneIndex( (oi->pmtadc).At(ih) );
299                                    if(pl == 1 || pl == 2 || pl == 5)nphit_i++;    
300                            };
301                            
302                            if(
303                                    use_TOF            &&
304                                    (nphit_p+nphit_i) !=0 &&        
305                                    true){
306    
307                                    if( nphit_p >= nphit_i) tp_score++;
308                                    else                                              ti_score++;
309                            };
310                
311                            if(tp_score == ti_score) use_TRK = true;
312                    // ------------------------
313                // tracker check
314                // ------------------------
315                    // chi**2 difference is not always large enough to distinguish among
316                    // the real track and its image.
317                    // Tracker check will be applied always when calorimeter and tof information is ambiguous.
318                            if(use_TRK){
319                                    if(      tp->chi2 > 0 && tp->chi2 < ti->chi2 ) tp_score++ ;
320                                    else if( ti->chi2 > 0 && ti->chi2 < tp->chi2 ) ti_score++ ;
321                            };
322    
323              // ------------------------              // ------------------------
324              // the winner is....              // the winner is....
325              // ------------------------                  // ------------------------    
326                        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!!
327                        else                    ts = ti;//its image!!                          else if (tp_score < ti_score) ts = ti;//its image!!
328                            else {
329          }else{                                  ts = tp;
330              ts = tp;  //                              cout << "Warning - track image ambiguity not solved" << endl;
331    //                              cout << ts->GetNtot() << " "<< ts->chi2 << " " << npcfit[1] << " "<< nphit_p << endl;
332                            };
333    
334                    }else{
335                            ts = tp;
336                    };
337                    
338    //              cout <<" SortTracks() "<<i<<" -- "<<ts<<endl;
339                    sorted_tracks->Add(ts);//save the track in the sorted array
340    //              cout << "SortTracks:: sorted_tracks->Add(it) "<<i<<" "<<ts<<endl;
341                    
342          };          };
343              //Restore Object count
344          new(sorted[i]) TrkTrack(*ts); //save the track in the sorted array    //To save space in the table keeping track of all referenced objects
345      };    //we assume that our events do not address each other. We reset the
346      //object count to what it was at the beginning of the event.
347            TProcessID::SetObjectCount(ObjectNumber);
348    
     return aa;  
349  };  };
350  //--------------------------------------  //--------------------------------------
351  //  //
352  //  //
353  //--------------------------------------  //--------------------------------------
354  /**  /**
355     * This method overrides TrkLevel2::GetTracks(), where sorting is done by decreasing number of fit points and increasing chi^2.
356     * PamLevel2::GetTracks() keeps the same track order given by TrkLevel2::GetTracks(), but checks image selection by using calorimeter and ToF tracking information.
357     */
358     TRefArray *PamLevel2::GetTracks(){
359             //
360            SortTracks("+CAL+TOF");
361            //
362            return sorted_tracks;
363     };
364    //--------------------------------------
365     //
366     //
367    //--------------------------------------
368    /**
369   * Retrieves the it-th Pamela "physical" track.   * Retrieves the it-th Pamela "physical" track.
370   * It override TrkLevel2::GetTrack(int it).   * It override TrkLevel2::GetTrack(int it).
371   * @param it Track number, ranging from 0 to GetNTracks().   * @param it Track number, ranging from 0 to GetNTracks().
372   */   */
373  PamTrack *PamLevel2::GetTrack(int it){  PamTrack *PamLevel2::GetTrack(int it){
374            
375    //  *-*-*-*-*-*-*
376            SortTracks("+CAL+TOF");
377    //  *-*-*-*-*-*-*
378    
379      TClonesArray *aa = this->GetTracks();          PamTrack *track = 0;
380      TClonesArray &sorted = *aa;          
381            if( it >=0 && it < TrkLevel2::GetNTracks() ){
382      TrkTrack   *t = 0;                  TrkTrack   *t = (TrkTrack*)sorted_tracks->At(it);
383      CaloTrkVar *c = 0;  //              cout << "GetTrack(int it):: sorted_tracks->At(it) "<<it<<" "<<t<<endl;
384      ToFTrkVar  *o = 0;                  track = GetPamTrackAlong(t);
385            }else{
386      if( it >=0 && it < TrkLevel2::GetNTracks() ){                  cout << "PamLevel2::GetTrack(int) : tracker track SeqNo "<< it <<" does not exist (GetNTracks() = "<<TrkLevel2::GetNTracks()<<")"<<endl;
387          t = (TrkTrack*)sorted[it];          };
388          c = CaloLevel2::GetCaloTrkVar(t->GetSeqNo());          
389          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;  
390    
391  };  };
392    
393  //--------------------------------------  //--------------------------------------
394  //  //
395  //  //
396  //--------------------------------------  //--------------------------------------
397  /**  /**
398   * 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().
399   * @param it Track number, ranging from 0 to GetNTracks().   * @param it Track number, ranging from 0 to GetNTracks().
400   */   */
401  PamTrack *PamLevel2::GetTrackImage(int it){  PamTrack *PamLevel2::GetTrackImage(int it){
402    
403      TClonesArray *aa = this->GetTracks();          SortTracks("+CAL+TOF");
404      TClonesArray &sorted = *aa;          
405            PamTrack *image = 0;
406    
407      TrkTrack   *t = 0;          if( it >=0 && it < TrkLevel2::GetNTracks() ){
408      CaloTrkVar *c = 0;                  TrkTrack *temp = (TrkTrack*)sorted_tracks->At(it);
409      ToFTrkVar  *o = 0;                  if( temp->HasImage() ){
410                            TrkTrack   *t = TrkLevel2::GetStoredTrack(temp->GetImageSeqNo());
411      if( it >=0 && it < TrkLevel2::GetNTracks() ){                          image = GetPamTrackAlong(t);
412          TrkTrack *temp = (TrkTrack*)sorted[it];                  }else{
413          if( temp->HasImage() ){                          cout <<"PamLevel2::GetTrackImage(int) : Track SeqNo "<<it<<" does not have image"<<endl;
414              t = TrkLevel2::GetStoredTrack(temp->GetImageSeqNo());                  };
415              c = CaloLevel2::GetCaloTrkVar(temp->GetImageSeqNo());          }else{
416              o = ToFLevel2::GetToFTrkVar(temp->GetImageSeqNo());                  cout << "PamLevel2::GetTrackImage(int) : Tracker track SeqNo "<< it <<" does not exist (GetNTracks() = "<<TrkLevel2::GetNTracks()<<")"<<endl;
417          };          };
     };  
       
     // hence create a "PamTrack" object  
     PamTrack *image = 0;  
     if(t && c && o)image = new PamTrack(t,c,o);  
     return image;  
418            
419            return image;
420  }  }
421    
422  //--------------------------------------  //--------------------------------------
# Line 209  PamTrack *PamLevel2::GetTrackImage(int i Line 424  PamTrack *PamLevel2::GetTrackImage(int i
424  //  //
425  //--------------------------------------  //--------------------------------------
426  /**  /**
427   * Get the Pamela detector trees and make them friends.   * Get the Pamela detector trees in a single file and make them friends.
428     * @param f TFile pointer
429     * @param detlist String to select trees to be included
430     * @return Pointer to a TTree
431   */   */
432  TTree *PamLevel2::LoadPamTrees(TFile *f){  TTree *PamLevel2::GetPamTree(TFile *f, TString detlist="+ALL"){
433        
434      TTree *Tout =0;          cout << "WARNING!!! -- obsolete method -- \n";
435                cout << "better use TChain *PamLevel2::GetPamTree(TList*, TString) \n";
436      // Tracker          
437            TTree *Trout =0;
438            
439            SetWhichTrees(detlist);
440    // Tracker
441      TTree *T = (TTree*)f->Get("Tracker");      TTree *T = (TTree*)f->Get("Tracker");
442      if(T) {      if(T && TRK) {
443          T->SetBranchAddress("TrkLevel2", GetPointerToTrk());                  if(TRK_L1){
444          cout << "Tracker      : set branch address TrkLevel2"<<endl;                          T->SetBranchAddress("TrkLevel1", GetPointerToTrk(1));
445          if(!Tout)Tout=T;                          cout << "Tracker      : set branch address TrkLevel1"<<endl;
446                    };
447                    T->SetBranchAddress("TrkLevel2", GetPointerToTrk(2));
448                    cout << "Tracker      : set branch address TrkLevel2"<<endl;
449      }else{      }else{
450          cout << "Tracker      : missing tree"<<endl;          cout << "Tracker      : missing tree"<<endl;
451      };      };
452      // Calorimeter      // Calorimeter
453      TTree *C = (TTree*)f->Get("Calorimeter");      TTree *C = (TTree*)f->Get("Calorimeter");
454      if(C) {      if(C && CAL) {
455          C->SetBranchAddress("CaloLevel2", GetPointerToCalo());          C->SetBranchAddress("CaloLevel2", GetPointerToCalo());
456          cout << "Calorimeter  : set branch address CaloLevel2"<<endl;          cout << "Calorimeter  : set branch address CaloLevel2"<<endl;
457          if(!Tout)Tout=C;          if(!Trout)Trout=C;
458          else Tout->AddFriend(C);          else Trout->AddFriend(C);
459      }else{      }else{
460          cout << "Calorimeter  : missing tree"<<endl;          cout << "Calorimeter  : missing tree"<<endl;
461      };      };
462      // ToF          // ToF    
463      TTree *O = (TTree*)f->Get("ToF");      TTree *O = (TTree*)f->Get("ToF");
464      if(O) {      if(O && TOF) {
465          O->SetBranchAddress("ToFLevel2", GetPointerToToF());          O->SetBranchAddress("ToFLevel2", GetPointerToToF());
466          cout << "ToF          : set branch address ToFLevel2"<<endl;          cout << "ToF          : set branch address ToFLevel2"<<endl;
467          if(!Tout)Tout=O;          if(!Trout)Trout=O;
468          else Tout->AddFriend(O);          else Trout->AddFriend(O);
469      }else{      }else{
470          cout << "ToF         : missing tree"<<endl;          cout << "ToF         : missing tree"<<endl;
471      };      };
472      // Trigger      // Trigger
473      TTree *R = (TTree*)f->Get("Trigger");      TTree *R = (TTree*)f->Get("Trigger");
474      if(R) {      if(R && TRG) {
475          R->SetBranchAddress("TrigLevel2", GetPointerToTrig());          R->SetBranchAddress("TrigLevel2", GetPointerToTrig());
476          cout << "Trigger      : set branch address TrigLevel2"<<endl;          cout << "Trigger      : set branch address TrigLevel2"<<endl;
477          if(!Tout)Tout=O;          if(!Trout)Trout=O;
478          else Tout->AddFriend(R);          else Trout->AddFriend(R);
479      }else{      }else{
480          cout << "Trigger      : missing tree"<<endl;          cout << "Trigger      : missing tree"<<endl;
481      };      };
482      // S4      // S4
483      TTree *S = (TTree*)f->Get("S4");      TTree *S = (TTree*)f->Get("S4");
484      if(S) {      if(S && S4) {
485          S->SetBranchAddress("S4Level2", GetPointerToS4());          S->SetBranchAddress("S4Level2", GetPointerToS4());
486          cout << "S4           : set branch address S4Level2"<<endl;          cout << "S4           : set branch address S4Level2"<<endl;
487          if(!Tout)Tout=O;          if(!Trout)Trout=O;
488          else Tout->AddFriend(S);          else Trout->AddFriend(S);
489      }else{      }else{
490          cout << "S4           : missing tree"<<endl;          cout << "S4           : missing tree"<<endl;
491      };      };
492      // Neutron Detector      // Neutron Detector
493      TTree *N = (TTree*)f->Get("NeutronD");      TTree *N = (TTree*)f->Get("NeutronD");
494      if(N) {      if(N && ND) {
495          N->SetBranchAddress("NDLevel2", GetPointerToND());          N->SetBranchAddress("NDLevel2", GetPointerToND());
496          cout << "NeutronD     : set branch address NDLevel2"<<endl;          cout << "NeutronD     : set branch address NDLevel2"<<endl;
497          if(!Tout)Tout=O;          if(!Trout)Trout=O;
498          else Tout->AddFriend(N);          else Trout->AddFriend(N);
499      }else{      }else{
500          cout << "NeutronD     : missing tree"<<endl;          cout << "NeutronD     : missing tree"<<endl;
501      };      };
502      // Anticounters      // Anticounters
503      TTree *A = (TTree*)f->Get("Anticounter");      TTree *A = (TTree*)f->Get("Anticounter");
504      if(A) {      if(A && AC) {
505          A->SetBranchAddress("AcLevel2", GetPointerToAc());          A->SetBranchAddress("AcLevel2", GetPointerToAc());
506          cout << "Anticounter  : set branch address AcLevel2"<<endl;          cout << "Anticounter  : set branch address AcLevel2"<<endl;
507          if(!Tout)Tout=O;          if(!Trout)Trout=O;
508          else Tout->AddFriend(A);          else Trout->AddFriend(A);
509      }else{      }else{
510          cout << "Anticounter  : missing tree"<<endl;          cout << "Anticounter  : missing tree"<<endl;
511      };      };
512        // Orbital Info
513            TTree *B = (TTree*)f->Get("OrbitalInfo");
514            if(B && ORB) {
515                    B->SetBranchAddress("OrbitalInfo", GetPointerToOrb());
516                    cout << "OrbitalInfo  : set branch address OrbitalInfo"<<endl;
517                    if(!Trout)Trout=O;
518                    else Trout->AddFriend(B);
519            }else{
520                    cout << "OrbitalInfo  : missing tree"<<endl;
521            };
522        
523        return Trout;
524        
525    }
526    //--------------------------------------
527    //
528    //
529    //--------------------------------------
530    /**
531     * Get all the Pamela detector trees in a single file and make them friends.
532     * @param f TFile pointer
533     * @return Pointer to a TTree
534     */
535    /*TTree *PamLevel2::GetPamTree(TFile *f){
536        
537            
538            TTree *Tout =0;
539            
540            SetWhichTrees("+ALL");
541            
542        // Tracker
543            TTree *T = (TTree*)f->Get("Tracker");
544            if(T && TRK) {
545                    T->SetBranchAddress("TrkLevel2", GetPointerToTrk());
546                    cout << "Tracker      : set branch address TrkLevel2"<<endl;
547                    if(!Tout)Tout=T;
548            }else{
549                    cout << "Tracker      : missing tree"<<endl;
550            };
551        // Calorimeter
552            TTree *C = (TTree*)f->Get("Calorimeter");
553            if(C && CAL) {
554                    C->SetBranchAddress("CaloLevel2", GetPointerToCalo());
555                    cout << "Calorimeter  : set branch address CaloLevel2"<<endl;
556                    if(!Tout)Tout=C;
557                    else Tout->AddFriend(C);
558            }else{
559                    cout << "Calorimeter  : missing tree"<<endl;
560            };
561        // ToF    
562            TTree *O = (TTree*)f->Get("ToF");
563            if(O && TOF) {
564                    O->SetBranchAddress("ToFLevel2", GetPointerToToF());
565                    cout << "ToF          : set branch address ToFLevel2"<<endl;
566                    if(!Tout)Tout=O;
567                    else Tout->AddFriend(O);
568            }else{
569                    cout << "ToF         : missing tree"<<endl;
570            };
571        // Trigger
572            TTree *R = (TTree*)f->Get("Trigger");
573            if(R && TRG) {
574                    R->SetBranchAddress("TrigLevel2", GetPointerToTrig());
575                    cout << "Trigger      : set branch address TrigLevel2"<<endl;
576                    if(!Tout)Tout=O;
577                    else Tout->AddFriend(R);
578            }else{
579                    cout << "Trigger      : missing tree"<<endl;
580            };
581        // S4
582            TTree *S = (TTree*)f->Get("S4");
583            if(S && S4) {
584                    S->SetBranchAddress("S4Level2", GetPointerToS4());
585                    cout << "S4           : set branch address S4Level2"<<endl;
586                    if(!Tout)Tout=O;
587                    else Tout->AddFriend(S);
588            }else{
589                    cout << "S4           : missing tree"<<endl;
590            };
591        // Neutron Detector
592            TTree *N = (TTree*)f->Get("NeutronD");
593            if(N && ND) {
594                    N->SetBranchAddress("NDLevel2", GetPointerToND());
595                    cout << "NeutronD     : set branch address NDLevel2"<<endl;
596                    if(!Tout)Tout=O;
597                    else Tout->AddFriend(N);
598            }else{
599                    cout << "NeutronD     : missing tree"<<endl;
600            };
601        // Anticounters
602            TTree *A = (TTree*)f->Get("Anticounter");
603            if(A && AC) {
604                    A->SetBranchAddress("AcLevel2", GetPointerToAc());
605                    cout << "Anticounter  : set branch address AcLevel2"<<endl;
606                    if(!Tout)Tout=O;
607                    else Tout->AddFriend(A);
608            }else{
609                    cout << "Anticounter  : missing tree"<<endl;
610            };
611        // Orbital Info
612            TTree *B = (TTree*)f->Get("OrbitalInfo");
613            if(B && ORB) {
614                    B->SetBranchAddress("OrbitalInfo", GetPointerToOrb());
615                    cout << "OrbitalInfo  : set branch address OrbitalInfo"<<endl;
616                    if(!Tout)Tout=O;
617                    else Tout->AddFriend(B);
618            }else{
619                    cout << "OrbitalInfo  : missing tree"<<endl;
620            };
621        
622            return Tout;
623        
624    }*/
625    //--------------------------------------
626    //
627    //
628    //--------------------------------------
629    /**
630     * Get list of Level2 files.
631     * @param ddir Level2 data directory.
632     * @param flisttxt Name of txt file containing file list.
633     * @return Pointer to a TList of TSystemFiles
634     * If no input file list is given , all the Level2 files inside the directory are processed.
635     */
636    TList*  PamLevel2::GetListOfLevel2Files(TString ddir, TString flisttxt = ""){
637            
638            TString wdir = gSystem->WorkingDirectory();    
639            
640            if(ddir=="")ddir = wdir;
641    //      TSystemDirectory *datadir = new TSystemDirectory(gSystem->BaseName(ddir),ddir);
642            cout << "Level2 data directory : "<< endl <<  ddir << endl;
643                    
644            TList *contents  = new TList; // create output list
645            contents->SetOwner();
646            
647            char *fullpath;
648                    
649            // if no input file list is given:      
650            if ( flisttxt != "" ){
651                                    
652                    if( !gSystem->IsFileInIncludePath(flisttxt,&fullpath) )return 0;
653                    
654    //              flisttxt = gSystem->ConcatFileName(gSystem->DirName(flisttxt),gSystem->BaseName(flisttxt));
655                    flisttxt = fullpath;
656                    
657                    if( !gSystem->ChangeDirectory(ddir) )return 0;
658            
659                    cout <<"Input file list : "<< endl << flisttxt <<endl;
660                    ifstream in;
661                    in.open(flisttxt, ios::in); //open input file list
662                    while (1) {
663                            TString file;
664                            in >> file;
665                            if (!in.good()) break;
666                            if( gSystem->IsFileInIncludePath(file,&fullpath) ){
667    //                              contents->Add(new TSystemDirectory(fullpath,ddir)); // add file to the list
668    //                              contents->Add(new TSystemFile(fullpath,ddir)); // add file to the list
669                                    contents->Add(new TSystemFile(fullpath,gSystem->DirName(fullpath)));// add file to the list
670                            }else{
671                                    cout << "warning! --- File "<<file<<" does not exists"<< endl;
672                            };
673                    };
674                    in.close();
675                    
676            }else{
677            
678                    cout << "No input file list given."<<endl;
679                    cout << "Check for existing root files."<<endl;
680    //              cout << "Warking directory: "<< gSystem->WorkingDirectory()<< endl;
681                    
682                    TSystemDirectory *datadir = new TSystemDirectory(gSystem->BaseName(ddir),ddir);
683                    TList *temp = datadir->GetListOfFiles();
684    //              temp->Print();
685    //              cout << "*************************************" << endl;
686                    
687                    TIter next(temp);
688                    TSystemFile *questo = 0;
689                    
690                    
691                    while ( (questo = (TSystemFile*) next()) ) {
692                            TString name =  questo-> GetName();
693                            if( name.EndsWith(".root") ){
694                                    char *fullpath;
695                                    gSystem->IsFileInIncludePath(name,&fullpath);
696                                    contents->Add(new TSystemFile(fullpath,gSystem->DirName(fullpath)));
697                            };
698                    }
699                    delete temp;
700                    delete datadir;
701            
702            };
703            gSystem->ChangeDirectory(wdir); // back to the working directory
704            cout << endl << "Selected files:" << endl;
705            contents->Print();
706            cout << endl;
707    //      cout << "Working directory: "<< gSystem->WorkingDirectory()<< endl;
708            return contents;
709    };
710    //--------------------------------------
711    //
712    //
713    //--------------------------------------
714    /**
715     * Get the Pamela detector chains from a list of files and make them friends.
716     * @param fl Pointer to a TList of TSystemFiles
717     * @param detlist String to select trees to be included
718     * @return Pointer to a TChain
719     */
720    TChain *PamLevel2::GetPamTree(TList *fl, TString detlist="+ALL"){
721    
722    //      TChain *Tout=0;
723            if(Tout)Tout->Delete();
724            Tout = NULL;
725            
726            SetWhichTrees(detlist);
727            
728            TChain *T = 0;  
729            TChain *C = 0;
730            TChain *O = 0;
731            TChain *R = 0;
732            TChain *S = 0;
733            TChain *N = 0;
734            TChain *A = 0;
735            TChain *B = 0;
736            
737            if(TRK) T = new TChain("Tracker");      
738            if(CAL) C = new TChain("Calorimeter");
739            if(TOF) O = new TChain("ToF");
740            if(TRG) R = new TChain("Trigger");
741            if(S4)  S = new TChain("S4");
742            if(ND)  N = new TChain("NeutronD");
743            if(AC)  A = new TChain("Anticounter");
744            if(ORB) B = new TChain("OrbitalInfo");
745            
746            // loop over files and create chains    
747            TIter next(fl);
748            TSystemFile *questo = 0;
749            while ( (questo = (TSystemFile*) next()) ) {
750                    TString name =  questo->GetName();
751    //              cout << "File: "<< name << endl;
752                    if( CheckLevel2File(name) ){
753                            if(TRK) T->Add(name);
754                            if(CAL) C->Add(name);
755                            if(TOF) O->Add(name);
756                            if(TRG) R->Add(name);
757                            if(S4)  S->Add(name);
758                            if(ND)  N->Add(name);
759                            if(AC)  A->Add(name);
760                            if(ORB) B->Add(name);
761                    };
762            }
763            
764    /*    // Tracker
765            if(TRK) {
766                    if(TRK_L1){
767                            T->SetBranchAddress("TrkLevel1", GetPointerToTrk(1));
768                            cout << "Tracker      : set branch address TrkLevel1"<<endl;
769                    };
770                    T->SetBranchAddress("TrkLevel2", GetPointerToTrk(2));
771                    cout << "Tracker      : set branch address TrkLevel2"<<endl;
772                    
773                    if(!Tout)Tout=T;
774            };
775                
776            // Calorimeter
777            if(CAL) {
778                    C->SetBranchAddress("CaloLevel2", GetPointerToCalo());
779                    cout << "Calorimeter  : set branch address CaloLevel2"<<endl;
780                    if(!Tout)Tout=C;
781                    else Tout->AddFriend("Calorimeter");
782            };
783            
784        // ToF    
785            if(TOF) {
786                    O->SetBranchAddress("ToFLevel2", GetPointerToToF());
787                    cout << "ToF          : set branch address ToFLevel2"<<endl;
788                    if(!Tout)Tout=O;
789                    else Tout->AddFriend("ToF");
790            };
791        // Trigger
792            if(TRG) {
793                    R->SetBranchAddress("TrigLevel2", GetPointerToTrig());
794                    cout << "Trigger      : set branch address TrigLevel2"<<endl;
795                    if(!Tout)Tout=O;
796                    else Tout->AddFriend("Trigger");
797            };
798        // S4
799            if(S4) {
800                    S->SetBranchAddress("S4Level2", GetPointerToS4());
801                    cout << "S4           : set branch address S4Level2"<<endl;
802                    if(!Tout)Tout=O;
803                    else Tout->AddFriend("S4");
804            };
805        // Neutron Detector
806            if(ND) {
807                    N->SetBranchAddress("NDLevel2", GetPointerToND());
808                    cout << "NeutronD     : set branch address NDLevel2"<<endl;
809                    if(!Tout)Tout=O;
810                    else Tout->AddFriend("NeutronD");
811            };
812        // Anticounters
813            if(AC) {
814                    A->SetBranchAddress("AcLevel2", GetPointerToAc());
815                    cout << "Anticounter  : set branch address AcLevel2"<<endl;
816                    if(!Tout)Tout=O;
817                    else Tout->AddFriend("Anticounter");
818            };
819        // OrbitalInfo
820            if(ORB) {
821                    B->SetBranchAddress("OrbitalInfo", GetPointerToOrb());
822                    cout << "OrbitalInfo  : set branch address OrbitalInfo"<<endl;
823                    if(!Tout)Tout=O;
824                    else Tout->AddFriend("OrbitalInfo");
825            };
826            
827      return Tout;          cout<<endl<<" Number of entries: "<<Tout->GetEntries()<<endl<<endl;*/
828            
829                // Tracker
830            if(TRK) if(!Tout)Tout=T;
831                
832            // Calorimeter
833            if(CAL) {              
834                    if(!Tout)Tout=C;
835                    else Tout->AddFriend("Calorimeter");
836            };
837            
838        // ToF    
839            if(TOF) {
840                    if(!Tout)Tout=O;
841                    else Tout->AddFriend("ToF");
842            };
843        // Trigger
844            if(TRG) {
845                    if(!Tout)Tout=O;
846                    else Tout->AddFriend("Trigger");
847            };
848        // S4
849            if(S4) {
850                    if(!Tout)Tout=O;
851                    else Tout->AddFriend("S4");
852            };
853        // Neutron Detector
854            if(ND) {
855                    if(!Tout)Tout=O;
856                    else Tout->AddFriend("NeutronD");
857            };
858        // Anticounters
859            if(AC) {
860                    if(!Tout)Tout=O;
861                    else Tout->AddFriend("Anticounter");
862            };
863        // OrbitalInfo
864            if(ORB) {
865                    if(!Tout)Tout=O;
866                    else Tout->AddFriend("OrbitalInfo");
867            };
868            
869            cout<<endl<<" Number of entries: "<<Tout->GetEntries()<<endl<<endl;
870            
871            PamLevel2::SetBranchAddress();
872            
873            return Tout;
874    }
875    //--------------------------------------
876    //
877    //
878    //--------------------------------------
879    /**
880     * Set branch addresses for Pamela friend trees
881     */
882    void PamLevel2::SetBranchAddress(){
883        // Tracker
884            if(TRK) {
885                    if(TRK_L1){
886                            Tout->SetBranchAddress("TrkLevel1", GetPointerToTrk(1));
887                            cout << "Tracker      : set branch address TrkLevel1"<<endl;
888                    };
889                    Tout->SetBranchAddress("TrkLevel2", GetPointerToTrk(2));
890                    cout << "Tracker      : set branch address TrkLevel2"<<endl;
891            };
892                
893            // Calorimeter
894            if(CAL) {
895                    Tout->SetBranchAddress("CaloLevel2", GetPointerToCalo());
896                    cout << "Calorimeter  : set branch address CaloLevel2"<<endl;
897            };
898            
899        // ToF    
900            if(TOF) {
901                    Tout->SetBranchAddress("ToFLevel2", GetPointerToToF());
902                    cout << "ToF          : set branch address ToFLevel2"<<endl;
903            };
904        // Trigger
905            if(TRG) {
906                    Tout->SetBranchAddress("TrigLevel2", GetPointerToTrig());
907                    cout << "Trigger      : set branch address TrigLevel2"<<endl;
908            };
909        // S4
910            if(S4) {
911                    Tout->SetBranchAddress("S4Level2", GetPointerToS4());
912                    cout << "S4           : set branch address S4Level2"<<endl;
913            };
914        // Neutron Detector
915            if(ND) {
916                    Tout->SetBranchAddress("NDLevel2", GetPointerToND());
917                    cout << "NeutronD     : set branch address NDLevel2"<<endl;
918            };
919        // Anticounters
920            if(AC) {
921                    Tout->SetBranchAddress("AcLevel2", GetPointerToAc());
922                    cout << "Anticounter  : set branch address AcLevel2"<<endl;
923            };
924        // OrbitalInfo
925            if(ORB) {
926                    Tout->SetBranchAddress("OrbitalInfo", GetPointerToOrb());
927                    cout << "OrbitalInfo  : set branch address OrbitalInfo"<<endl;
928            };
929            
930    }
931    
932    //--------------------------------------
933    //
934    //
935    //--------------------------------------
936    void *PamLevel2::GetPointerTo(const char* c ){
937    //      cout << "objname "<< objname << endl;
938            TString objname = c;
939            if(!objname.CompareTo("TrkLevel1"))return &trk_l1_obj;
940            if(!objname.CompareTo("TrkLevel2"))return &trk_obj;
941            
942            return NULL;
943    };
944    //--------------------------------------
945    //
946    //
947    //--------------------------------------
948    /**
949     * Get the Run tree chain from a list of files.
950     * @param fl Pointer to a TList of TSystemFiles
951     * @return Pointer to a TChain
952     */
953    TChain *PamLevel2::GetRunTree(TList *fl){
954            
955            TChain *R = new TChain("Run");
956    
957            // loop over files and create chains    
958            TIter next(fl);
959            TSystemFile *questo = 0;
960            while ( (questo = (TSystemFile*) next()) ) {
961                    TString name =  questo->GetName();
962    //              cout << "File: "<< name << endl;
963                    if( CheckLevel2File(name) ){
964                            R->Add(name);
965                    };
966            }
967            
968            R->SetBranchAddress("RunInfo", GetPointerToRun());
969            cout << "Run         : set branch address RunInfo"<<endl;
970        
971            return R;
972        
973    }
974    //--------------------------------------
975    //
976    //
977    //--------------------------------------
978    /**
979     * Get the Run tree  from a file.
980     * @param f Pointer to a TFile
981     * @return Pointer to a TTree
982     */
983    TTree *PamLevel2::GetRunTree(TFile *f){
984    
985    
986            TTree *R = (TTree*)f->Get("Run");
987    
988            R->SetBranchAddress("RunInfo", GetPointerToRun());
989            cout << "Run         : set branch address RunInfo"<<endl;
990        
991            return R;
992            
993  }  }
994    //--------------------------------------
995    //
996    //
997    //--------------------------------------
998    /**
999     * Set which trees should be analysed
1000     * @param detlist TString containing the sequence of trees required
1001    */
1002    void PamLevel2::SetWhichTrees(TString detlist){
1003            
1004            if(detlist.Contains("+ALL", TString::kIgnoreCase)){
1005                    CAL = true;
1006                    TRK = true;
1007                    TRK_L1 = false;
1008                    TRG = true;
1009                    TOF = true;
1010                    S4  = true;
1011                    ND  = true;
1012                    AC  = true;
1013                    ORB = true;
1014            }else if( detlist.Contains("-ALL", TString::kIgnoreCase) ){
1015                    CAL = false;
1016                    TRK = false;
1017                    TRK_L1 = false;
1018                    TRG = false;
1019                    TOF = false;
1020                    S4  = false;
1021                    ND  = false;
1022                    AC  = false;
1023                    ORB = false;
1024            };
1025            
1026            if( detlist.Contains("-CAL", TString::kIgnoreCase) )CAL = false;
1027            else if( detlist.Contains("+CAL", TString::kIgnoreCase) )CAL = true;
1028            
1029            if( detlist.Contains("-TRK", TString::kIgnoreCase) )TRK = false;
1030            else if( detlist.Contains("+TRK", TString::kIgnoreCase) )TRK = true;
1031            
1032            if( detlist.Contains("-TRK1", TString::kIgnoreCase) )TRK_L1 = false;
1033            else if( detlist.Contains("+TRK1", TString::kIgnoreCase) )TRK_L1 = true;
1034            
1035            if( detlist.Contains("-TRG", TString::kIgnoreCase) )TRG = false;
1036            else if( detlist.Contains("+TRG", TString::kIgnoreCase) )TRG = true;
1037            
1038            if( detlist.Contains("-TOF", TString::kIgnoreCase) )TOF = false;
1039            else if( detlist.Contains("+TOF", TString::kIgnoreCase) )TOF = true;
1040            
1041            if( detlist.Contains("-S4",  TString::kIgnoreCase) )S4  = false;
1042            else if( detlist.Contains("+S4",  TString::kIgnoreCase) )S4  = true;
1043            
1044            if( detlist.Contains("-ND",  TString::kIgnoreCase) )ND  = false;
1045            else if( detlist.Contains("+ND",  TString::kIgnoreCase) )ND  = true;
1046            
1047            if( detlist.Contains("-AC",  TString::kIgnoreCase) )AC  = false;
1048            else if( detlist.Contains("+AC",  TString::kIgnoreCase) )AC  = true;
1049            
1050            if( detlist.Contains("-ORB", TString::kIgnoreCase) )ORB = false;
1051            else if( detlist.Contains("+ORB", TString::kIgnoreCase) )ORB = true;
1052            
1053    };
1054    //--------------------------------------
1055    //
1056    //
1057    //--------------------------------------
1058    /**
1059     * Check if a file contains selected Pamela Level2 trees.
1060     * @param name File name
1061     * @return true if the file is ok.
1062     */
1063    Bool_t  PamLevel2::CheckLevel2File(TString name){
1064            
1065            Bool_t CAL__ok = false;
1066            Bool_t TRK__ok = false;
1067            Bool_t TRK_L1__ok = false;
1068            Bool_t TRG__ok = false;
1069            Bool_t TOF__ok = false;
1070            Bool_t S4__ok  = false;
1071            Bool_t ND__ok  = false;
1072            Bool_t AC__ok  = false;
1073            Bool_t ORB__ok = false;
1074            
1075            Bool_t RUN__ok = false;
1076            
1077            TFile *f = new TFile(name.Data());
1078            TList *lk = f->GetListOfKeys();
1079    //      lk->Print();
1080            TIter next(lk);
1081            TKey *key =0;
1082            while( (key = (TKey*)next()) ){
1083    //              cout << key->GetName() << endl;
1084                    if( !strcmp(key->GetName(),"Calorimeter") )CAL__ok = true;
1085    //              if( !strcmp(key->GetName(),"Tracker"    ) )TRK__ok = true;
1086                    if( !strcmp(key->GetName(),"Trigger"    ) )TRG__ok = true;
1087                    if( !strcmp(key->GetName(),"ToF"        ) )TOF__ok = true;
1088                    if( !strcmp(key->GetName(),"S4"         ) )S4__ok = true;
1089                    if( !strcmp(key->GetName(),"NeutronD"   ) )ND__ok = true;
1090                    if( !strcmp(key->GetName(),"Anticounter") )AC__ok = true;
1091                    if( !strcmp(key->GetName(),"OrbitalInfo") )ORB__ok = true;
1092                    if( !strcmp(key->GetName(),"Run"        ) )RUN__ok = true;
1093                    
1094                    if( !strcmp(key->GetName(),"Tracker"    ) ){
1095                            TRK__ok = true;
1096                            TTree *T = (TTree*)f->Get("Tracker");
1097                            for(Int_t i=0; i<T->GetListOfBranches()->GetEntries(); i++){
1098                                    TString name = T->GetListOfBranches()->At(i)->GetName();
1099                                    if( !name.CompareTo("TrkLevel1") )TRK_L1__ok=true;
1100                            };
1101                    };
1102    
1103            };
1104                    
1105            lk->Delete();
1106            f->Close();
1107            
1108            Bool_t FLAG = true;
1109            if(!RUN__ok) {
1110                    cout << "File: "<< f->GetName() <<" discarded ---- Missing RunInfo tree"<< endl;
1111                    FLAG = false;
1112            };
1113            if(CAL && !CAL__ok){
1114                    cout << "File: "<< f->GetName() <<" discarded ---- Missing Calorimeter tree"<< endl;
1115                    FLAG = false;
1116            };
1117            if(TRK && !TRK__ok){
1118                    cout << "File: "<< f->GetName() <<" discarded ---- Missing Tracker tree"<< endl;
1119                    FLAG = false;
1120            };
1121            if(TRK_L1 && !TRK_L1__ok){
1122                    cout << "File: "<< f->GetName() <<" discarded ---- Missing Tracker Level1 Branch"<< endl;
1123                    FLAG = false;
1124            };
1125            if(TRG && !TRG__ok){
1126                    cout << "File: "<< f->GetName() <<" discarded ---- Missing Trigger tree"<< endl;
1127                    FLAG = false;
1128            };
1129            if(TOF && !TOF__ok){
1130                    cout << "File: "<< f->GetName() <<" discarded ---- Missing ToF tree"<< endl;
1131                    FLAG = false;
1132            };
1133            if(S4 && !S4__ok){
1134                    cout << "File: "<< f->GetName() <<" discarded ---- Missing S4 tree"<< endl;
1135                    FLAG = false;
1136            };
1137            if(ND && !ND__ok){
1138                    cout << "File: "<< f->GetName() <<" discarded ---- Missing ND tree"<< endl;
1139                    FLAG = false;
1140            };
1141            if(AC && !AC__ok){
1142                    cout << "File: "<< f->GetName() <<" discarded ---- Missing AC tree"<< endl;
1143                    FLAG = false;
1144            };
1145            if(ORB && !ORB__ok){
1146                    cout << "File: "<< f->GetName() <<" discarded ---- Missing ORB tree"<< endl;
1147                    FLAG = false;
1148            };
1149            
1150            return FLAG;
1151            
1152    };
1153    
1154    
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.4
  ViewVC Help
Powered by ViewVC 1.1.23