TPC/AliTPCSelectorESD.cxx

   1 // The class definition in esdClus.h has been generated automatically
   2 // by the ROOT utility TTree::MakeSelector(). This class is derived
   3 // from the ROOT class TSelector. For more information on the TSelector
   4 // framework see $ROOTSYS/README/README.SELECTOR or the ROOT User Manual.
   5
   6 // The following methods are defined in this file:
   7 //    Begin():        called everytime a loop on the tree starts,
   8 //                    a convenient place to create your histograms.
   9 //    SlaveBegin():   called after Begin(), when on PROOF called only on the
  10 //                    slave servers.
  11 //    Process():      called for each event, in this function you decide what
  12 //                    to read and fill your histograms.
  13 //    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
  14 //                    called only on the slave servers.
  15 //    Terminate():    called at the end of the loop on the tree,
  16 //                    a convenient place to draw/fit your histograms.
  17 //
  18 // To use this file, try the following session on your Tree T:
  19 //
  20 // Root > T->Process("esdClus.C")
  21 // Root > T->Process("esdClus.C","some options")
  22 // Root > T->Process("esdClus.C+")
  23 //
  24 // Modification log:
  25 // 05/11/2006 HH  Correct for large pads (outer sectors) in amplitude plots
  26
  27 #include "TSystem.h"
  28 #include <TPDGCode.h>
  29 #include <TStyle.h>
  30 #include "TCint.h"
  31 #include "TH1I.h"
  32 #include "TTimeStamp.h"
  33 #include "TProof.h"
  34 #include "TTree.h"
  35 //
  36 #include "AliTracker.h"
  37 #include "AliMagF.h"
  38 //
  39 #include "AliESDEvent.h"   // new container
  40 #include "AliESD.h"
  41 #include "AliESDtrack.h"
  42 #include "AliESDfriend.h"
  43 #include "AliESDfriendTrack.h"
  44 #include "AliTPCseed.h"
  45 #include "AliTPCclusterMI.h"
  46 //
  47 #include "AliSysInfo.h"
  48 #include "AliTPCSelectorESD.h"
  49
  50
  51
  52
  53
  54 AliTPCSelectorESD::AliTPCSelectorESD(TTree *tree) :
  55    TSelector(),
  56    fChain(0),
  57    fESDevent(0),
  58    fESD(0),
  59    fESDfriend(0),
  60    fFileNo(0),
  61    fSysWatch(0),      // system info
  62    fFileWatch(0),      // file watch - write the status of the analyzed files
  63    fDebugLevel(0)
  64  {
  65    G__SetCatchException(0);
  66    //
  67    //
  68    //if (somthing){
  69    fSysWatch  = new fstream("syswatch2.log", ios_base::out|ios_base::trunc);
  70    fFileWatch = new fstream("filewatch.log", ios_base::out|ios_base::trunc);
  71    if (gProof) fDebugLevel = gProof->GetLogLevel();
  72    if (tree) fChain=tree;
  73  }
  74
  75
  76 void AliTPCSelectorESD::Begin(TTree * /*tree*/)
  77 {
  78   // The Begin() function is called at the start of the query.
  79   // When running with PROOF Begin() is only called on the client.
  80   // The tree argument is deprecated (on PROOF 0 is passed).
  81
  82   TString option = GetOption();
  83
  84 }
  85
  86 void AliTPCSelectorESD::SlaveBegin(TTree * tree)
  87 {
  88    // The SlaveBegin() function is called after the Begin() function.
  89    // When running with PROOF SlaveBegin() is called on each slave server.
  90    // The tree argument is deprecated (on PROOF 0 is passed).
  91   if (tree) fChain = tree;
  92   Init(tree);
  93   //
  94   fNtracks       = new TH1I("ntracks","Number of tracks",100,0,400);
  95   fNtracksFriend = new TH1I("ntracksF","Number of friend tracks",100,0,400);
  96   fNClusters     = new TH1I("ncluster","Number of clusters",100,0,200);
  97   fOutput->AddLast(fNtracks);
  98   fOutput->AddLast(fNtracksFriend);
  99   fOutput->AddLast(fNClusters);
 100
 101
 102 }
 103
 104 void   AliTPCSelectorESD::CleanESD(){
 105   //
 106   Bool_t isNew =  fESDevent!=0;
 107   if (isNew) return;
 108
 109
 110   if (fESD!=0){
 111     delete fESD;
 112     fESD = 0;
 113   }
 114   if (fESDevent!=0){
 115     delete fESDevent;
 116     fESDevent=0;
 117   }
 118   if (fESDfriend){
 119     delete fESDfriend;
 120     fESDfriend =0;
 121   }
 122 }
 123
 124 Bool_t AliTPCSelectorESD::Process(Long64_t entry)
 125 {
 126    // The Process() function is called for each entry in the tree (or possibly
 127    // keyed object in the case of PROOF) to be processed. The entry argument
 128    // specifies which entry in the currently loaded tree is to be processed.
 129    // It can be passed to either AliTPCSelectorESD::GetEntry() or TBranch::GetEntry()
 130    // to read either all or the required parts of the data. When processing
 131    // keyed objects with PROOF, the object is already loaded and is available
 132    // via the fObject pointer.
 133    //
 134    // This function should contain the "body" of the analysis. It can contain
 135    // simple or elaborate selection criteria, run algorithms on the data
 136    // of the event and typically fill histograms.
 137    //
 138    // The processing can be stopped by calling Abort().
 139    //
 140    // Use fStatus to set the return value of TTree::Process().
 141    //
 142    // The return value is currently not used.
 143
 144   Int_t status = ProcessIn(entry);
 145   if (fFileWatch) {
 146     (*fFileWatch) << "__" << status ;
 147   }
 148   return (status==0);
 149 }
 150
 151
 152
 153
 154 Int_t   AliTPCSelectorESD::ReadEvent(Long64_t entry){
 155   //
 156   //
 157   //
 158
 159
 160   if (!fChain) return -1;
 161   if (!fChain->GetTree()) return -1;
 162   try {
 163     fChain->GetTree()->GetEntry(entry);
 164   } catch (std::bad_alloc) {
 165     printf("Pica vyjebana pojebany skurveny kokot piciak\n");
 166     //    fESD =0;
 167     //fESDfriend = 0;
 168     //fESDevent=0;
 169     return -1;
 170   }
 171   //
 172   // Info("Procces","0");
 173   if (!fESD && !fESDevent) {
 174     //fESD = 0;
 175     //fESDfriend = 0;
 176     //CleanESD();
 177     return -2;
 178   }
 179   Int_t ntracks = (fESD) ? fESD->GetNumberOfTracks() : fESDevent->GetNumberOfTracks();
 180
 181   if (fESDevent){
 182     fESDevent->SetESDfriend(fESDfriend);
 183   }
 184
 185
 186   fNtracks->Fill(ntracks);
 187   Info("Procces", Form("entry\t%d: Ntracks = %d",entry, ntracks));
 188
 189   if (!fESDfriend || fESDfriend->GetNumberOfTracks() != ntracks) {
 190     try {
 191       delete fESD;
 192     }
 193     catch (std::bad_alloc) {
 194       printf("Pica vyjebana pojebany skurveny kokot piciak\n");
 195       fESD =0;
 196       return -1;
 197     }
 198     //fESD = 0;
 199     //fESDfriend = 0;
 200     //fESD = 0;
 201     //    CleanESD();
 202     if (fESDfriend) fNtracksFriend->Fill(fESDfriend->GetNumberOfTracks());
 203     Info("Procces","2: PROBLEM");
 204     return -3;
 205   }
 206   if (fESD) fESD->SetESDfriend(fESDfriend);
 207   return 0;
 208 }
 209
 210
 211 Int_t AliTPCSelectorESD::ProcessIn(Long64_t entry)
 212 {
 213   //
 214   // User part of proccess method
 215   //
 216
 217   //
 218   // USER code to go here
 219   //
 220   Int_t status = ReadEvent(entry);
 221   if (status<0) return status;
 222   Int_t ntracks = (fESD) ? fESD->GetNumberOfTracks() : fESDevent->GetNumberOfTracks();
 223   //
 224   AliTPCseed *seed;
 225   AliTPCclusterMI cl;
 226   Info("Procces", Form("entry\t%d: NtracksF = %d",entry,fESDfriend->GetNumberOfTracks() ));
 227
 228   for (Int_t tr = 0; tr < ntracks; tr++){
 229     AliESDtrack *esdTrack = fESD ? (AliESDtrack*) fESD->GetTrack(tr): (AliESDtrack*) fESDevent->GetTrack(tr);
 230     AliESDfriendTrack *friendtrack = (AliESDfriendTrack*) esdTrack->GetFriendTrack();
 231     seed = 0;
 232     TObject *cobject=0;
 233     for (Int_t i=0;;i++){
 234       cobject = friendtrack->GetCalibObject(i);
 235       if (!cobject) break;
 236       seed = dynamic_cast<AliTPCseed*>(cobject);
 237       if (seed) break;
 238     }
 239     //
 240     //Info("Process",Form("Proccessing track%d\n",tr));
 241     if (seed) {
 242       fNClusters->Fill(seed->GetNumberOfClusters());
 243       //
 244       //
 245     }
 246   }
 247   CleanESD();
 248   return 0;
 249
 250 }
 251
 252
 253 void AliTPCSelectorESD::SlaveTerminate()
 254 {
 255    // The SlaveTerminate() function is called after all entries or objects
 256    // have been processed. When running with PROOF SlaveTerminate() is called
 257    // on each slave server.
 258     printf ("SlaveTerminate.. \n");
 259
 260 }
 261
 262 void AliTPCSelectorESD::Terminate()
 263 {
 264    // The Terminate() function is the last function to be called during
 265    // a query. It always runs on the client, it can be used to present
 266    // the results graphically or save the results to file.
 267
 268   printf ("Terminate... \n");
 269   if (!fOutput) return;
 270   TFile file("Output.root","recreate");
 271   printf("fOutput contains the following: \n");
 272   fOutput->Print();
 273   printf("Trying to write the file 'Output.root'... \n");
 274   fOutput->Write();
 275   file.Close();
 276
 277
 278 }
 279
 280
 281
 282 void AliTPCSelectorESD::Init(TTree *tree)
 283 {
 284    // The Init() function is called when the selector needs to initialize
 285    // a new tree or chain. Typically here the branch addresses and branch
 286    // pointers of the tree will be set.
 287    // It is normaly not necessary to make changes to the generated
 288    // code, but the routine can be extended by the user if needed.
 289    // Init() will be called many times when running on PROOF
 290    // (once per file to be processed).
 291
 292    // Set branch addresses and branch pointers
 293   static Int_t counter=0;
 294   printf(Form("\nAliTPCSelectorESD::Init Accesing%d time\n",counter));
 295   counter++;
 296   if (!tree) return;
 297   fChain = tree;
 298   //if (counter>1) return;
 299   tree->SetBranchStatus("*",1);
 300   //
 301   // New AliESDevent format
 302   //
 303   if (!fChain->GetBranch("ESD")){
 304     //
 305     //
 306     //
 307     if (fESDevent) delete fESDevent;
 308      fESDevent = new AliESDEvent();
 309      fESDevent->ReadFromTree(tree); // Attach the branch with ESD friends
 310      fESDfriend = (AliESDfriend*)fESDevent->FindListObject("AliESDfriend");
 311      tree->SetBranchAddress("ESDfriend.",&fESDfriend);
 312      return;
 313   }
 314   //
 315   // if old format
 316   //
 317
 318
 319
 320    //   fChain->SetMakeClass(1);
 321    fChain->SetBranchAddress("ESD",&fESD);
 322    Info("Init","Enter");
 323    Bool_t isOK=kFALSE;
 324    if (fChain->GetBranch("ESDfriend")) {
 325      fChain->SetBranchAddress("ESDfriend",&fESDfriend);
 326      Info("Init","V0-ESDfriend.");
 327      isOK=kTRUE;
 328    }
 329    if (fChain->GetBranch("ESDfriend.")){
 330      Info("Init","V1-ESDfriend.");
 331      fChain->SetBranchAddress("ESDfriend.",&fESDfriend);
 332      isOK=kTRUE;
 333    }
 334    if (isOK) return;
 335
 336    //
 337    // Try to solve problem
 338    //
 339
 340    Info("Init","Problem");
 341    if (tree->GetBranch("ESD")){
 342      Info("InitTree",tree->GetBranch("ESD")->GetFile()->GetName());
 343      char  fname[1000];
 344      sprintf(fname,"%s/AliESDfriends.root",gSystem->DirName(tree->GetBranch("ESD")->GetFile()->GetName()));
 345      Info("InitFile",fname);
 346      if (tree->AddFriend("esdFriendTree",fname)){
 347        Info("InitFileOK",fname);
 348        if (fChain->GetBranch("ESDfriend")) {
 349          fChain->SetBranchAddress("ESDfriend",&fESDfriend);
 350          Info("Init","V0-ESDfriend.");
 351          isOK=kTRUE;
 352        }
 353        if (fChain->GetBranch("ESDfriend.")){
 354          Info("Init","V1-ESDfriend.");
 355          fChain->SetBranchAddress("ESDfriend.",&fESDfriend);
 356          isOK=kTRUE;
 357        }
 358      }
 359    }
 360 }
 361
 362
 363
 364 Bool_t AliTPCSelectorESD::Notify()
 365 {
 366    // The Notify() function is called when a new file is opened. This
 367    // can be either for a new TTree in a TChain or when when a new TTree
 368    // is started when using PROOF. It is normaly not necessary to make changes
 369    // to the generated code, but the routine can be extended by the
 370    // user if needed. The return value is currently not used.
 371
 372   ++fFileNo;
 373   const char * fname = "UNKNOWN";
 374   const char * hname = gSystem->HostName();
 375   if (!fChain) return kFALSE;
 376   if (fChain->GetCurrentFile()){
 377     fname = fChain->GetCurrentFile()->GetName();
 378   }
 379   Info("Notify",Form("Host %s processing file no %d %s\n",hname,fFileNo,fname));
 380
 381   //
 382   // Print statistic to log file
 383   //
 384 //   if (fname) {
 385 //     (*fFileWatch) << endl;
 386 //     (*fFileWatch) << hname   <<"\t"
 387 //                << fname   <<"\t";
 388 //   }
 389   DumpSysInfo(-1);
 390
 391   return kTRUE;
 392 }
 393
 394
 395 void   AliTPCSelectorESD::DumpSysInfo(Int_t entry){
 396   //
 397   // dump system info to log file
 398   // entry  - entry number in the chain
 399   //
 400   const char * fname = "UNKNOWN";
 401   const char * hname = gSystem->HostName();
 402   if (fChain->GetCurrentFile()){
 403     fname = fChain->GetCurrentFile()->GetName();
 404   }
 405   //   //
 406   if (fSysWatch){
 407     TTimeStamp stamp;
 408     CpuInfo_t  cpuInfo;
 409     MemInfo_t  memInfo;
 410     ProcInfo_t procInfo;
 411
 412     gSystem->GetCpuInfo(&cpuInfo, 1000);
 413     gSystem->GetMemInfo(&memInfo);
 414     gSystem->GetProcInfo(&procInfo);
 415
 416     (*fSysWatch) << hname   <<"\t"               // hname - hostname
 417                  << fname   <<"\t"               // fname - filename
 418                  << entry   <<"\t"               // entry - entry number
 419                  << stamp.GetSec()<<"\t"         // time  - time stamp in seconds
 420                  << memInfo.fMemUsed<<"\t"       //
 421                  << memInfo.fSwapUsed<<"\t"      //
 422                  << procInfo.fMemResident<<"\t"  //
 423                  << procInfo.fMemVirtual<<"\t"   //
 424                  << cpuInfo.fUser <<"\t"         //
 425                  << cpuInfo.fSys  <<"\t"         //
 426                  << procInfo.fCpuUser<<"\t"      //
 427                  << procInfo.fCpuSys<<"\t"       //
 428                  << endl;
 429   }
 430   AliSysInfo::AddStamp(fname);
 431 }