START/AliSTARTDigitizer.cxx

   1
   2 /**************************************************************************
   3  * Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights reserved. *
   4  *                                                                        *
   5  * Author: The ALICE Off-line Project.                                    *
   6  * Contributors are mentioned in the code where appropriate.              *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16
  17
  18 #include <TTree.h>
  19 #include <TFile.h>
  20 #include <TDirectory.h>
  21 #include <TRandom.h>
  22 #include <TArrayI.h>
  23 #include <TError.h>
  24 #include <TH1F.h>
  25
  26 #include "AliLog.h"
  27 #include "AliSTARTDigitizer.h"
  28 #include "AliSTART.h"
  29 #include "AliSTARThit.h"
  30 #include "AliSTARTdigit.h"
  31 #include "AliRunDigitizer.h"
  32 #include <AliDetector.h>
  33 #include "AliRun.h"
  34 #include <AliLoader.h>
  35 #include <AliRunLoader.h>
  36 #include <stdlib.h>
  37 #include <Riostream.h>
  38 #include <Riostream.h>
  39
  40 ClassImp(AliSTARTDigitizer)
  41
  42 //___________________________________________
  43   AliSTARTDigitizer::AliSTARTDigitizer()  :AliDigitizer()
  44 {
  45 // Default ctor - don't use it
  46   ;
  47 }
  48
  49 //___________________________________________
  50 AliSTARTDigitizer::AliSTARTDigitizer(AliRunDigitizer* manager)
  51     :AliDigitizer(manager)
  52 {
  53   //    cout<<"AliSTARTDigitizer::AliSTARTDigitizer"<<endl;
  54 // ctor which should be used
  55
  56   AliDebug(1,"processed");
  57
  58   ftimeTDC = new TArrayI(24);
  59   fADC = new TArrayI(24);
  60
  61   TFile* file = TFile::Open("$ALICE_ROOT/START/PMTefficiency.root");
  62   fEff = (TH1F*) file->Get("hEff")->Clone();
  63   fEff->SetDirectory(NULL);
  64   file->Close();
  65   delete file;
  66 }
  67
  68 //------------------------------------------------------------------------
  69 AliSTARTDigitizer::~AliSTARTDigitizer()
  70 {
  71 // Destructor
  72
  73   AliDebug(1,"START");
  74   delete ftimeTDC;
  75   delete fADC;
  76   delete fEff;
  77 }
  78
  79  //------------------------------------------------------------------------
  80 Bool_t AliSTARTDigitizer::Init()
  81 {
  82 // Initialization
  83   AliDebug(1," Init");
  84  return kTRUE;
  85 }
  86
  87
  88 //---------------------------------------------------------------------
  89
  90 void AliSTARTDigitizer::Exec(Option_t* /*option*/)
  91 {
  92
  93   /*
  94     Produde digits from hits
  95         digits is TObject and includes
  96         We are writing array if left & right  TDC
  97         left & right  ADC (will need for slow simulation)
  98         TOF first particle left & right
  99         mean time and time difference (vertex position)
 100
 101   */
 102
 103   AliRunLoader *inRL, *outRL;//in and out Run Loaders
 104   AliLoader *pInStartLoader, *pOutStartLoader;// in and out STARTLoaders
 105
 106   outRL = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
 107   pOutStartLoader = outRL->GetLoader("STARTLoader");
 108
 109   AliDebug(1,"start...");
 110
 111   //
 112   // From hits to digits
 113   //
 114   Int_t hit, nhits;
 115   Float_t meanTime;
 116   Int_t countE[24];
 117   Int_t volume,pmt,tr,sumRight;
 118   Int_t  bestRightTDC,bestLeftTDC;
 119   Float_t time[24]={24*0};
 120   Float_t besttime[24]={24*0};
 121   Float_t timeGaus[37]={24*0};
 122   Float_t channelWidth=25.; //ps
 123
 124   AliSTARThit  *startHit;
 125   TBranch *brHits=0;
 126
 127   pOutStartLoader->LoadDigits("UPDATE");//probably it is necessary to load them before
 128   fdigits= new AliSTARTdigit();
 129   pOutStartLoader->GetDigitsDataLoader()->GetBaseLoader(0)->Post(fdigits);
 130
 131   Int_t nFiles=fManager->GetNinputs();
 132   for (Int_t inputFile=0; inputFile<nFiles;  inputFile++) {
 133     if (inputFile < nFiles-1) {
 134       AliWarning(Form("ignoring input stream %d", inputFile));
 135       continue;
 136
 137     }
 138
 139     Float_t besttimeright=9999.;
 140     Float_t besttimeleft=9999.;
 141     Float_t timeDiff;
 142     sumRight=0;
 143     for (Int_t i0=0; i0<24; i0++)
 144       {
 145         time[i0]=9999;  besttime[i0]=9999;      countE[i0]=0;
 146       }
 147
 148     inRL = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
 149     if (!inRL->GetAliRun()) inRL->LoadgAlice();
 150     AliSTART *fSTART  = (AliSTART*) inRL->GetAliRun()->GetDetector("START");
 151     pInStartLoader = inRL->GetLoader("STARTLoader");
 152     pInStartLoader->LoadHits("READ");//probably it is necessary to load them before
 153     TClonesArray *fHits = fSTART->Hits ();
 154
 155     TTree *th = pInStartLoader->TreeH();
 156     brHits = th->GetBranch("START");
 157     if (brHits) {
 158       fSTART->SetHitsAddressBranch(brHits);
 159     }else{
 160        AliError("Branch START hit not found");
 161       exit(111);
 162     }
 163     Int_t ntracks    = (Int_t) th->GetEntries();
 164
 165     if (ntracks<=0) return;
 166     // Start loop on tracks in the hits containers
 167     for (Int_t track=0; track<ntracks;track++) {
 168       brHits->GetEntry(track);
 169       nhits = fHits->GetEntriesFast();
 170        for (hit=0;hit<nhits;hit++)
 171         {
 172           startHit   = (AliSTARThit*) fHits->UncheckedAt(hit);
 173           if (!startHit) {
 174             AliError("The unchecked hit doesn't exist");
 175             break;
 176           }
 177           pmt=startHit->Pmt();
 178           Int_t numpmt=pmt-1;
 179           Float_t e=startHit->Etot();
 180           volume = startHit->Volume();
 181           if(RegisterPhotoE(e)) countE[numpmt]++;
 182           besttime[numpmt] = startHit->Time();
 183           if(besttime[numpmt]<time[numpmt])
 184             {
 185               time[numpmt]=besttime[numpmt];
 186             }
 187
 188         } //hits loop
 189     } //track loop
 190
 191     //best time right&left
 192     for (Int_t ipmt=0; ipmt<12; ipmt++)
 193       {
 194         timeGaus[ipmt]=gRandom->Gaus(time[ipmt],0.025);
 195         if(timeGaus[ipmt]<besttimeleft) besttimeleft=timeGaus[ipmt]; //timeleft
 196       }
 197     for ( Int_t ipmt=12; ipmt<24; ipmt++)
 198       {
 199         timeGaus[ipmt]=gRandom->Gaus(time[ipmt],0.025);
 200         if(timeGaus[ipmt]<besttimeright)  besttimeright=timeGaus[ipmt]; //timeright
 201       }// besttime
 202
 203     //folding with experimental time distribution
 204       Float_t c = 29.9792; // mm/ns
 205     Float_t koef=(350.-69.7)/c;
 206     Float_t  besttimeleftR= besttimeleft;
 207     besttimeleft=koef+besttimeleft;
 208     bestLeftTDC=Int_t (besttimeleftR*1000/channelWidth);
 209     bestRightTDC=Int_t (besttimeright*1000/channelWidth);
 210     timeDiff=(c*(besttimeright-besttimeleftR)-(350.-69.7))/(2*c);
 211     meanTime=(besttimeright+besttimeleftR)/2.;
 212     Float_t ds=(c*(besttimeright-besttimeleftR)-(350.-69.7))/2;
 213     AliDebug(2,Form(" timediff in ns %f  z= %f real point%f",timeDiff,timeDiff*c,ds));
 214
 215
 216     // Time to TDC signal
 217     Int_t iTimeAv=Int_t (meanTime*1000/channelWidth);
 218     // time  channel numbres
 219     //       fill digits
 220     fdigits->SetTimeBestLeft(bestLeftTDC);
 221     fdigits->SetTimeBestRight(bestRightTDC);
 222     fdigits->SetMeanTime(iTimeAv);
 223
 224     //ADC features
 225
 226     for (Int_t i=0; i<24; i++)
 227       {
 228
 229         //  fill TDC
 230         tr= Int_t (timeGaus[i]*1000/channelWidth);
 231         if(timeGaus[i]>100) tr=0;
 232         ftimeTDC->AddAt(tr,i);
 233
 234         //fill ADC
 235         Int_t al= countE[i]; //1024 - channel width shoul be change
 236         fADC->AddAt(al,i);
 237       } //pmt loop
 238
 239     fdigits->SetTime(*ftimeTDC);
 240     fdigits->SetADC(*fADC);
 241
 242     pInStartLoader->UnloadHits();
 243
 244   } //input streams loop
 245
 246   pOutStartLoader->WriteDigits("OVERWRITE");
 247   pOutStartLoader->UnloadDigits();
 248 }
 249
 250
 251 //------------------------------------------------------------------------
 252 Bool_t AliSTARTDigitizer::RegisterPhotoE(Float_t e)
 253 {
 254
 255
 256   //  Float_t hc=197.326960*1.e6; //mev*nm
 257   Float_t hc=1.973*1.e-6; //gev*nm
 258   Float_t lambda=hc/e;
 259   Int_t bin=  fEff->GetXaxis()->FindBin(lambda);
 260   Float_t eff=fEff->GetBinContent(bin);
 261   Double_t  p = gRandom->Rndm();
 262   if (p > eff)
 263     return kFALSE;
 264
 265   return kTRUE;
 266 }
 267 //----------------------------------------------------------------------------