FMD/AliFMDDigitizer.cxx

   1  /**************************************************************************
   2  * Copyright(c) 1998-2000, 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  //////////////////////////////////////////////////////////////////////////////
  17 //                                                                           //
  18 //  Forward Multiplicity Detector based on Silicon plates                    //
  19 //  This class contains the procedures simulation ADC  signal for            //
  20 //  the Forward Multiplicity detector  : hits -> digits                      //
  21 //  ADC signal consists                                                      //
  22 //   - number of detector;                                                   //
  23 //   - number of ring;                                                       //
  24 //   - number of sector;                                                     //
  25 //   - ADC signal in this channel                                            //
  26 //                                                                           //
  27  //////////////////////////////////////////////////////////////////////////////
  28
  29 #include <TTree.h>
  30 #include <TVector.h>
  31 #include <TObjArray.h>
  32 #include <TFile.h>
  33 #include <TDirectory.h>
  34 #include <TRandom.h>
  35
  36
  37 #include "AliFMDDigitizer.h"
  38 #include "AliFMD.h"
  39 #include "AliFMDhit.h"
  40 #include "AliFMDdigit.h"
  41 #include "AliRunDigitizer.h"
  42
  43 #include "AliRun.h"
  44 #include "AliLoader.h"
  45 #include "AliRunLoader.h"
  46
  47 #include <stdlib.h>
  48 #include <Riostream.h>
  49 #include <Riostream.h>
  50
  51 ClassImp(AliFMDDigitizer)
  52
  53 //___________________________________________
  54   AliFMDDigitizer::AliFMDDigitizer()  :AliDigitizer()
  55 {
  56 // Default ctor - don't use it
  57   ;
  58 }
  59
  60 //___________________________________________
  61 AliFMDDigitizer::AliFMDDigitizer(AliRunDigitizer* manager)
  62     :AliDigitizer(manager)
  63 {
  64   // ctor which should be used
  65   //  fDebug =0;
  66 #ifdef DEBUG
  67      Info("AliFMDDigitizer"," processed");
  68 #endif
  69 }
  70
  71 //------------------------------------------------------------------------
  72 AliFMDDigitizer::~AliFMDDigitizer()
  73 {
  74 // Destructor
  75
  76 }
  77
  78  //------------------------------------------------------------------------
  79 Bool_t AliFMDDigitizer::Init()
  80 {
  81 // Initialization
  82 // cout<<"AliFMDDigitizer::Init"<<endl;
  83  return kTRUE;
  84 }
  85
  86
  87 //---------------------------------------------------------------------
  88
  89 void AliFMDDigitizer::Exec(Option_t * /*option*/)
  90 {
  91
  92   /*
  93    Conver hits to digits:
  94    - number of detector;
  95    - number of ring;
  96    - number of sector;
  97    - ADC signal in this channel
  98   */
  99
 100   AliRunLoader *inRL, *outRL;//in and out Run Loaders
 101   AliLoader *pInFMD, *pOutFMD;// in and out ITSLoaders
 102
 103   outRL = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
 104   pOutFMD = outRL->GetLoader("FMDLoader");
 105
 106
 107 #ifdef DEBUG
 108   Info("Hits2Digits Exec"," start...";
 109 #endif
 110
 111
 112   Int_t volume, sector, ring, charge;
 113   Float_t e;
 114   Float_t de[10][50][520];
 115   Int_t hit;
 116   Int_t digit[5];
 117   Int_t ivol, iSector, iRing;
 118   for (Int_t i=0; i<10; i++)
 119     for(Int_t j=0; j<50; j++)
 120       for(Int_t ij=0; ij<520; ij++)
 121      de[i][j][ij]=0;
 122   Int_t numberOfRings[5]= {512,256,512,256,512};
 123   Int_t numberOfSector[5] =  {20,40,20,40,20};
 124
 125   AliFMDhit *fmdHit=0;
 126   TTree *tH=0;
 127   TBranch *brHits=0;
 128   TBranch *brD=0;
 129
 130   inRL = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
 131
 132   if (inRL == 0x0)
 133     {
 134       Error("Exec","Can not find Run Loader for input stream 0");
 135       return;
 136     }
 137
 138   if (!inRL->GetAliRun()) inRL->LoadgAlice();
 139
 140   AliFMD * fFMD = (AliFMD *) inRL->GetAliRun()->GetDetector("FMD");
 141
 142   if (fFMD == 0x0)
 143    {
 144      Error("Exec","Can not get FMD from gAlice");
 145      return;
 146    }
 147 // Loop over files to digitize
 148
 149   Int_t nFiles=GetManager()->GetNinputs();
 150   for (Int_t inputFile=0; inputFile<nFiles;inputFile++)
 151    {
 152
 153 #ifdef DEBUG
 154   Info(" Digitizing event number ",fManager->GetOutputEventNr()) ;
 155 #endif
 156
 157     if (fFMD)
 158      {
 159
 160       inRL = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
 161       pInFMD = inRL->GetLoader("FMDLoader");
 162       pInFMD->LoadHits("READ");
 163
 164
 165       tH = pInFMD->TreeH();
 166       if (tH == 0x0)
 167        {
 168          pInFMD->LoadHits("read");
 169          tH = pInFMD->TreeH();
 170        }
 171       brHits = tH->GetBranch("FMD");
 172       if (brHits) {
 173           fFMD->SetHitsAddressBranch(brHits);
 174       }else{
 175         Fatal("Exec","EXEC Branch FMD hit not found");
 176       }
 177       TClonesArray *fFMDhits = fFMD->Hits ();
 178
 179       Int_t ntracks    = (Int_t) tH->GetEntries();
 180
 181       for (Int_t track = 0; track < ntracks; track++)
 182        {
 183          brHits->GetEntry(track);
 184          Int_t nhits = fFMDhits->GetEntries ();
 185
 186          for (hit = 0; hit < nhits; hit++)
 187            {
 188              fmdHit = (AliFMDhit *) fFMDhits->UncheckedAt(hit);
 189
 190              volume = fmdHit->Volume ();
 191              sector = fmdHit->NumberOfSector ();
 192              ring = fmdHit->NumberOfRing ();
 193              e = fmdHit->Edep ();
 194              de[volume][sector][ring] += e;
 195
 196            }          //hit loop
 197        }               //track loop
 198     }
 199 //if FMD
 200    }
 201
 202
 203   // Put noise and make ADC signal
 204    Float_t mipI = 1.664 * 0.04 * 2.33 / 22400;     // = 6.923e-6;
 205    for ( ivol=1; ivol<=5; ivol++){
 206      for ( iSector=1; iSector<=numberOfSector[ivol-1]; iSector++){
 207        for ( iRing=1; iRing<=numberOfRings[ivol-1]; iRing++){
 208          digit[0]=ivol;
 209          digit[1]=iSector;
 210          digit[2]=iRing;
 211          charge = Int_t (de[ivol][iSector][iRing] / mipI);
 212          Int_t pedestal=Int_t(gRandom->Gaus(500,250));
 213   //       digit[3]=PutNoise(charge);
 214          digit[3]=charge + pedestal;
 215          if(digit[3]<= 500) digit[3]=500;
 216     //dynamic range from MIP(0.155MeV) to 30MIP(4.65MeV)
 217     //1024 ADC channels
 218          Float_t channelWidth=(22400*50)/1024;
 219          digit[4]=Int_t(digit[3]/channelWidth);
 220          if (digit[4]>1024) digit[4]=1024;
 221          fFMD->AddDigit(digit);
 222        } //ivol
 223      } //iSector
 224    } //iRing
 225
 226    pOutFMD->LoadDigits("update");
 227    TTree* treeD = pOutFMD->TreeD();
 228
 229    if (treeD == 0x0) {
 230      pOutFMD->MakeTree("D");
 231      treeD = pOutFMD->TreeD();
 232
 233    }
 234
 235    treeD->Reset();
 236    fFMD->MakeBranchInTreeD(treeD);
 237    brD = treeD->GetBranch("FMD");
 238
 239
 240    treeD->Fill();
 241
 242    pOutFMD->WriteDigits("OVERWRITE");
 243    pOutFMD->UnloadHits();
 244    pOutFMD->UnloadDigits();
 245    fFMD->ResetDigits();
 246 }
 247
 248
 249
 250
 251