Removing the tasks from the digitization (Ruben)
[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSupgradeDigitizer.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 /* $Id$ */
18
19 #include <AliRun.h>
20 #include <AliRunLoader.h>
21 #include "AliDigitizationInput.h"
22 #include <AliLoader.h>
23 #include <AliLog.h>
24 #include "AliITSupgradeDigitizer.h"
25 #include "AliITSDigitUpgrade.h"
26 #include "AliITSupgrade.h"
27 #include "AliITSsegmentationUpgrade.h"
28 #include <TObjArray.h>
29 #include <TClonesArray.h>
30 #include <TTree.h>
31
32 extern TRandom *gRandom;
33
34 ClassImp(AliITSupgradeDigitizer)
35     
36   void AliITSupgradeDigitizer::SetConfiguration(TArrayD xcell, TArrayD zcell)
37 {
38   
39   if(xcell.GetSize()!=zcell.GetSize()) AliError(" !! The # of X cells and Z cells differ !!");
40   
41   fNlayers = xcell.GetSize();
42   
43   if(fNlayers > 9) {
44     AliError("*  Only 9 layers can be be filled  ...Exiting!!! *");
45     return;
46   }
47   
48   fNxCells.Set(fNlayers);
49   fNzCells.Set(fNlayers);
50   for(Int_t i=0; i<fNlayers; i++){
51     fNxCells.AddAt(xcell.At(i),i);
52     fNzCells.AddAt(zcell.At(i),i); 
53   }  
54 }   
55 //______________________________________________________________________________      
56 void AliITSupgradeDigitizer::Digitize(Option_t*)
57 {
58   // This method is responsible for merging sdigits to a list of digits
59   //  Disintegration leeds to the fact that one hit affects several neighbouring pads, 
60   // which means that the same pad might be affected by few hits.     
61   
62   AliDebug(1,Form("Start with %i input(s) for event %i",fDigInput->GetNinputs(),fDigInput->GetOutputEventNr()));
63   
64   
65   AliITSsegmentationUpgrade *s = new AliITSsegmentationUpgrade();
66   SetConfiguration(s->GetFullCellSizeX(),s->GetFullCellSizeZ());
67   delete s;
68   //First we read all sdigits from all inputs  
69   AliRunLoader *pInRunLoader=0;//in and out Run loaders
70   AliLoader    *pITSLoader=0;//in and out ITS loaders  
71   
72   TClonesArray sdigits[10];
73   for(Int_t i=0; i<fNlayers; i++) sdigits[i].SetClass("AliITSDigitUpgrade");//tmp storage for sdigits sum up from all input files
74   
75   
76   Int_t total[10]={0,0,0,0,0,0,0,0,0,0};
77   for(Int_t inFileN=0;inFileN<fDigInput->GetNinputs();inFileN++){//files loop
78     
79     pInRunLoader  = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(inFileN));          //get run loader from current input 
80     pITSLoader = pInRunLoader->GetLoader("ITSLoader"); 
81     if(pITSLoader==0) {
82       continue;       //no ITS in this input, check the next input
83       AliDebug(1,"no ITS lodader, checking in the other input \n"); 
84     }
85     
86     if (!pInRunLoader->GetAliRun()) pInRunLoader->LoadgAlice();
87     AliITSupgrade* pITS=(AliITSupgrade*)pInRunLoader->GetAliRun()->GetDetector("ITS"); 
88     
89     pITSLoader->LoadSDigits();  
90     
91     pITSLoader->TreeS()->GetEntry(0);                          //take list of ITS sdigits from current input 
92     
93     for(Int_t is=0;is<pITS->SDigitsList()->GetEntries();is++){      
94       
95       //collect sdigits from current input
96       for(Int_t ientr =0; ientr < ((TClonesArray*)pITS->SDigitsList()->At(is))->GetEntries(); ientr++){
97         AliITSDigitUpgrade *pSDig=(AliITSDigitUpgrade*)((TClonesArray*)pITS->SDigitsList()->At(is))->At(ientr);
98         pSDig->AddTidOffset(fDigInput->GetMask(inFileN)); // -> To be introduced for merging (apply TID shift since all inputs count tracks independently starting from 0)
99         new((sdigits[is])[total[is]++]) AliITSDigitUpgrade(*pSDig);  
100       }
101     }
102     
103     pITSLoader->UnloadSDigits();   
104     pITS->SDigitsReset(); //close current input and reset 
105   }//files loop  
106   
107   AliRunLoader *pOutRunLoader  = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());  //open output stream (only 1 possible)
108   AliLoader    *pOutITSLoader = pOutRunLoader->GetLoader("ITSLoader");                        
109   AliRun *pArun = pOutRunLoader->GetAliRun();
110   AliITSupgrade      *pOutITS       = (AliITSupgrade*)pArun->GetDetector("ITS");      
111   pOutITSLoader->MakeTree("D");   pOutITS->MakeBranch("D");                                    //create TreeD in output stream
112   pOutITS->SetTreeAddress();
113   
114   Sdigits2Digits(sdigits,pOutITS->DigitsList());
115   
116   pOutITSLoader->TreeD()->Fill();              //fill the output tree with the list of digits
117   pOutITSLoader->WriteDigits("OVERWRITE");     //serialize them to file
118   
119   for(Int_t i=0; i< fNlayers; i++) sdigits[i].Clear();                      //remove all tmp sdigits
120   pOutITSLoader->UnloadDigits();   
121   pOutITS->DigitsReset(); 
122 }//Exec()
123 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
124 void AliITSupgradeDigitizer::Sdigits2Digits(TClonesArray *pSDigitList,TObjArray *pDigitList)
125 {   
126
127   TClonesArray *pLst[100]; Int_t iCnt[100];
128  
129   for(Int_t i=0;i<fNlayers;i++){ 
130     pLst[i]=(TClonesArray*)(*pDigitList)[i];
131     iCnt[i]=0; if(pLst[i]->GetEntries()!=0) AliErrorClass("Some of digits lists is not empty");  //in principle those lists should be empty 
132   }
133    
134   Double_t eloss= 0.;
135   Double_t nele = 0.;
136   
137   Int_t tids[maxLab];           // track with id#
138   Float_t elossPart[maxLab];    // eloss produced by track with id#
139   for(Int_t i=0; i<maxLab ; i++) {
140     tids[i]=-1;
141     elossPart[i]=-1;
142   }
143   TArrayI labelsMC(0);          // all track with id#   
144
145   AliDebug(1,"starting loop over layers");
146    
147   for(Int_t ilay=0;ilay<fNlayers;ilay++){ 
148
149     AliITSDigitUpgrade *tmpdig=0x0;
150     pSDigitList[ilay].Sort();
151
152     Int_t prevModule=999; 
153     ULong_t  prevPixId = 999;
154     Int_t iNdigPart=0;  
155     Int_t iNtrackPart = 0;
156
157     AliDebug(1,"starting loop over sdigits to create digits");
158
159     Int_t nSDigits = pSDigitList[ilay].GetEntries();
160     Int_t nDigits = 0;
161
162     for(Int_t isdigentr=0; isdigentr<nSDigits; isdigentr++){
163
164       tmpdig = (AliITSDigitUpgrade*)(pSDigitList[ilay].At(isdigentr) )  ;
165       
166       Int_t    module  = tmpdig->GetModule(); 
167       ULong_t  pixId   = tmpdig->GetPixId();
168       Int_t    trackId = tmpdig->GetTrackID(0);  
169       
170       AliDebug(3,Form("  #tracks %d; #summed digits = %d, TrackIds (%d,%d,%d) ... ",iNtrackPart,iNdigPart,tids[0],tids[1],tids[2]));
171       AliDebug(3,Form("\t adding lay:%d  mod:%d  pixId:%lu   trackID:%d \n",tmpdig->GetLayer(),tmpdig->GetModule(),tmpdig->GetPixId(),
172                       tmpdig->GetTrackID(0)));
173       
174       if (trackId<0)
175         AliError("Screw you! A track with label<0 produced a SDigit? Something is wrong with Geant?\n");
176
177       if(pixId==prevPixId && module==prevModule) { 
178         // This sdigit belongs to the same pixel as before
179
180         // check if trackId is already in the list, if yes just add eloss ...
181         Int_t iid =0;
182         while (iid<labelsMC.GetSize()) {
183           if ( trackId==labelsMC.At(iid)) {
184             if (iid<maxLab) elossPart[iid] += tmpdig->GetSignal(); // hardcoded limit for elossPart
185             break;
186           }
187           iid++;
188         }
189         if (iid==labelsMC.GetSize()) { // the trackId is NEW!!
190           if (iid<maxLab) { // hardcoded limits for trackID 
191             tids[iNtrackPart] = tmpdig->GetTrackID(0);
192             elossPart[iNtrackPart] = tmpdig->GetSignal();
193           }
194           iNtrackPart++; 
195           // complete list of trackIDs
196           labelsMC.Set(iNtrackPart); 
197           labelsMC.SetAt(trackId,iNtrackPart-1);
198         } else {
199           AliDebug(3,"  -> Track ID already in the list\n");
200         }
201
202         if(iNtrackPart>maxLab) {        
203           AliWarning(Form(" Event %d: Number of summable digits for this pixel (lay=%d,mod=%d,pixId=%lu) is too large (%d<%d). Sum is ok but skipping track Id %d ... ",
204                           fDigInput->GetOutputEventNr(),ilay,module,pixId,maxLab,iNtrackPart,trackId));
205         }
206         eloss+=tmpdig->GetSignal();
207         nele +=tmpdig->GetNelectrons();
208         iNdigPart++;
209
210       } else { // new Pixel
211         
212         // write "previous" Digit
213         if(isdigentr!=0) {
214           AliITSDigitUpgrade digit(prevPixId,eloss);
215           digit.SetNelectrons(nele); 
216           digit.SetLayer(ilay);
217           digit.SetModule(prevModule);
218           digit.SetTids(tids);
219           digit.SetSignalID(elossPart);  
220           digit.SetNTracksIdMC(iNtrackPart);
221           //      for (Int_t i=0; i<12; i++) { if (i<12)printf("%d ",tids[i]); if (i==11) printf("| ");}
222           //      for (Int_t i=0; i<digit.GetNTracksIdMC(); i++) { printf("%d ",digit.GetTrackID(i)); if (i==labelsMC.GetSize()-1) printf("\n"); };
223           new((*pLst[ilay])[iCnt[ilay]++]) AliITSDigitUpgrade(digit);
224           nDigits++;
225           AliDebug(3,Form(" -> Wrote NEW digit in layer %d (%d)\n",ilay,nDigits));
226         }
227         
228         // Prepare newly found Pixel
229         eloss = tmpdig->GetSignal();
230         nele = tmpdig->GetNelectrons();
231         
232         iNtrackPart=1;  iNdigPart=1;   
233         labelsMC.Set(iNtrackPart); 
234         labelsMC.SetAt(tmpdig->GetTrackID(0),iNtrackPart-1);
235         tids[0]=tmpdig->GetTrackID(0);
236         elossPart[0]=tmpdig->GetSignal();
237         for(Int_t i=1; i<maxLab ; i++) {
238           tids[i]=-1;
239           elossPart[i]=-1;
240         }
241       }
242       
243       prevPixId=tmpdig->GetPixId(); 
244       prevModule=tmpdig->GetModule(); 
245       
246       
247     }  
248     // write "last" Digit
249     AliITSDigitUpgrade digit(prevPixId,eloss);
250     digit.SetNelectrons(nele); 
251     digit.SetLayer(ilay);
252     digit.SetModule(prevModule);
253     digit.SetTids(tids);
254     digit.SetSignalID(elossPart);      
255     digit.SetNTracksIdMC(iNtrackPart);
256     //   for (Int_t i=0; i<12; i++) { if (i<12)printf("%d ",tids[i]); if (i==11) printf("| ");}
257     //    for (Int_t i=0; i<digit.GetNTracksIdMC(); i++) { printf("%d ",digit.GetTrackID(i)); if (i==labelsMC.GetSize()-1) printf("\n"); };
258     new((*pLst[ilay])[iCnt[ilay]++]) AliITSDigitUpgrade(digit);
259     nDigits++;
260     AliDebug(3,Form(" -> Wrote LAST digit in layer %d (%d)\n",ilay,nDigits));
261
262     AliDebug(3,Form(" -> layer %d: Number of created digits %d",ilay,nDigits)); 
263     AliDebug(1,"ending loop over sdigits to create digits");
264
265   }
266   AliDebug(1,"ending loop over layers");  
267
268 }
269