new Hits2SDigits.
[u/mrichter/AliRoot.git] / RICH / AliRICHDigitizer.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 /* $Id$ */
17
18 //Piotr.Skowronski@cern.ch :
19 //Corrections applied in order to compile (only) with new I/O and folder structure
20 //To be implemented correctly by responsible
21
22 #include <Riostream.h> 
23
24 #include <TTree.h> 
25 #include <TObjArray.h>
26 #include <TFile.h>
27 #include <TDirectory.h>
28 #include <TParticle.h>
29
30 #include "AliRunLoader.h"
31 #include "AliLoader.h"
32
33 #include "AliRICHDigitizer.h"
34 #include "AliRICHChamber.h"
35 #include "AliHitMap.h"
36 #include "AliRICHHitMapA1.h"
37 #include "AliRICH.h"
38 #include "AliRICHSDigit.h"
39 #include "AliRICHDigit.h"
40 #include "AliRICHTransientDigit.h"
41 #include "AliRun.h"
42 #include "AliPDG.h"
43 #include "AliRunDigitizer.h"
44
45 ClassImp(AliRICHDigitizer)
46
47 //___________________________________________
48   AliRICHDigitizer::AliRICHDigitizer()
49 {
50 // Default constructor - don't use it   
51   fHits = 0;
52   fSDigits = 0;
53   fHitMap = 0;
54   fTDList = 0;
55 }
56
57 ////////////////////////////////////////////////////////////////////////
58 AliRICHDigitizer::AliRICHDigitizer(AliRunDigitizer* manager) 
59     :AliDigitizer(manager)
60 {
61 // ctor which should be used
62   fHits = 0;
63   fSDigits = 0;
64   fHitMap = 0;
65   fTDList = 0;
66   fDebug   = 0; 
67   if (GetDebug()>2) 
68     cerr<<"AliRICHDigitizer::AliRICHDigitizer"
69       <<"(AliRunDigitizer* manager) was processed"<<endl;
70 }
71
72 ////////////////////////////////////////////////////////////////////////
73 AliRICHDigitizer::~AliRICHDigitizer()
74 {
75 // Destructor
76     if (fHits) {
77         fHits->Delete();
78         delete fHits;
79     }
80     if (fSDigits) {
81         fSDigits->Delete();
82         delete fSDigits;
83     }
84     for (Int_t i=0; i<kNCH; i++ )
85         delete fHitMap[i];
86     delete [] fHitMap;
87     if (fTDList) {
88         fTDList->Delete();
89         delete fTDList;
90   }
91 }
92
93 //------------------------------------------------------------------------
94 Bool_t AliRICHDigitizer::Exists(const AliRICHSDigit *padhit)
95 {
96   return (fHitMap[fNch]->TestHit(padhit->PadX(),padhit->PadY()));
97 }
98
99 //------------------------------------------------------------------------
100 void AliRICHDigitizer::Update(AliRICHSDigit *padhit)
101 {
102   AliRICHTransientDigit *pdigit = 
103     static_cast<AliRICHTransientDigit*>(
104       fHitMap[fNch]->GetHit(padhit->PadX(),padhit->PadY()));
105
106   // update charge
107   //
108   Int_t iqpad    = Int_t(padhit->QPad()); // charge per pad
109   pdigit->AddSignal(iqpad);
110   pdigit->AddPhysicsSignal(iqpad);            
111
112   // update list of tracks
113   //
114   Int_t track, charge;
115   track = fTrack+fMask;
116   if (fSignal) {
117     charge = iqpad;
118   } else {
119     charge = kBgTag;
120   }
121   pdigit->UpdateTrackList(track,charge);
122 }
123
124 //------------------------------------------------------------------------
125 void AliRICHDigitizer::CreateNew(AliRICHSDigit *padhit)
126 {
127   fTDList->AddAtAndExpand(
128     new AliRICHTransientDigit(fNch,fDigits),fCounter);
129   fHitMap[fNch]->SetHit(padhit->PadX(),padhit->PadY(),fCounter);
130
131   AliRICHTransientDigit* pdigit = 
132     static_cast<AliRICHTransientDigit*>(fTDList->Last());
133   // list of tracks
134   Int_t track, charge;
135   if (fSignal) {
136     track = fTrack;
137     charge = padhit->QPad();
138   } else {
139     track = kBgTag;
140     charge = kBgTag;
141   }
142   pdigit->AddToTrackList(track,charge);
143   fCounter++;
144 }
145
146
147 ////////////////////////////////////////////////////////////////////////
148 Bool_t AliRICHDigitizer::Init()
149 {
150 // Initialisation
151   fHits     = new TClonesArray("AliRICHhit",1000);
152   fSDigits  = new TClonesArray("AliRICHSDigit",1000);
153   return kTRUE;
154 }
155
156 ////////////////////////////////////////////////////////////////////////
157 //void AliRICHDigitizer::Digitise(Int_t nev, Int_t flag)
158 void AliRICHDigitizer::Exec(Option_t* option)
159 {
160   TString optionString = option;
161   if (optionString.Data() == "deb") {
162     cout<<"AliMUONDigitizer::Exec: called with option deb "<<endl;
163     fDebug = 3;
164   }
165
166   AliRICHChamber*       iChamber;
167   AliSegmentation*  segmentation;
168  
169   AliRunLoader *inRL, *outRL;//in and out Run Loaders
170   AliLoader *ingime, *outgime;// in and out ITSLoaders
171  
172   outRL = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
173   outgime = outRL->GetLoader("RICHLoader");
174
175   fTDList = new TObjArray;
176   
177      
178   AliRICH *pRICH = (AliRICH *) gAlice->GetDetector("RICH");
179   
180   if (outgime->TreeD() == 0x0) outgime->MakeTree("D");
181   
182   pRICH->MakeBranchInTreeD(outgime->TreeD());
183   fHitMap= new AliHitMap* [kNCH];
184         
185   for (Int_t i =0; i<kNCH; i++) {
186     iChamber= &(pRICH->Chamber(i));
187     segmentation=iChamber->GetSegmentationModel(1);
188     fHitMap[i] = new AliRICHHitMapA1(segmentation, fTDList);
189   }
190
191 // Loop over files to digitize
192   fSignal = kTRUE;
193   fCounter = 0;
194   for (Int_t inputFile=0; inputFile<fManager->GetNinputs(); inputFile++) 
195    {
196     inRL = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
197     ingime = inRL->GetLoader("RICHLoader");
198     
199 // Connect RICH branches
200
201     if (inputFile > 0 ) fSignal = kFALSE;
202     TBranch *branchHits = 0;
203     TBranch *branchSDigits = 0;
204
205     ingime->LoadHits("READ");
206     TTree *treeH = ingime->TreeH();
207     if (GetDebug()>2) {
208       cerr<<"   inputFile  "<<inputFile<<endl;
209       cerr<<"   treeH, fHits "<<treeH<<" "<<fHits<<endl;
210     }
211     if (treeH && fHits) {
212       branchHits = treeH->GetBranch("RICH");
213       if (branchHits) 
214        {
215          fHits->Clear();
216           branchHits->SetAddress(&fHits);
217       }
218       else
219       Error("Exec","branch RICH was not found");
220     }
221     if (GetDebug()>2) cerr<<"   branchHits = "<<branchHits<<endl;
222
223     if (treeH && fSDigits) {
224       branchSDigits = treeH->GetBranch("RICHSDigits");
225       if (branchSDigits) 
226       branchSDigits->SetAddress(&fSDigits);
227       else
228       Error("exec","branch RICHSDigits was not found");
229     }
230     if (GetDebug()>2) cerr<<"   branchSDigits = "<<branchSDigits<<endl;
231
232
233     //
234     //   Loop over tracks
235     //
236     
237     Int_t ntracks =(Int_t) treeH->GetEntries();
238     for (fTrack=0; fTrack<ntracks; fTrack++) {
239       fHits->Clear();
240       fSDigits->Clear();  
241       branchHits->GetEntry(fTrack);
242       branchSDigits->GetEntry(fTrack);
243
244
245       //
246       //   Loop over hits
247       for(Int_t i = 0; i < fHits->GetEntriesFast(); ++i) {
248         AliRICHhit* mHit = static_cast<AliRICHhit*>(fHits->At(i));
249         fNch = mHit->Chamber()-1;  // chamber number
250         if (fNch >= kNCH) {
251           cerr<<"AliRICHDigitizer: chamber nr. fNch out of range: "<<fNch<<endl;
252           cerr<<"               track: "<<fTrack<<endl;
253           continue;
254         }
255         iChamber = &(pRICH->Chamber(fNch));
256           
257         //
258         // Loop over pad hits
259         for (AliRICHSDigit* mPad=
260                (AliRICHSDigit*)pRICH->FirstPad(mHit,fSDigits);
261              mPad;
262              mPad=(AliRICHSDigit*)pRICH->NextPad(fSDigits))
263         {
264           Int_t iqpad    = mPad->QPad();       // charge per pad
265           fDigits[0]=mPad->PadX();
266           fDigits[1]=mPad->PadY();
267           fDigits[2]=iqpad;
268           fDigits[3]=iqpad;
269           fDigits[4]=mPad->HitNumber();
270                   
271         
272
273           // build the list of fired pads and update the info
274           if (Exists(mPad)) {
275             Update(mPad);
276           } else {
277             CreateNew(mPad);
278           }
279         } //end loop over clusters
280       } // hit loop
281     } // track loop
282   } // end file loop
283   if (GetDebug()>2) cerr<<"END OF FILE LOOP"<<endl;
284
285   Int_t tracks[kMAXTRACKSPERRICHDIGIT];
286   Int_t charges[kMAXTRACKSPERRICHDIGIT];
287   Int_t nentries=fTDList->GetEntriesFast();
288     
289   for (Int_t nent=0;nent<nentries;nent++) {
290     AliRICHTransientDigit *transDigit=(AliRICHTransientDigit*)fTDList->At(nent);
291     if (transDigit==0) continue; 
292     Int_t ich=transDigit->GetChamber();
293     Int_t q=transDigit->Signal(); 
294     iChamber=&(pRICH->Chamber(ich));
295     AliRICHResponse * response=iChamber->GetResponseModel();
296     Int_t adcmax= (Int_t) response->MaxAdc();
297       
298       
299     // add white noise and do zero-suppression and signal truncation (new electronics,old electronics gaus 1.2,0.2)
300     //printf("Treshold: %d\n",iChamber->fTresh->GetHitIndex(transDigit->PadX(),transDigit->PadY()));
301
302 // tmp change
303 //    Int_t pedestal = iChamber->fTresh->GetHitIndex(transDigit->PadX(),transDigit->PadY());
304     Int_t pedestal = 0;
305
306
307     //printf("Pedestal:%d\n",pedestal);
308     //Int_t pedestal=0;
309     Float_t treshold = (pedestal + 4*2.2);
310       
311     Float_t meanNoise = gRandom->Gaus(2.2, 0.3);
312     Float_t noise     = gRandom->Gaus(0, meanNoise);
313     q+=(Int_t)(noise + pedestal);
314     //q+=(Int_t)(noise);
315     //          magic number to be parametrised !!! 
316     if ( q <= treshold) 
317     {
318       q = q - pedestal;
319       continue;
320     }
321     q = q - pedestal;
322     if ( q >= adcmax) q=adcmax;
323     fDigits[0]=transDigit->PadX();
324     fDigits[1]=transDigit->PadY();
325     fDigits[2]=q;
326     fDigits[3]=transDigit->Physics();
327     fDigits[4]=transDigit->Hit();
328
329     Int_t nptracks = transDigit->GetNTracks();  
330
331     // this was changed to accomodate the real number of tracks
332     if (nptracks > kMAXTRACKSPERRICHDIGIT) {
333       printf("Attention - tracks > 10 %d\n",nptracks);
334       nptracks=kMAXTRACKSPERRICHDIGIT;
335     }
336     if (nptracks > 2) {
337       printf("Attention - tracks > 2  %d \n",nptracks);
338     }
339     for (Int_t tr=0;tr<nptracks;tr++) {
340       tracks[tr]=transDigit->GetTrack(tr);
341       charges[tr]=transDigit->GetCharge(tr);
342       //printf("%f \n",charges[tr]);
343     }      //end loop over list of tracks for one pad
344     if (nptracks < kMAXTRACKSPERRICHDIGIT ) {
345       for (Int_t t=nptracks; t<kMAXTRACKSPERRICHDIGIT; t++) {
346       tracks[t]=0;
347       charges[t]=0;
348       }
349     }
350     //write file
351     //if (ich==2)
352     //fprintf(points,"%4d,      %4d,      %4d\n",digits[0],digits[1],digits[2]);
353       
354     // fill digits
355     pRICH->AddDigits(ich,tracks,charges,fDigits);
356   }      
357   outgime->TreeD()->Fill();
358
359   //pRICH->ResetDigits();
360   fTDList->Delete();    // or fTDList->Clear(); ???
361   for(Int_t ii=0;ii<kNCH;++ii) {
362     if (fHitMap[ii]) {
363       delete fHitMap[ii];
364       fHitMap[ii]=0;
365     }
366   }
367     
368   TClonesArray *richDigits;
369   for (Int_t k=0;k<kNCH;k++) {
370     richDigits = pRICH->DigitsAddress(k);
371     Int_t ndigit=richDigits->GetEntriesFast();
372     printf ("Chamber %d digits %d \n",k,ndigit);
373   }
374   pRICH->ResetDigits(); /// ??? should it be here???
375   
376   outgime->WriteDigits("OVERWRITE");
377
378   delete [] fHitMap;
379   delete fTDList;
380
381   if (fHits)    fHits->Delete();
382   if (fSDigits) fSDigits->Delete();
383
384 }