geometry 12 + 24 && recent media properties
[u/mrichter/AliRoot.git] / 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 //----------------------------------------------------------------------------