ACORDE/AliACORDEDigitizer.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, 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 /* $Id$ */
  17
  18 ///_________________________________________________________________________
  19 ///
  20 /// This class constructs Digits out of Hits
  21 ///
  22 ///
  23
  24 // --- Standard library ---
  25
  26 // --- ROOT system ---
  27 #include <TMath.h>
  28 #include <TTree.h>
  29 #include <TRandom.h>
  30
  31 // --- AliRoot header files ---
  32 #include "AliRun.h"
  33 #include "AliACORDE.h"
  34 #include "AliACORDEhit.h"
  35 #include "AliRunLoader.h"
  36 #include "AliLoader.h"
  37 #include "AliDigitizationInput.h"
  38 #include "AliCDBManager.h"
  39 #include "AliCDBStorage.h"
  40 #include "AliCDBEntry.h"
  41 #include "AliACORDECalibData.h"
  42 #include "AliACORDEConstants.h"
  43
  44 #include "AliACORDEdigit.h"
  45 #include "AliACORDEDigitizer.h"
  46
  47 ClassImp(AliACORDEDigitizer)
  48
  49 AliACORDEDigitizer::AliACORDEDigitizer()
  50   :AliDigitizer(),
  51    fCalibData(GetCalibData()),
  52    fNdigits(0),
  53    fDigits(0)
  54
  55 {
  56   // default constructor
  57 }
  58
  59 AliACORDEDigitizer::AliACORDEDigitizer(AliDigitizationInput* digInput)
  60   :AliDigitizer(digInput),
  61    fCalibData(GetCalibData()),
  62    fNdigits(0),
  63    fDigits(0)
  64
  65 {
  66   // constructor
  67
  68 }
  69
  70 AliACORDEDigitizer::~AliACORDEDigitizer()
  71 {
  72   // destructor
  73
  74   if (fDigits) {
  75     fDigits->Delete();
  76     delete fDigits;
  77     fDigits=0;
  78   }
  79 }
  80
  81
  82 Bool_t AliACORDEDigitizer::Init()
  83 {
  84   // Initialises the digitizer
  85
  86   // Initialises the Digit array
  87   fDigits = new TClonesArray ("AliACORDEdigit", 1000);
  88
  89   return kTRUE;
  90 }
  91
  92 void AliACORDEDigitizer::Digitize(Option_t* /*option*/)
  93 {
  94
  95   // Creates digits from hits
  96
  97   // 1.- create and initialize temporal variables
  98   // 2.- get loaders to access hots and digits
  99   // 3.- loop over all input.
 100   //     3.1 for each input loop over all track
 101   //     3.2 for each track loop over all hits
 102   //     3.3 for each hit, check
 103   //         if energy above threshold
 104   //         if survives efficiency
 105   //         then store the plastic, the time and track in temp arrays
 106   //         if a hit already survived for this plastic take the hit
 107   //         with the lowest time
 108   // 4.- loop over temporal array
 109   //     if both plastic have a surviving hit and the time
 110   //     difference is below the limit, add a new digit
 111   //
 112
 113
 114   // 1.- temporal variables
 115   Float_t emin = AliACORDEConstants::Instance()->HitEnergyThreshold();
 116   Float_t td = AliACORDEConstants::Instance()->MaxHitTimeDifference();
 117   Int_t modules[60]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 118   Int_t moduls[60]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 119   Int_t mods;
 120   Float_t PlasticTimes[2][60];
 121   Int_t PlasticTracks[2][60];
 122   for (Int_t i=0;i<60;i++) {
 123     PlasticTimes[0][i]=-1.0;
 124     PlasticTimes[1][i]=-1.0;
 125     PlasticTracks[0][i]=-1;
 126     PlasticTracks[1][i]=-1;
 127   }
 128
 129   // 2.- get loaders
 130   AliRunLoader* outRunLoader =
 131     AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
 132   if (!outRunLoader) {
 133     Error("Exec", "Can not get output Run Loader");
 134     return;}
 135
 136   AliLoader* outLoader = outRunLoader->GetLoader("ACORDELoader");
 137   if (!outLoader) {
 138     Error("Exec", "Can not get output ACORDE Loader");
 139     return;}
 140
 141   outLoader->LoadDigits("update");
 142   if (!outLoader->TreeD()) outLoader->MakeTree("D");
 143   outLoader->MakeDigitsContainer();
 144   TTree* treeD  = outLoader->TreeD();
 145   Int_t bufsize = 16000;
 146   treeD->Branch("ACORDEdigit", &fDigits, bufsize);
 147
 148   // 3. loop over inputs
 149   for (Int_t iInput = 0; iInput < fDigInput->GetNinputs(); iInput++) {
 150     AliRunLoader* runLoader =
 151       AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(iInput));
 152     AliLoader* loader = runLoader->GetLoader("ACORDELoader");
 153     if (!loader) {
 154       Error("Exec", "Can not get ACORDE Loader for input %d", iInput);
 155       continue;}
 156
 157     if (!runLoader->GetAliRun()) runLoader->LoadgAlice();
 158
 159     AliACORDE* acorde = (AliACORDE*) runLoader->GetAliRun()->GetDetector("ACORDE");
 160     if (!acorde) {
 161       Error("Exec", "No ACORDE detector for input %d", iInput);
 162       continue;}
 163
 164     loader->LoadHits();
 165     TTree* treeH = loader->TreeH();
 166     if (!treeH) {
 167       Error("Exec", "Cannot get TreeH for input %d", iInput);
 168       continue; }
 169
 170     TClonesArray* hits = acorde->Hits();
 171
 172     // 3.1 loop over all tracks
 173     Int_t nTracks = (Int_t) treeH->GetEntries();
 174     for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
 175       acorde->ResetHits();
 176       treeH->GetEvent(iTrack);
 177       Int_t nHits = hits->GetEntriesFast();
 178       // 3.2 loop over hits
 179       for (Int_t iHit = 0; iHit < nHits; iHit++) {
 180         AliACORDEhit* hit = (AliACORDEhit *)hits->UncheckedAt(iHit);
 181         // 3.3 select hit
 182         // get hit info
 183         Float_t eloss_mev = hit->Eloss()*1000.0;
 184         Int_t module = hit->GetModule();
 185         modules[module]=1;
 186         Int_t plastic = hit->GetPlastic();
 187         Float_t time_ns = hit->GetTime()*1e9;
 188         Float_t eff = TMath::Sqrt(fCalibData->GetEfficiency(module));
 189         // if enough energy and efficiency
 190         if( eloss_mev > emin && gRandom->Uniform() < eff ) {
 191           // if first hit or earlier track
 192           if ((PlasticTimes[plastic-1][module-1] == -1.0) ||
 193               (PlasticTimes[plastic-1][module-1] > time_ns) ) {
 194             PlasticTimes[plastic-1][module-1]= time_ns;
 195             PlasticTracks[plastic-1][module-1]= hit->GetTrack();
 196           }
 197         }
 198       } // end of hit   loop
 199     } // end of track loop
 200     for(Int_t i=0;i<60;i++){moduls[i]=modules[i];}
 201
 202     loader->UnloadHits();
 203
 204   }  // end of input loop
 205
 206   // 4.- loop over temporal arrays to add hits
 207   Int_t tracks[3]={-1,-1,-1};
 208   for (Int_t i=0; i<60; i++) {
 209     // if both modules have a hit
 210     // if time diff small enough
 211     Float_t diff = TMath::Abs(PlasticTimes[0][i]-PlasticTimes[1][i]);
 212     if (diff < td) {
 213       tracks[0] = PlasticTracks[0][i];
 214       if (PlasticTracks[0][i] != PlasticTracks[1][i])
 215         tracks[1] = PlasticTracks[1][i];
 216       if(moduls[i]==1) {
 217         mods = i;
 218         //      Float_t module_time = (PlasticTimes[0][i] > PlasticTimes[1][i] ?
 219         //                             PlasticTimes[0][i] : PlasticTimes[1][i]);
 220         //      AddDigit(tracks, mods, module_time);
 221         AddDigit(tracks, mods, 0);
 222       }
 223     }
 224   }
 225   treeD->Fill();
 226   outLoader->WriteDigits("OVERWRITE");
 227   outLoader->UnloadDigits();
 228   ResetDigit();
 229 }
 230
 231 //____________________________________________________________________________
 232
 233 void AliACORDEDigitizer::AddDigit(Int_t* track, Int_t module, Float_t time)
 234 {
 235
 236   // Adds Digit
 237
 238   TClonesArray &ldigits = *fDigits;
 239   new(ldigits[fNdigits++]) AliACORDEdigit(track,module,time);
 240 }
 241
 242 void AliACORDEDigitizer::AddDigit(Int_t* modul,Float_t time)
 243 {
 244         // MRC Adds Digit
 245   TClonesArray &ldigits = *fDigits;
 246   new(ldigits[fNdigits++]) AliACORDEdigit(modul,time);
 247
 248
 249 }
 250 void AliACORDEDigitizer::ResetDigit()
 251 {
 252 //
 253 // Clears Digits
 254 //
 255   fNdigits = 0;
 256   if (fDigits) fDigits->Delete();
 257 }
 258
 259
 260 AliACORDECalibData* AliACORDEDigitizer::GetCalibData() const
 261
 262 {
 263   AliCDBManager *man = AliCDBManager::Instance();
 264
 265   AliCDBEntry *entry=0;
 266
 267   entry = man->Get("ACORDE/Calib/Data");
 268
 269   if(!entry){
 270     AliWarning("Load of calibration data from default storage failed!");
 271     AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
 272     Int_t runNumber = man->GetRun();
 273     entry = man->GetStorage("local://$ALICE_ROOT/OCDB")
 274       ->Get("ACORDE/Calib/Data",runNumber);
 275
 276   }
 277
 278   // Retrieval of data in directory ACORDE/Calib/Data:
 279
 280
 281   AliACORDECalibData *calibdata = 0;
 282
 283   if (entry) calibdata = (AliACORDECalibData*) entry->GetObject();
 284   if (!calibdata)  AliError("No calibration data from calibration database !");
 285
 286
 287   return calibdata;
 288
 289 }
 290