FMD/AliFMDBaseDA.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
  16 /** @file    AliFMDBaseDA.cxx
  17     @author  Hans Hjersing Dalsgaard <canute@nbi.dk>
  18     @date    Wed Mar 26 11:30:45 2008
  19     @brief   Base class for detector algorithms.
  20 */
  21 //
  22 // This is the implementation of the (virtual) base class for the FMD
  23 // detector algorithms(DA). It implements the creation of the relevant
  24 // containers and handles the loop over the raw data. The derived
  25 // classes can control the parameters and action to be taken making
  26 // this the base class for the Pedestal, Gain and Physics DA.
  27 //
  28
  29 #include "AliFMDBaseDA.h"
  30 #include "iostream"
  31 #include "AliFMDRawReader.h"
  32 #include "AliFMDCalibSampleRate.h"
  33 #include "AliFMDCalibStripRange.h"
  34 #include "AliLog.h"
  35 #include "AliRawEventHeaderBase.h"
  36 #include <TDatime.h>
  37 #include <TSystem.h>
  38 #include <TH2F.h>
  39
  40 //_____________________________________________________________________
  41 ClassImp(AliFMDBaseDA)
  42 #if 0
  43 ; // Do not delete  - to let Emacs for mat the code
  44 #endif
  45
  46 //_____________________________________________________________________
  47 const char*
  48 AliFMDBaseDA::GetStripPath(UShort_t det,
  49                            Char_t   ring,
  50                            UShort_t sec,
  51                            UShort_t str,
  52                            Bool_t   full) const
  53 {
  54   // Get the strip path
  55   //
  56   // Parameters
  57   //     det      Detector number
  58   //     ring     Ring identifier
  59   //     sec      Sector number
  60   //     str      Strip number
  61   //     full     If true, return full path
  62   //
  63   // Return
  64   //     The path
  65   return Form("%s%sFMD%d%c[%02d,%03d]",
  66               (full ? GetSectorPath(det, ring, sec, full) : ""),
  67               (full ? "/" : ""), det, ring, sec, str);
  68 }
  69 //_____________________________________________________________________
  70 const char*
  71 AliFMDBaseDA::GetSectorPath(UShort_t det,
  72                             Char_t   ring,
  73                             UShort_t sec,
  74                             Bool_t   full) const
  75 {
  76   // Get the strip path
  77   //
  78   // Parameters
  79   //     det      Detector number
  80   //     ring     Ring identifier
  81   //     sec      Sector number
  82   //     str      Strip number
  83   //     full     If true, return full path
  84   //
  85   // Return
  86   //     The path
  87   return Form("%s%sFMD%d%c[%02d]",
  88               (full ? GetRingPath(det, ring, full) : ""),
  89               (full ? "/" : ""), det, ring, sec);
  90 }
  91 //_____________________________________________________________________
  92 const char*
  93 AliFMDBaseDA::GetRingPath(UShort_t det,
  94                           Char_t   ring,
  95                           Bool_t   full) const
  96 {
  97   // Get the strip path
  98   //
  99   // Parameters
 100   //     det      Detector number
 101   //     ring     Ring identifier
 102   //     sec      Sector number
 103   //     str      Strip number
 104   //     full     If true, return full path
 105   //
 106   // Return
 107   //     The path
 108   return Form("%s%sFMD%d%c",
 109               (full ? GetDetectorPath(det, full) : ""),
 110               (full ? "/" : ""), det, ring);
 111 }
 112 //_____________________________________________________________________
 113 const char*
 114 AliFMDBaseDA::GetDetectorPath(UShort_t det,
 115                               Bool_t   full) const
 116 {
 117   // Get the strip path
 118   //
 119   // Parameters
 120   //     det      Detector number
 121   //     ring     Ring identifier
 122   //     sec      Sector number
 123   //     str      Strip number
 124   //     full     If true, return full path
 125   //
 126   // Return
 127   //     The path
 128   return Form("%s%sFMD%d",
 129               (full ? fDiagnosticsFilename.Data() : ""),
 130               (full ? ":/" : ""), det);
 131 }
 132
 133 //_____________________________________________________________________
 134 AliFMDBaseDA::AliFMDBaseDA() :
 135   TNamed(),
 136   fDiagnosticsFilename("diagnosticsHistograms.root"),
 137   fOutputFile(),
 138   fConditionsFile(),
 139   fSaveHistograms(kFALSE),
 140   fMakeSummaries(kFALSE),
 141   fDetectorArray(),
 142   fPulseSize(10),
 143   fPulseLength(10),
 144   fRequiredEvents(0),
 145   fCurrentEvent(0),
 146   fRunno(0),
 147   fSummaries(0)
 148 {
 149   //Constructor
 150   fSeenDetectors[0] = fSeenDetectors[1] = fSeenDetectors[2] = kFALSE;
 151   fDetectorArray.SetOwner();
 152   Rotate("conditions.csv", 3);
 153   fConditionsFile.open("conditions.csv");
 154 }
 155 //_____________________________________________________________________
 156 AliFMDBaseDA::AliFMDBaseDA(const AliFMDBaseDA & baseDA) :
 157   TNamed(baseDA),
 158   fDiagnosticsFilename(baseDA.fDiagnosticsFilename.Data()),
 159   fOutputFile(),
 160   fConditionsFile(),
 161   fSaveHistograms(baseDA.fSaveHistograms),
 162   fMakeSummaries(baseDA.fMakeSummaries),
 163   fDetectorArray(baseDA.fDetectorArray),
 164   fPulseSize(baseDA.fPulseSize),
 165   fPulseLength(baseDA.fPulseLength),
 166   fRequiredEvents(baseDA.fRequiredEvents),
 167   fCurrentEvent(baseDA.fCurrentEvent),
 168   fRunno(baseDA.fRunno),
 169   fSummaries(0)
 170 {
 171   //Copy constructor
 172   fSeenDetectors[0] = baseDA.fSeenDetectors[0];
 173   fSeenDetectors[1] = baseDA.fSeenDetectors[1];
 174   fSeenDetectors[2] = baseDA.fSeenDetectors[2];
 175
 176   fDetectorArray.SetOwner();
 177
 178 }
 179
 180
 181 //_____________________________________________________________________
 182 AliFMDBaseDA::~AliFMDBaseDA()
 183 {
 184   //destructor
 185 }
 186
 187 //_____________________________________________________________________
 188 void AliFMDBaseDA::Run(AliRawReader* reader)
 189 {
 190   //Run the FMD DA
 191   TFile* diagFile = 0;
 192   if (fSaveHistograms)
 193     diagFile = TFile::Open(fDiagnosticsFilename.Data(),"RECREATE");
 194
 195
 196
 197
 198
 199   reader->Reset();
 200   fRunno = reader->GetRunNumber();
 201
 202   AliFMDRawReader* fmdReader  = new AliFMDRawReader(reader,0);
 203   TClonesArray*    digitArray = new TClonesArray("AliFMDDigit",0);
 204
 205   Bool_t sodread = kFALSE;
 206
 207   for(Int_t i=0;i<3;i++) {
 208     reader->NextEvent(); // Read Start-of-Run / Start-of-Files event
 209
 210     UInt_t eventType = reader->GetType();
 211     if(eventType == AliRawEventHeaderBase::kStartOfData ||
 212        eventType == AliRawEventHeaderBase::kFormatError) {
 213
 214       WriteConditionsData(fmdReader);
 215       Init();
 216       sodread = kTRUE;
 217       break;
 218     }
 219   }
 220
 221   InitContainer(diagFile);
 222
 223   if(!sodread)
 224     AliWarning("No SOD event detected!");
 225
 226   int lastProgress = 0;
 227
 228
 229
 230   for(Int_t n =1;n <= GetRequiredEvents(); n++) {
 231     if(!reader->NextEvent()) continue;
 232     SetCurrentEvent(n);
 233     digitArray->Clear();
 234     fmdReader->ReadAdcs(digitArray);
 235
 236     for(Int_t i = 0; i<digitArray->GetEntriesFast();i++) {
 237       AliFMDDigit* digit = static_cast<AliFMDDigit*>(digitArray->At(i));
 238       fSeenDetectors[digit->Detector()-1] = kTRUE;
 239       FillChannels(digit);
 240     }
 241
 242
 243     FinishEvent();
 244
 245     int progress = int((n *100)/ GetRequiredEvents()) ;
 246     if (progress <= lastProgress) continue;
 247     lastProgress = progress;
 248     std::cout << "Progress: " << lastProgress << " / 100 " << std::endl;
 249
 250   }
 251
 252   AliInfo(Form("Looped over %d events",GetCurrentEvent()));
 253   WriteHeaderToFile();
 254
 255   for(UShort_t det=1;det<=3;det++) {
 256     if (!fSeenDetectors[det-1]) continue;
 257     std::cout << "FMD" << det << std::endl;
 258     UShort_t firstRing = (det == 1 ? 1 : 0);
 259     for (UShort_t ir = firstRing; ir < 2; ir++) {
 260       Char_t   ring = (ir == 0 ? 'O' : 'I');
 261       UShort_t nsec = (ir == 0 ? 40  : 20);
 262       UShort_t nstr = (ir == 0 ? 256 : 512);
 263
 264       if (fMakeSummaries) MakeSummary(det, ring);
 265
 266       std::cout << " Ring " << ring << ": " << std::flush;
 267       for(UShort_t sec =0; sec < nsec;  sec++)  {
 268         for(UShort_t strip = 0; strip < nstr; strip++) {
 269           Analyse(det,ring,sec,strip);
 270         }
 271         std::cout << '.' << std::flush;
 272       }
 273       if(fSaveHistograms)
 274         diagFile->Flush();
 275       std::cout << "done" << std::endl;
 276     }
 277   }
 278
 279   if(fOutputFile.is_open()) {
 280     fOutputFile.write("# EOF\n",6);
 281     fOutputFile.close();
 282   }
 283
 284   Terminate(diagFile);
 285
 286   if(fSaveHistograms ) {
 287
 288     AliInfo("Closing diagnostics file - please wait ...");
 289     // diagFile->Write();
 290     diagFile->Close();
 291     AliInfo("done");
 292
 293   }
 294 }
 295 //_____________________________________________________________________
 296
 297 void AliFMDBaseDA::InitContainer(TDirectory* diagFile)
 298 {
 299   //Prepare container for diagnostics
 300   TObjArray* detArray;
 301   TObjArray* ringArray;
 302   TObjArray* sectorArray;
 303
 304   TDirectory* savDir   = gDirectory;
 305
 306   for(UShort_t det=1;det<=3;det++) {
 307     detArray = new TObjArray();
 308     detArray->SetOwner();
 309     fDetectorArray.AddAtAndExpand(detArray,det);
 310
 311     TDirectory* detDir = 0;
 312     if (diagFile) {
 313       diagFile->cd();
 314       detDir = diagFile->mkdir(GetDetectorPath(det, kFALSE));
 315     }
 316
 317     UShort_t FirstRing = (det == 1 ? 1 : 0);
 318     for (UShort_t ir = FirstRing; ir < 2; ir++) {
 319       Char_t   ring = (ir == 0 ? 'O' : 'I');
 320       UShort_t nsec = (ir == 0 ? 40  : 20);
 321       UShort_t nstr = (ir == 0 ? 256 : 512);
 322       ringArray = new TObjArray();
 323       ringArray->SetOwner();
 324       detArray->AddAtAndExpand(ringArray,ir);
 325
 326
 327       TDirectory* ringDir = 0;
 328       if (detDir) {
 329         detDir->cd();
 330         ringDir = detDir->mkdir(GetRingPath(det,ring, kFALSE));
 331       }
 332
 333
 334       for(UShort_t sec =0; sec < nsec;  sec++)  {
 335         sectorArray = new TObjArray();
 336         sectorArray->SetOwner();
 337         ringArray->AddAtAndExpand(sectorArray,sec);
 338
 339
 340         TDirectory* secDir = 0;
 341         if (ringDir) {
 342           ringDir->cd();
 343           secDir = ringDir->mkdir(GetSectorPath(det, ring, sec, kFALSE));
 344         }
 345
 346         for(UShort_t strip = 0; strip < nstr; strip++) {
 347           if (secDir) {
 348             secDir->cd();
 349             secDir->mkdir(GetStripPath(det, ring, sec, strip, kFALSE));
 350           }
 351           AddChannelContainer(sectorArray, det, ring, sec, strip);
 352         }
 353       }
 354     }
 355   }
 356   savDir->cd();
 357 }
 358
 359 //_____________________________________________________________________
 360 void AliFMDBaseDA::WriteConditionsData(AliFMDRawReader* fmdReader)
 361 {
 362   //Write the conditions data to file
 363   AliFMDParameters* pars       = AliFMDParameters::Instance();
 364   fConditionsFile.write(Form("# %s \n",pars->GetConditionsShuttleID()),14);
 365   TDatime now;
 366   fConditionsFile << "# This file created from run number " << fRunno
 367                   << " at " << now.AsString() << std::endl;
 368
 369   AliFMDCalibSampleRate* sampleRate = new AliFMDCalibSampleRate();
 370   AliFMDCalibStripRange* stripRange = new AliFMDCalibStripRange();
 371
 372   fmdReader->ReadSODevent(sampleRate,stripRange,fPulseSize,fPulseLength,
 373                           fSeenDetectors);
 374
 375   sampleRate->WriteToFile(fConditionsFile, fSeenDetectors);
 376   stripRange->WriteToFile(fConditionsFile, fSeenDetectors);
 377
 378
 379   // Zero Suppresion
 380
 381   // Strip Range
 382
 383   fConditionsFile.write("# Gain Events \n",15);
 384
 385   for(UShort_t det=1; det<=3;det++) {
 386     if (!fSeenDetectors[det-1]) {
 387       continue;
 388     }
 389     UShort_t firstring = (det == 1 ? 1 : 0);
 390     for(UShort_t iring = firstring; iring <=1;iring++) {
 391       Char_t ring = (iring == 1 ? 'I' : 'O');
 392       for(UShort_t board =0 ; board <=1; board++) {
 393
 394         Int_t idx = GetHalfringIndex(det,ring,board);
 395
 396         fConditionsFile << det                     << ','
 397                         << ring                    << ','
 398                         << board                   << ','
 399                         << fPulseLength.At(idx)    << "\n";
 400
 401       }
 402     }
 403   }
 404
 405   fConditionsFile.write("# Gain Pulse \n",14);
 406
 407   for(UShort_t det=1; det<=3;det++) {
 408     if (!fSeenDetectors[det-1]) {
 409       continue;
 410     }
 411     UShort_t firstring = (det == 1 ? 1 : 0);
 412     for(UShort_t iring = firstring; iring <=1;iring++) {
 413       Char_t ring = (iring == 1 ? 'I' : 'O');
 414       for(UShort_t board =0 ; board <=1; board++) {
 415
 416         Int_t idx = GetHalfringIndex(det,ring,board);
 417
 418         fConditionsFile << det                     << ','
 419                         << ring                    << ','
 420                         << board                   << ','
 421                         << fPulseSize.At(idx)      << "\n";
 422
 423       }
 424     }
 425   }
 426   // sampleRate->WriteToFile(std::cout, fSeenDetectors);
 427   // stripRange->WriteToFile(std::cout, fSeenDetectors);
 428
 429   if(fConditionsFile.is_open()) {
 430
 431     fConditionsFile.write("# EOF\n",6);
 432     fConditionsFile.close();
 433
 434   }
 435
 436 }
 437 //_____________________________________________________________________
 438 Int_t AliFMDBaseDA::GetHalfringIndex(UShort_t det, Char_t ring,
 439                                      UShort_t board) const
 440 {
 441   // Get the index corresponding to a half-ring
 442   //
 443   // Parameters:
 444   //   det    Detector number
 445   //   ring   Ring identifier
 446   //   board  Board number
 447   //
 448   // Return
 449   //   Internal index of the board
 450   UShort_t iring  =  (ring == 'I' ? 1 : 0);
 451
 452   Int_t index = (((det-1) << 2) | (iring << 1) | (board << 0));
 453
 454   return index-2;
 455
 456 }
 457 //_____________________________________________________________________
 458 void AliFMDBaseDA::Rotate(const char* base, int max) const
 459 {
 460   //
 461   // Rotate a set of files.   base is the basic name of the files.
 462   // If the file base.max exists it is removed.
 463   // If the file base.n exists (where n < max) it is renamed to
 464   // base.(n-1).
 465   // If the file base exists, it is renamed to base.1
 466   //
 467   // Parameters:
 468   //   base Base name of the files
 469   //   max  Maximum number to keep (minus one for the current).
 470
 471   // Note:  TSystem::AccessPathName returns false if the condition is
 472   // fulfilled!
 473
 474   // Check if we have base.max, and if so, remove it.
 475   TString testName(Form("%s.%d", base, max));
 476   if (!gSystem->AccessPathName(testName.Data()))
 477     gSystem->Unlink(testName.Data());
 478
 479   // Loop down from max-1 to 1 and move files
 480   for (int i = max-1; i >= 1; i--) {
 481     testName = Form("%s.%d", base, i);
 482     if (!gSystem->AccessPathName(testName.Data())) {
 483       TString newName(Form("%s.%d", base, i+1));
 484       gSystem->Rename(testName.Data(), newName.Data());
 485     }
 486   }
 487
 488   // If we have the file base, rename it to base.1
 489   testName = Form("%s", base);
 490   if (!gSystem->AccessPathName(testName.Data())){
 491     TString newName(Form("%s.%d", base, 1));
 492     gSystem->Rename(testName.Data(), newName.Data());
 493   }
 494 }
 495
 496 //_____________________________________________________________________
 497 TH2*
 498 AliFMDBaseDA::MakeSummaryHistogram(const char* prefix, const char* title,
 499                                    UShort_t d, Char_t r)
 500 {
 501   Int_t nX = ((d == 1 || r == 'I' || r == 'i') ?  20 :  40);
 502   Int_t nY = ((d == 1 || r == 'I' || r == 'i') ? 512 : 256);
 503
 504   TH2* ret = new TH2F(Form("%sFMD%d%c", prefix, d, r),
 505                       Form("%s for FMD%d%c", title, d, r),
 506                       nX, -0.5, nX-0.5, nY, -0.5, nY-0.5);
 507   ret->SetXTitle("Sector #");
 508   ret->SetYTitle("Strip #");
 509
 510   // if (!fSummaries) fSummaries = new TObjArray;
 511   fSummaries.Add(ret);
 512   return ret;
 513 }
 514
 515 //_____________________________________________________________________
 516 //
 517 // EOF
 518 //