MUON/AliMUONDigitizerv2.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 //  Do the Digitization (Digit) from summable Digits (SDigit)
  19 //  Allow the merging of signal file with background file(s).
  20
  21 /////////////////////////////////////////////////////////////////////////////////
  22 //
  23 // AliMUONDigitizerv2 digitizes digits from s-digits.
  24 // Merging is allowed from multiple input streams. The first input stream is
  25 // assumed to be the signal and all other input streams as assumed to be
  26 // background.
  27 // Chamber response is applied to the digits identically to AliMUONDigitizerv1.
  28 //
  29 /////////////////////////////////////////////////////////////////////////////////
  30
  31 #include "AliMUON.h"
  32 #include "AliMUONData.h"
  33 #include "AliMUONLoader.h"
  34 #include "AliMUONConstants.h"
  35 #include "AliMUONChamber.h"
  36 #include "AliMUONDigit.h"
  37 #include "AliMUONDigitizerv2.h"
  38 #include "AliMUONTransientDigit.h"
  39 #include "AliLog.h"
  40
  41 ClassImp(AliMUONDigitizerv2)
  42
  43 //___________________________________________
  44 AliMUONDigitizerv2::AliMUONDigitizerv2() : AliMUONDigitizer()
  45 {
  46 /// Default ctor - don't use it
  47 }
  48
  49 //___________________________________________
  50 AliMUONDigitizerv2::AliMUONDigitizerv2(AliRunDigitizer* manager) : AliMUONDigitizer(manager)
  51 {
  52 /// ctor which should be used
  53 }
  54
  55 //___________________________________________
  56 AliMUONDigitizerv2::~AliMUONDigitizerv2()
  57 {
  58 /// Destructor
  59 }
  60
  61 //-----------------------------------------------------------------------
  62 void AliMUONDigitizerv2::GenerateTransientDigits()
  63 {
  64 /// Loop over all chambers and s-digits in the input stream and create
  65 /// AliMUONTransientDigit objects from them. These are then added to fTDList.
  66
  67         AliDebug(2,"Generating transient digits using treeH = 0x%X");
  68         //
  69         // Loop over SDigits
  70         Int_t ndig, k;
  71         AliMUONDigit* sDigit;
  72         TClonesArray* muonSDigits;
  73         for (Int_t ich = 0; ich < AliMUONConstants::NCh(); ich++)  // loop over chamber
  74         {
  75                 fMUONData->ResetSDigits();
  76                 fMUONData->GetSDigits();
  77                 muonSDigits = fMUONData->SDigits(ich);
  78                 ndig = muonSDigits->GetEntriesFast();
  79                 for (k = 0; k < ndig; k++)
  80                 {
  81                         sDigit = (AliMUONDigit*) muonSDigits->UncheckedAt(k);
  82                         MakeTransientDigitFromSDigit(ich,sDigit);
  83                 }
  84 //              fMUONData->ResetSDigits();
  85 //              fMUONData->GetCathodeS(1);
  86 //              muonSDigits = fMUONData->SDigits(ich);
  87 //              ndig=muonSDigits->GetEntriesFast();
  88 //              for (k = 0; k < ndig; k++)
  89 //              {
  90 //                      sDigit = (AliMUONDigit*) muonSDigits->UncheckedAt(k);
  91 //                      MakeTransientDigitFromSDigit(ich,sDigit);
  92 //              }
  93         } // SDigits loop, end loop over chamber
  94 }
  95
  96 //------------------------------------------------------------------------
  97 void AliMUONDigitizerv2::MakeTransientDigitFromSDigit(Int_t iChamber, AliMUONDigit* sDigit)
  98 {
  99 /// Makes a transient digit from the specified s-digit from the specified chamber.
 100 /// Once the digit is created it is added to the fTDList.
 101
 102         AliDebug(4,Form("Making transient digit from s-digit for chamber %d.", iChamber));
 103         Int_t digits[7];
 104         //
 105         // Creating a new TransientDigits from SDigit
 106         digits[0] = sDigit->PadX();  // Padx of the Digit
 107         digits[1] = sDigit->PadY();  // Pady of the Digit
 108         digits[2] = sDigit->Cathode()+1;  // Cathode plane
 109         digits[3] = sDigit->Signal();  // Induced charge in the Pad
 110         if (fSignal)
 111                 digits[4] = sDigit->Signal();
 112         else
 113                 digits[4] = 0;
 114
 115         digits[5] = sDigit->Hit();    // Hit number in the list
 116         digits[6] = sDigit->DetElemId();
 117
 118         AliDebug(5,Form("Made digit from sDigit 0x%X: PadX %d\tPadY %d\tPlane %d\tCharge %d\tHit %d\tidDE %d",
 119                         (void*)sDigit, digits[0], digits[1], digits[2], digits[3], digits[5], digits[6]));
 120
 121
 122         AliMUONTransientDigit* mTD = new AliMUONTransientDigit(iChamber, digits);
 123         // Copy list of tracks and trackcharge
 124         for(Int_t itrack = 0; itrack < sDigit->Ntracks(); ++itrack)
 125         {
 126                 Int_t track = sDigit->Track(itrack);
 127                 if (track < 0) break;  // Check if we reached the end of the track list.
 128                 mTD->AddToTrackList( track + fMask, sDigit->TrackCharge(itrack) );
 129         }
 130
 131         OnCreateTransientDigit(mTD, sDigit);
 132         AddOrUpdateTransientDigit(mTD);
 133 }
 134
 135 //------------------------------------------------------------------------
 136 void AliMUONDigitizerv2::AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7])
 137 {
 138 /// Override to add new digits to the digits tree TreeD.
 139         fMUONData->AddDigit(chamber, tracks, charges, digits);
 140 }
 141
 142 //------------------------------------------------------------------------
 143 Int_t AliMUONDigitizerv2::GetSignalFrom(AliMUONTransientDigit* td)
 144 {
 145 /// Derived to apply the chamber response model to the digit.
 146 /// Using AliMUONChamber::ResponseModel() for this.
 147
 148         AliDebug(4, "Applying response of chamber to TransientDigit signal.");
 149         //
 150         //  Digit Response (noise, threshold, saturation, ...)
 151         Int_t q = td->Signal();
 152         AliMUONChamber& chamber = fMUON->Chamber(td->Chamber());
 153         AliMUONResponse* response = chamber.ResponseModel();
 154         q = response->DigitResponse(q, td);
 155   if ( q >= response->Saturation() )
 156   {
 157     td->Saturated(kTRUE);
 158   }
 159         return q;
 160 }
 161
 162 //------------------------------------------------------------------------
 163 Bool_t AliMUONDigitizerv2::InitInputData(AliMUONLoader* muonloader)
 164 {
 165 /// Overridden to initialize fMUONData to read from the s-digits tree TreeS.
 166 /// If the s-digits are not loaded then the muon loader is used to load the
 167 /// s-digits into memory.
 168
 169         AliDebug(3,"Loading s-digits in READ mode and setting the tree address.");
 170         fMUONData->SetLoader(muonloader);
 171
 172         if (muonloader->TreeS() == NULL)
 173         {
 174                 muonloader->LoadSDigits("READ");
 175                 if (muonloader->TreeS() == NULL)
 176                 {
 177                         AliError("Can not load the s-digits tree.");
 178                         return kFALSE;
 179                 }
 180         }
 181
 182         fMUONData->SetTreeAddress("S");
 183         return kTRUE;
 184 }
 185
 186 //------------------------------------------------------------------------
 187 void AliMUONDigitizerv2::CleanupInputData(AliMUONLoader* muonloader)
 188 {
 189 /// Overridden to release and unload s-digits from memory.
 190
 191         AliDebug(3,"Releasing loaded s-digits.");
 192         fMUONData->ResetSDigits();
 193         muonloader->UnloadSDigits();
 194 }
 195
 196 //------------------------------------------------------------------------
 197 Bool_t AliMUONDigitizerv2::InitOutputData(AliMUONLoader* muonloader)
 198 {
 199 /// Derived to initialize the output digits tree TreeD, create it if necessary
 200 /// and sets the fMUONData tree address to treeD.
 201
 202         AliDebug(3, "Creating digits branch and setting the tree address.");
 203
 204         fMUONData->SetLoader(muonloader);
 205
 206         // New branch per chamber for MUON digit in the tree of digits
 207         if (muonloader->TreeD() == NULL)
 208         {
 209                 muonloader->MakeDigitsContainer();
 210                 if (muonloader->TreeD() == NULL)
 211                 {
 212                         AliError("Could not create TreeD.");
 213                         return kFALSE;
 214                 }
 215         }
 216
 217         fMUONData->MakeBranch("D");
 218         fMUONData->SetTreeAddress("D");
 219
 220         return kTRUE;
 221 }
 222
 223 //------------------------------------------------------------------------
 224 void AliMUONDigitizerv2::FillOutputData()
 225 {
 226 /// Derived to fill TreeD and resets the digit array in fMUONData.
 227
 228         AliDebug(3, "Filling trees with digits.");
 229         fMUONData->Fill("D");
 230         fMUONData->ResetDigits();
 231 }
 232
 233 //------------------------------------------------------------------------
 234 void AliMUONDigitizerv2::CleanupOutputData(AliMUONLoader* muonloader)
 235 {
 236 /// Derived to write the digits tree and then unload the digits tree once written.
 237
 238         AliDebug(3, "Writing digits and releasing pointers.");
 239         muonloader->WriteDigits("OVERWRITE");
 240         muonloader->UnloadDigits();
 241 }
 242
 243