FMD/AliFMDInput.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15 /* $Id$ */
  16 /** @file    AliFMDInput.cxx
  17     @author  Christian Holm Christensen <cholm@nbi.dk>
  18     @date    Mon Mar 27 12:42:40 2006
  19     @brief   FMD utility classes for reading FMD data
  20 */
  21 //___________________________________________________________________
  22 //
  23 // The classes defined here, are utility classes for reading in data
  24 // for the FMD.  They are  put in a seperate library to not polute the
  25 // normal libraries.  The classes are intended to be used as base
  26 // classes for customized class that do some sort of analysis on the
  27 // various types of data produced by the FMD.
  28 //
  29 // Latest changes by Christian Holm Christensen
  30 //
  31 #include "AliFMDInput.h"        // ALIFMDHIT_H
  32 #include "AliFMDDebug.h"        // ALIFMDDEBUG_H ALILOG_H
  33 #include "AliLoader.h"          // ALILOADER_H
  34 #include "AliRunLoader.h"       // ALIRUNLOADER_H
  35 #include "AliRun.h"             // ALIRUN_H
  36 #include "AliStack.h"           // ALISTACK_H
  37 #include "AliRawReaderFile.h"   // ALIRAWREADERFILE_H
  38 #include "AliRawReaderRoot.h"   // ALIRAWREADERROOT_H
  39 #include "AliRawReaderDate.h"   // ALIRAWREADERDATE_H
  40 #include "AliFMD.h"             // ALIFMD_H
  41 #include "AliFMDHit.h"          // ALIFMDHIT_H
  42 #include "AliFMDDigit.h"        // ALIFMDDigit_H
  43 #include "AliFMDSDigit.h"       // ALIFMDDigit_H
  44 #include "AliFMDRecPoint.h"     // ALIFMDRECPOINT_H
  45 #include "AliFMDRawReader.h"    // ALIFMDRAWREADER_H
  46 #include <AliESD.h>
  47 #include <AliESDFMD.h>
  48 #include <AliESDEvent.h>
  49 #include <AliCDBManager.h>
  50 #include <AliCDBEntry.h>
  51 #include <AliAlignObjParams.h>
  52 #include <TTree.h>              // ROOT_TTree
  53 #include <TChain.h>             // ROOT_TChain
  54 #include <TParticle.h>          // ROOT_TParticle
  55 #include <TString.h>            // ROOT_TString
  56 #include <TDatabasePDG.h>       // ROOT_TDatabasePDG
  57 #include <TMath.h>              // ROOT_TMath
  58 #include <TGeoManager.h>        // ROOT_TGeoManager
  59 #include <TSystemDirectory.h>   // ROOT_TSystemDirectory
  60 #include <Riostream.h>          // ROOT_Riostream
  61 #include <TFile.h>              // ROOT_TFile
  62 #include <TStreamerInfo.h>
  63 #include <TArrayF.h>
  64
  65 //____________________________________________________________________
  66 ClassImp(AliFMDInput)
  67 #if 0
  68   ; // This is here to keep Emacs for indenting the next line
  69 #endif
  70
  71
  72 //____________________________________________________________________
  73 AliFMDInput::AliFMDInput()
  74   : TNamed("AliFMDInput", "Input handler for various FMD data"),
  75     fGAliceFile(""),
  76     fLoader(0),
  77     fRun(0),
  78     fStack(0),
  79     fFMDLoader(0),
  80     fReader(0),
  81     fFMD(0),
  82     fESD(0),
  83     fESDEvent(0),
  84     fTreeE(0),
  85     fTreeH(0),
  86     fTreeD(0),
  87     fTreeS(0),
  88     fTreeR(0),
  89     fTreeA(0),
  90     fChainE(0),
  91     fArrayE(0),
  92     fArrayH(0),
  93     fArrayD(0),
  94     fArrayS(0),
  95     fArrayR(0),
  96     fArrayA(0),
  97     fHeader(0),
  98     fGeoManager(0),
  99     fTreeMask(0),
 100     fRawFile(""),
 101     fIsInit(kFALSE),
 102     fEventCount(0)
 103 {
 104
 105   // Constructor of an FMD input object.  Specify what data to read in
 106   // using the AddLoad member function.   Sub-classes should at a
 107   // minimum overload the member function Event.   A full job can be
 108   // executed using the member function Run.
 109 }
 110
 111
 112
 113 //____________________________________________________________________
 114 AliFMDInput::AliFMDInput(const char* gAliceFile)
 115   : TNamed("AliFMDInput", "Input handler for various FMD data"),
 116     fGAliceFile(gAliceFile),
 117     fLoader(0),
 118     fRun(0),
 119     fStack(0),
 120     fFMDLoader(0),
 121     fReader(0),
 122     fFMD(0),
 123     fESD(0),
 124     fESDEvent(0),
 125     fTreeE(0),
 126     fTreeH(0),
 127     fTreeD(0),
 128     fTreeS(0),
 129     fTreeR(0),
 130     fTreeA(0),
 131     fChainE(0),
 132     fArrayE(0),
 133     fArrayH(0),
 134     fArrayD(0),
 135     fArrayS(0),
 136     fArrayR(0),
 137     fArrayA(0),
 138     fHeader(0),
 139     fGeoManager(0),
 140     fTreeMask(0),
 141     fRawFile(""),
 142     fIsInit(kFALSE),
 143     fEventCount(0)
 144 {
 145
 146   // Constructor of an FMD input object.  Specify what data to read in
 147   // using the AddLoad member function.   Sub-classes should at a
 148   // minimum overload the member function Event.   A full job can be
 149   // executed using the member function Run.
 150 }
 151
 152 //____________________________________________________________________
 153 Int_t
 154 AliFMDInput::NEvents() const
 155 {
 156   // Get number of events
 157   if (TESTBIT(fTreeMask, kRaw)) return -1;
 158   if (fTreeE) return fTreeE->GetEntries();
 159   return -1;
 160 }
 161
 162 //____________________________________________________________________
 163 Bool_t
 164 AliFMDInput::Init()
 165 {
 166   // Initialize the object.  Get the needed loaders, and such.
 167
 168   // Check if we have been initialized
 169   if (fIsInit) {
 170     AliWarning("Already initialized");
 171     return fIsInit;
 172   }
 173   // Get the run
 174   if (!TESTBIT(fTreeMask, kRaw)) {
 175     if (fGAliceFile.IsNull()) fGAliceFile = "galice.root";
 176     // Get the loader
 177     fLoader = AliRunLoader::Open(fGAliceFile.Data(), "Alice", "read");
 178     if (!fLoader) {
 179       AliError(Form("Coulnd't read the file %s", fGAliceFile.Data()));
 180       return kFALSE;
 181     }
 182
 183     if  (fLoader->LoadgAlice()) return kFALSE;
 184     fRun = fLoader->GetAliRun();
 185
 186     // Get the FMD
 187     fFMD = static_cast<AliFMD*>(fRun->GetDetector("FMD"));
 188     if (!fFMD) {
 189       AliError("Failed to get detector FMD from loader");
 190       return kFALSE;
 191     }
 192
 193     // Get the FMD loader
 194     fFMDLoader = fLoader->GetLoader("FMDLoader");
 195     if (!fFMDLoader) {
 196       AliError("Failed to get detector FMD loader from loader");
 197       return kFALSE;
 198     }
 199     if (fLoader->LoadHeader()) {
 200       AliError("Failed to get event header information from loader");
 201       return kFALSE;
 202     }
 203     fTreeE = fLoader->TreeE();
 204   }
 205
 206   // Optionally, get the ESD files
 207   if (TESTBIT(fTreeMask, kESD)) {
 208     fChainE = new TChain("esdTree");
 209     TSystemDirectory dir(".",".");
 210     TList*           files = dir.GetListOfFiles();
 211     TSystemFile*     file = 0;
 212     if (!files) {
 213       AliError("No files");
 214       return kFALSE;
 215     }
 216     files->Sort();
 217     TIter            next(files);
 218     while ((file = static_cast<TSystemFile*>(next()))) {
 219       TString fname(file->GetName());
 220       if (fname.Contains("AliESDs")) fChainE->AddFile(fname.Data());
 221     }
 222     fESDEvent = new AliESDEvent();
 223     fESDEvent->ReadFromTree(fChainE);
 224     //    fChainE->SetBranchAddress("ESD", &fMainESD);
 225
 226   }
 227
 228   if (TESTBIT(fTreeMask, kRaw)) {
 229     AliInfo("Getting FMD raw data digits");
 230     fArrayA = new TClonesArray("AliFMDDigit");
 231 #if 0
 232     if (!fRawFile.IsNull() && fRawFile.EndsWith(".root"))
 233       fReader = new AliRawReaderRoot(fRawFile.Data());
 234     else if (!fRawFile.IsNull() && fRawFile.EndsWith(".raw"))
 235       fReader = new AliRawReaderDate(fRawFile.Data());
 236     else
 237       fReader = new AliRawReaderFile(-1);
 238 #else
 239     if(!fRawFile.IsNull())
 240       fReader = AliRawReader::Create(fRawFile.Data());
 241     else
 242       fReader = new AliRawReaderFile(-1);
 243 #endif
 244   }
 245
 246   // Optionally, get the geometry
 247   if (TESTBIT(fTreeMask, kGeometry)) {
 248     if (fRun) {
 249       TString fname(fRun->GetGeometryFileName());
 250       if (fname.IsNull()) {
 251         Warning("Init", "No file name for the geometry from AliRun");
 252         fname = gSystem->DirName(fGAliceFile);
 253         fname.Append("/geometry.root");
 254       }
 255       fGeoManager = TGeoManager::Import(fname.Data());
 256       if (!fGeoManager) {
 257         Fatal("Init", "No geometry manager found");
 258         return kFALSE;
 259       }
 260     }
 261     else {
 262       AliGeomManager::LoadGeometry();
 263     }
 264     AliCDBManager* cdb   = AliCDBManager::Instance();
 265     AliCDBEntry*   align = cdb->Get("FMD/Align/Data");
 266     if (align) {
 267       AliInfo("Got alignment data from CDB");
 268       TClonesArray* array = dynamic_cast<TClonesArray*>(align->GetObject());
 269       if (!array) {
 270         AliWarning("Invalid align data from CDB");
 271       }
 272       else {
 273         Int_t nAlign = array->GetEntries();
 274         for (Int_t i = 0; i < nAlign; i++) {
 275           AliAlignObjParams* a = static_cast<AliAlignObjParams*>(array->At(i));
 276           if (!a->ApplyToGeometry()) {
 277             AliWarning(Form("Failed to apply alignment to %s",
 278                             a->GetSymName()));
 279           }
 280         }
 281       }
 282     }
 283   }
 284
 285   fEventCount = 0;
 286   fIsInit = kTRUE;
 287   return fIsInit;
 288 }
 289
 290 //____________________________________________________________________
 291 Bool_t
 292 AliFMDInput::Begin(Int_t event)
 293 {
 294   // Called at the begining of each event.  Per default, it gets the
 295   // data trees and gets pointers to the output arrays.   Users can
 296   // overload this, but should call this member function in the
 297   // overloaded member function of the derived class.
 298
 299   // Check if we have been initialized
 300   if (!fIsInit) {
 301     AliError("Not initialized");
 302     return fIsInit;
 303   }
 304
 305   // Get the event
 306   if (fLoader && fLoader->GetEvent(event)) return kFALSE;
 307   AliInfo(Form("Now in event %8d/%8d", event, NEvents()));
 308
 309   // Possibly load global kinematics information
 310   if (TESTBIT(fTreeMask, kKinematics) || TESTBIT(fTreeMask, kTracks)) {
 311     // AliInfo("Getting kinematics");
 312     if (fLoader->LoadKinematics("READ")) return kFALSE;
 313     fStack = fLoader->Stack();
 314   }
 315
 316   // Possibly load FMD Hit information
 317   if (TESTBIT(fTreeMask, kHits) || TESTBIT(fTreeMask, kTracks)) {
 318     // AliInfo("Getting FMD hits");
 319     if (!fFMDLoader || fFMDLoader->LoadHits("READ")) return kFALSE;
 320     fTreeH = fFMDLoader->TreeH();
 321     if (!fArrayH) fArrayH = fFMD->Hits();
 322   }
 323
 324   // Possibly load heaedr information
 325   if (TESTBIT(fTreeMask, kHeader)) {
 326     // AliInfo("Getting FMD hits");
 327     if (!fLoader /* || fLoader->LoadHeader()*/) return kFALSE;
 328     fHeader = fLoader->GetHeader();
 329   }
 330
 331   // Possibly load FMD Digit information
 332   if (TESTBIT(fTreeMask, kDigits)) {
 333     // AliInfo("Getting FMD digits");
 334     if (!fFMDLoader || fFMDLoader->LoadDigits("READ")) return kFALSE;
 335     fTreeD = fFMDLoader->TreeD();
 336     if (fTreeD) {
 337       if (!fArrayD) fArrayD = fFMD->Digits();
 338     }
 339     else {
 340       fArrayD = 0;
 341       AliWarning(Form("Failed to load FMD Digits"));
 342     }
 343   }
 344
 345   // Possibly load FMD Sdigit information
 346   if (TESTBIT(fTreeMask, kSDigits)) {
 347     // AliInfo("Getting FMD summable digits");
 348     if (!fFMDLoader || fFMDLoader->LoadSDigits("READ")) return kFALSE;
 349     fTreeS = fFMDLoader->TreeS();
 350     if (!fArrayS) fArrayS = fFMD->SDigits();
 351   }
 352
 353   // Possibly load FMD RecPoints information
 354   if (TESTBIT(fTreeMask, kRecPoints)) {
 355     // AliInfo("Getting FMD reconstructed points");
 356     if (!fFMDLoader || fFMDLoader->LoadRecPoints("READ")) return kFALSE;
 357     fTreeR = fFMDLoader->TreeR();
 358     if (!fArrayR) fArrayR = new TClonesArray("AliFMDRecPoint");
 359     fTreeR->SetBranchAddress("FMD",  &fArrayR);
 360   }
 361
 362   // Possibly load FMD ESD information
 363   if (TESTBIT(fTreeMask, kESD)) {
 364     // AliInfo("Getting FMD event summary data");
 365     Int_t read = fChainE->GetEntry(event);
 366     if (read <= 0) return kFALSE;
 367     fESD = fESDEvent->GetFMDData();
 368     if (!fESD) return kFALSE;
 369 #if 0
 370     TFile* f = fChainE->GetFile();
 371     if (f) {
 372       TObject* o = f->GetStreamerInfoList()->FindObject("AliFMDMap");
 373       if (o) {
 374         TStreamerInfo* info = static_cast<TStreamerInfo*>(o);
 375         std::cout << "AliFMDMap class version read is "
 376                   <<  info->GetClassVersion() << std::endl;
 377       }
 378     }
 379     // fESD->CheckNeedUShort(fChainE->GetFile());
 380 #endif
 381   }
 382
 383   // Possibly load FMD Digit information
 384   if (TESTBIT(fTreeMask, kRaw)) {
 385     AliInfo("Getting FMD raw data digits");
 386     if (!fReader->NextEvent()) return kFALSE;
 387     AliFMDRawReader r(fReader, 0);
 388     fArrayA->Clear();
 389     r.ReadAdcs(fArrayA);
 390     AliFMDDebug(1, ("Got a total of %d digits", fArrayA->GetEntriesFast()));
 391   }
 392   fEventCount++;
 393   return kTRUE;
 394 }
 395
 396
 397 //____________________________________________________________________
 398 Bool_t
 399 AliFMDInput::Event()
 400 {
 401   // Process one event.  The default implementation one or more of
 402   //
 403   //   -  ProcessHits       if the hits are loaded.
 404   //   -  ProcessDigits     if the digits are loaded.
 405   //   -  ProcessSDigits    if the sumbable digits are loaded.
 406   //   -  ProcessRecPoints  if the reconstructed points are loaded.
 407   //   -  ProcessESD        if the event summary data is loaded
 408   //
 409   if (TESTBIT(fTreeMask, kHits))
 410     if (!ProcessHits()) return kFALSE;
 411   if (TESTBIT(fTreeMask, kTracks))
 412     if (!ProcessTracks()) return kFALSE;
 413   if (TESTBIT(fTreeMask, kDigits))
 414     if (!ProcessDigits()) return kFALSE;
 415   if (TESTBIT(fTreeMask, kSDigits))
 416     if (!ProcessSDigits()) return kFALSE;
 417   if (TESTBIT(fTreeMask, kRaw))
 418     if (!ProcessRawDigits()) return kFALSE;
 419   if (TESTBIT(fTreeMask, kRecPoints))
 420     if (!ProcessRecPoints()) return kFALSE;
 421   if (TESTBIT(fTreeMask, kESD))
 422     if (!ProcessESDs()) return kFALSE;
 423
 424   return kTRUE;
 425 }
 426
 427 //____________________________________________________________________
 428 Bool_t
 429 AliFMDInput::ProcessHits()
 430 {
 431   // Read the hit tree, and pass each hit to the member function
 432   // ProcessHit.
 433   if (!fTreeH) {
 434     AliError("No hit tree defined");
 435     return kFALSE;
 436   }
 437   if (!fArrayH) {
 438     AliError("No hit array defined");
 439     return kFALSE;
 440   }
 441
 442   Int_t nTracks = fTreeH->GetEntries();
 443   for (Int_t i = 0; i < nTracks; i++) {
 444     Int_t hitRead  = fTreeH->GetEntry(i);
 445     if (hitRead <= 0) continue;
 446
 447     Int_t nHit = fArrayH->GetEntries();
 448     if (nHit <= 0) continue;
 449
 450     for (Int_t j = 0; j < nHit; j++) {
 451       AliFMDHit* hit = static_cast<AliFMDHit*>(fArrayH->At(j));
 452       if (!hit) continue;
 453
 454       TParticle* track = 0;
 455       if (TESTBIT(fTreeMask, kKinematics) && fStack) {
 456         Int_t trackno = hit->Track();
 457         track = fStack->Particle(trackno);
 458       }
 459       if (!ProcessHit(hit, track)) return kFALSE;
 460     }
 461   }
 462   return kTRUE;
 463 }
 464
 465 //____________________________________________________________________
 466 Bool_t
 467 AliFMDInput::ProcessTracks()
 468 {
 469   // Read the hit tree, and pass each hit to the member function
 470   // ProcessTrack.
 471   if (!fStack) {
 472     AliError("No track tree defined");
 473     return kFALSE;
 474   }
 475   if (!fTreeH) {
 476     AliError("No hit tree defined");
 477     return kFALSE;
 478   }
 479   if (!fArrayH) {
 480     AliError("No hit array defined");
 481     return kFALSE;
 482   }
 483
 484   // Int_t nTracks = fStack->GetNtrack();
 485   Int_t nTracks = fTreeH->GetEntries();
 486   for (Int_t i = 0; i < nTracks; i++) {
 487     Int_t      trackno = nTracks - i - 1;
 488     TParticle* track   = fStack->Particle(trackno);
 489     if (!track) continue;
 490
 491     // Get the hits for this track.
 492     Int_t hitRead  = fTreeH->GetEntry(i);
 493     Int_t nHit     = fArrayH->GetEntries();
 494     if (nHit == 0 || hitRead <= 0) {
 495       // Let user code see the track, even if there's no hits.
 496       if (!ProcessTrack(trackno, track, 0)) return kFALSE;
 497       continue;
 498     }
 499
 500     // Loop over the hits corresponding to this track.
 501     for (Int_t j = 0; j < nHit; j++) {
 502       AliFMDHit* hit = static_cast<AliFMDHit*>(fArrayH->At(j));
 503       if (!ProcessTrack(trackno, track, hit)) return kFALSE;
 504     }
 505   }
 506   return kTRUE;
 507 }
 508
 509 //____________________________________________________________________
 510 Bool_t
 511 AliFMDInput::ProcessDigits()
 512 {
 513   // Read the digit tree, and pass each digit to the member function
 514   // ProcessDigit.
 515   if (!fTreeD) {
 516     AliError("No digit tree defined");
 517     return kFALSE;
 518   }
 519   if (!fArrayD) {
 520     AliError("No digit array defined");
 521     return kFALSE;
 522   }
 523
 524   Int_t nEv = fTreeD->GetEntries();
 525   for (Int_t i = 0; i < nEv; i++) {
 526     Int_t digitRead  = fTreeD->GetEntry(i);
 527     if (digitRead <= 0) continue;
 528     Int_t nDigit = fArrayD->GetEntries();
 529     AliFMDDebug(0, ("Got %5d digits for this event", nDigit));
 530     if (nDigit <= 0) continue;
 531     for (Int_t j = 0; j < nDigit; j++) {
 532       AliFMDDigit* digit = static_cast<AliFMDDigit*>(fArrayD->At(j));
 533       if (!digit) continue;
 534       if (!ProcessDigit(digit)) return kFALSE;
 535     }
 536   }
 537   return kTRUE;
 538 }
 539
 540 //____________________________________________________________________
 541 Bool_t
 542 AliFMDInput::ProcessSDigits()
 543 {
 544   // Read the summable digit tree, and pass each sumable digit to the
 545   // member function ProcessSdigit.
 546   if (!fTreeS) {
 547     AliWarning("No sdigit tree defined");
 548     return kTRUE; // Empty SDigits is fine
 549   }
 550   if (!fArrayS) {
 551     AliWarning("No sdigit array defined");
 552     return kTRUE; // Empty SDigits is fine
 553   }
 554
 555   Int_t nEv = fTreeS->GetEntries();
 556   for (Int_t i = 0; i < nEv; i++) {
 557     Int_t sdigitRead  = fTreeS->GetEntry(i);
 558     if (sdigitRead <= 0) continue;
 559     Int_t nSdigit = fArrayS->GetEntries();
 560     AliFMDDebug(0, ("Got %5d digits for this event", nSdigit));
 561     if (nSdigit <= 0) continue;
 562     for (Int_t j = 0; j < nSdigit; j++) {
 563       AliFMDSDigit* sdigit = static_cast<AliFMDSDigit*>(fArrayS->At(j));
 564       if (!sdigit) continue;
 565       if (!ProcessSDigit(sdigit)) return kFALSE;
 566     }
 567   }
 568   return kTRUE;
 569 }
 570
 571 //____________________________________________________________________
 572 Bool_t
 573 AliFMDInput::ProcessRawDigits()
 574 {
 575   // Read the digit tree, and pass each digit to the member function
 576   // ProcessDigit.
 577   if (!fArrayA) {
 578     AliError("No raw digit array defined");
 579     return kFALSE;
 580   }
 581
 582   Int_t nDigit = fArrayA->GetEntries();
 583   if (nDigit <= 0) return kTRUE;
 584   for (Int_t j = 0; j < nDigit; j++) {
 585     AliFMDDigit* digit = static_cast<AliFMDDigit*>(fArrayA->At(j));
 586     if (!digit) continue;
 587     if (AliLog::GetDebugLevel("FMD","") >= 40 && j < 30)
 588       digit->Print();
 589     if (!ProcessRawDigit(digit)) return kFALSE;
 590   }
 591   return kTRUE;
 592 }
 593
 594 //____________________________________________________________________
 595 Bool_t
 596 AliFMDInput::ProcessRecPoints()
 597 {
 598   // Read the reconstrcted points tree, and pass each reconstruction
 599   // object (AliFMDRecPoint) to either ProcessRecPoint.
 600   if (!fTreeR) {
 601     AliError("No recpoint tree defined");
 602     return kFALSE;
 603   }
 604   if (!fArrayR) {
 605     AliError("No recpoints array defined");
 606     return kFALSE;
 607   }
 608
 609   Int_t nEv = fTreeR->GetEntries();
 610   for (Int_t i = 0; i < nEv; i++) {
 611     Int_t recRead  = fTreeR->GetEntry(i);
 612     if (recRead <= 0) continue;
 613     Int_t nRecPoint = fArrayR->GetEntries();
 614     for (Int_t j = 0; j < nRecPoint; j++) {
 615       AliFMDRecPoint* recPoint = static_cast<AliFMDRecPoint*>(fArrayR->At(j));
 616       if (!recPoint) continue;
 617       if (!ProcessRecPoint(recPoint)) return kFALSE;
 618     }
 619   }
 620   return kTRUE;
 621 }
 622
 623 //____________________________________________________________________
 624 Bool_t
 625 AliFMDInput::ProcessESDs()
 626 {
 627   // Process event summary data
 628   if (!fESD) return kFALSE;
 629   for (UShort_t det = 1; det <= 3; det++) {
 630     Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
 631     for (Char_t* rng = rings; *rng != '\0'; rng++) {
 632       UShort_t nsec = (*rng == 'I' ?  20 :  40);
 633       UShort_t nstr = (*rng == 'I' ? 512 : 256);
 634       for (UShort_t sec = 0; sec < nsec; sec++) {
 635         for (UShort_t str = 0; str < nstr; str++) {
 636           Float_t eta  = fESD->Eta(det,*rng,sec,str);
 637           Float_t mult = fESD->Multiplicity(det,*rng,sec,str);
 638           if (!fESD->IsAngleCorrected())
 639             mult *= TMath::Abs(TMath::Cos(2.*TMath::ATan(TMath::Exp(-eta))));
 640           if (!ProcessESD(det, *rng, sec, str, eta, mult)) continue;
 641         }
 642       }
 643     }
 644   }
 645   return kTRUE;
 646 }
 647
 648 //____________________________________________________________________
 649 Bool_t
 650 AliFMDInput::End()
 651 {
 652   // Called at the end of each event.  Per default, it unloads the
 653   // data trees and resets the pointers to the output arrays.   Users
 654   // can overload this, but should call this member function in the
 655   // overloaded member function of the derived class.
 656
 657   // Check if we have been initialized
 658   if (!fIsInit) {
 659     AliError("Not initialized");
 660     return fIsInit;
 661   }
 662   // Possibly unload global kinematics information
 663   if (TESTBIT(fTreeMask, kKinematics) || TESTBIT(fTreeMask, kTracks)) {
 664     fLoader->UnloadKinematics();
 665     // fTreeK = 0;
 666     fStack = 0;
 667   }
 668   // Possibly unload FMD Hit information
 669   if (TESTBIT(fTreeMask, kHits) || TESTBIT(fTreeMask, kTracks)) {
 670     fFMDLoader->UnloadHits();
 671     fTreeH = 0;
 672   }
 673   // Possibly unload FMD Digit information
 674   if (TESTBIT(fTreeMask, kDigits)) {
 675     fFMDLoader->UnloadDigits();
 676     fTreeD = 0;
 677   }
 678   // Possibly unload FMD Sdigit information
 679   if (TESTBIT(fTreeMask, kSDigits)) {
 680     fFMDLoader->UnloadSDigits();
 681     fTreeS = 0;
 682   }
 683   // Possibly unload FMD RecPoints information
 684   if (TESTBIT(fTreeMask, kRecPoints)) {
 685     fFMDLoader->UnloadRecPoints();
 686     fTreeR = 0;
 687   }
 688   // AliInfo("Now out event");
 689   return kTRUE;
 690 }
 691
 692 //____________________________________________________________________
 693 Bool_t
 694 AliFMDInput::Run()
 695 {
 696   // Run over all events and files references in galice.root
 697
 698   Bool_t retval;
 699   if (!(retval = Init())) return retval;
 700
 701   Int_t nEvents = NEvents();
 702   for (Int_t event = 0; nEvents < 0 || event < nEvents; event++) {
 703     if (!(retval = Begin(event))) break;
 704     if (!(retval = Event())) break;
 705     if (!(retval = End())) break;
 706   }
 707   if (!retval) return retval;
 708   retval = Finish();
 709   return retval;
 710 }
 711
 712 //__________________________________________________________________
 713 TArrayF
 714 AliFMDInput::MakeLogScale(Int_t n, Double_t min, Double_t max)
 715 {
 716   // Service function to define a logarithmic axis.
 717   // Parameters:
 718   //   n    Number of bins
 719   //   min  Minimum of axis
 720   //   max  Maximum of axis
 721   TArrayF bins(n+1);
 722   bins[0]      = min;
 723   if (n <= 20) {
 724     for (Int_t i = 1; i < n+1; i++) bins[i] = bins[i-1] + (max-min)/n;
 725     return bins;
 726   }
 727   Float_t dp   = n / TMath::Log10(max / min);
 728   Float_t pmin = TMath::Log10(min);
 729   for (Int_t i = 1; i < n+1; i++) {
 730     Float_t p = pmin + i / dp;
 731     bins[i]   = TMath::Power(10, p);
 732   }
 733   return bins;
 734 }
 735
 736
 737
 738 //____________________________________________________________________
 739 //
 740 // EOF
 741 //