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