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    fSTART(0),
  53    fHits(0),
  54    fdigits(0),
  55    ftimeTDC(0),
  56    fADC(0),
  57    fEff(0)
  58 {
  59   //    cout<<"AliSTARTDigitizer::AliSTARTDigitizer"<<endl;
  60 // ctor which should be used
  61
  62   AliDebug(1,"processed");
  63
  64   fSTART = 0;
  65   fPhotons = 0;
  66   fHits = 0;
  67   fdigits = 0;
  68
  69   ftimeTDC = new TArrayI(36);
  70   fADC = new TArrayI(36);
  71
  72   TFile* file = TFile::Open("$ALICE_ROOT/START/PMTefficiency.root");
  73   fEff = (TH1F*) file->Get("hEff")->Clone();
  74   fEff->SetDirectory(NULL);
  75   file->Close();
  76   delete file;
  77 }
  78
  79 //------------------------------------------------------------------------
  80 AliSTARTDigitizer::~AliSTARTDigitizer()
  81 {
  82 // Destructor
  83
  84   AliDebug(1,"START");
  85
  86   delete ftimeTDC;
  87   delete fADC;
  88   delete fEff;
  89 }
  90
  91  //------------------------------------------------------------------------
  92 Bool_t AliSTARTDigitizer::Init()
  93 {
  94 // Initialization
  95   AliDebug(1," Init");
  96  return kTRUE;
  97 }
  98
  99
 100 //---------------------------------------------------------------------
 101
 102 void AliSTARTDigitizer::Exec(Option_t* /*option*/)
 103 {
 104
 105   /*
 106     Produde digits from hits
 107         digits is TObject and includes
 108         We are writing array if left & right  TDC
 109         left & right  ADC (will need for slow simulation)
 110         TOF first particle left & right
 111         mean time and time difference (vertex position)
 112
 113   */
 114
 115   AliRunLoader *inRL, *outRL;//in and out Run Loaders
 116   AliLoader *pInStartLoader, *pOutStartLoader;// in and out STARTLoaders
 117
 118   outRL = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
 119   pOutStartLoader = outRL->GetLoader("STARTLoader");
 120
 121   AliDebug(1,"start...");
 122
 123   //
 124   // From hits to digits
 125   //
 126   Int_t hit, nhits;
 127   Float_t meanTime;
 128   Int_t countE[36];
 129   Int_t volume,pmt,tr,sumRight;
 130   Int_t  bestRightTDC,bestLeftTDC;
 131   Float_t time[36]={36*0};
 132   Float_t besttime[36]={36*0};
 133   Float_t timeGaus[36]={36*0};
 134   Float_t channelWidth=25.; //ps
 135
 136   AliSTARThit  *startHit;
 137   TBranch *brHits=0;
 138
 139   pOutStartLoader->LoadDigits("UPDATE");//probably it is necessary to load them before
 140   fdigits= new AliSTARTdigit();
 141   pOutStartLoader->GetDigitsDataLoader()->GetBaseLoader(0)->Post(fdigits);
 142
 143   Int_t nFiles=fManager->GetNinputs();
 144   for (Int_t inputFile=0; inputFile<nFiles;  inputFile++) {
 145     if (inputFile < nFiles-1) {
 146       AliWarning(Form("ignoring input stream %d", inputFile));
 147       continue;
 148
 149     }
 150
 151     Float_t besttimeright=9999.;
 152     Float_t besttimeleft=9999.;
 153     Float_t timeDiff;
 154     sumRight=0;
 155     for (Int_t i0=0; i0<36; i0++)
 156       {
 157         time[i0]=9999;  besttime[i0]=9999;      countE[i0]=0;
 158       }
 159
 160     inRL = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
 161     if (!inRL->GetAliRun()) inRL->LoadgAlice();
 162     AliSTART *fSTART  = (AliSTART*) inRL->GetAliRun()->GetDetector("START");
 163     pInStartLoader = inRL->GetLoader("STARTLoader");
 164     pInStartLoader->LoadHits("READ");//probably it is necessary to load them before
 165     TClonesArray *fHits = fSTART->Hits ();
 166
 167     TTree *th = pInStartLoader->TreeH();
 168     brHits = th->GetBranch("START");
 169     if (brHits) {
 170       fSTART->SetHitsAddressBranch(brHits);
 171     }else{
 172        AliError("Branch START hit not found");
 173       exit(111);
 174     }
 175     Int_t ntracks    = (Int_t) th->GetEntries();
 176
 177     if (ntracks<=0) return;
 178     // Start loop on tracks in the hits containers
 179     for (Int_t track=0; track<ntracks;track++) {
 180       brHits->GetEntry(track);
 181       nhits = fHits->GetEntriesFast();
 182        for (hit=0;hit<nhits;hit++)
 183         {
 184           startHit   = (AliSTARThit*) fHits->UncheckedAt(hit);
 185           if (!startHit) {
 186             AliError("The unchecked hit doesn't exist");
 187             break;
 188           }
 189           pmt=startHit->Pmt();
 190           Int_t numpmt=pmt-1;
 191           Double_t e=startHit->Etot();
 192           //      cout<<"AliSTARTDigitizer::Exec >> e "<<e<<" time "<< startHit->Time()<<endl;
 193           volume = startHit->Volume();
 194
 195            if(e>0 && RegisterPhotoE(e)) {
 196              countE[numpmt]++;
 197              besttime[numpmt] = startHit->Time();
 198              if(besttime[numpmt]<time[numpmt])
 199                {
 200                  time[numpmt]=besttime[numpmt];
 201                }
 202            }
 203         } //hits loop
 204     } //track loop
 205
 206     //best time right&left
 207     for (Int_t ipmt=0; ipmt<12; ipmt++)
 208       {
 209         timeGaus[ipmt]=gRandom->Gaus(time[ipmt],0.025);
 210         if(timeGaus[ipmt]<besttimeleft) besttimeleft=timeGaus[ipmt]; //timeleft
 211       }
 212     //    for ( Int_t ipmt=12; ipmt<36; ipmt++)
 213     for ( Int_t ipmt=12; ipmt<36; ipmt++)
 214       {
 215         timeGaus[ipmt]=gRandom->Gaus(time[ipmt],0.025);
 216         if(timeGaus[ipmt]<besttimeright)  besttimeright=timeGaus[ipmt]; //timeright
 217       }// besttime
 218
 219     //folding with experimental time distribution
 220       Float_t c = 29.9792; // mm/ns
 221     Float_t koef=(350.-69.7)/c;
 222     Float_t  besttimeleftR= besttimeleft;
 223     besttimeleft=koef+besttimeleft;
 224     bestLeftTDC=Int_t (besttimeleftR*1000/channelWidth);
 225     bestRightTDC=Int_t (besttimeright*1000/channelWidth);
 226     timeDiff=(c*(besttimeright-besttimeleftR)-(350.-69.7))/(2*c);
 227     meanTime=(besttimeright+besttimeleftR)/2.;
 228     Float_t ds=(c*(besttimeright-besttimeleftR)-(350.-69.7))/2;
 229     AliDebug(2,Form(" timediff in ns %f  z= %f real point%f",timeDiff,timeDiff*c,ds));
 230
 231
 232     // Time to TDC signal
 233     Int_t iTimeAv=Int_t (meanTime*1000/channelWidth);
 234     // time  channel numbres
 235     //       fill digits
 236     fdigits->SetTimeBestLeft(bestLeftTDC);
 237     fdigits->SetTimeBestRight(bestRightTDC);
 238     fdigits->SetMeanTime(iTimeAv);
 239
 240     //ADC features
 241
 242     for (Int_t i=0; i<36; i++)
 243       {
 244
 245         //  fill TDC
 246         tr= Int_t (timeGaus[i]*1000/channelWidth);
 247         if(timeGaus[i]>100) tr=0;
 248         ftimeTDC->AddAt(tr,i);
 249
 250         //fill ADC
 251         Int_t al= countE[i]; //1024 - channel width shoul be change
 252         fADC->AddAt(al,i);
 253       } //pmt loop
 254
 255     fdigits->SetTime(*ftimeTDC);
 256     fdigits->SetADC(*fADC);
 257
 258     pInStartLoader->UnloadHits();
 259
 260   } //input streams loop
 261
 262   pOutStartLoader->WriteDigits("OVERWRITE");
 263   pOutStartLoader->UnloadDigits();
 264 }
 265
 266
 267 //------------------------------------------------------------------------
 268 Bool_t AliSTARTDigitizer::RegisterPhotoE(Double_t energy)
 269 {
 270
 271
 272   //  Float_t hc=197.326960*1.e6; //mev*nm
 273   Double_t hc=1.973*1.e-6; //gev*nm
 274   //  cout<<"AliSTARTDigitizer::RegisterPhotoE >> energy "<<energy<<endl;
 275   Float_t lambda=hc/energy;
 276   Int_t bin=  fEff->GetXaxis()->FindBin(lambda);
 277   Float_t eff=fEff->GetBinContent(bin);
 278   Double_t  p = gRandom->Rndm();
 279   if (p > eff)
 280     return kFALSE;
 281
 282   return kTRUE;
 283 }
 284 //----------------------------------------------------------------------------