Fixed a bug in the Digit reader, moved clusterfinder to initialize from OCDB, Added...
[u/mrichter/AliRoot.git] / ITS / AliITS.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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
19 ///////////////////////////////////////////////////////////////////////////////
20 //                                                                           //
21 //      An overview of the basic philosophy of the ITS code development      //
22 // and analysis is show in the figure below.                                 //
23 //Begin_Html                                                                 //
24 /*                                               
25 <img src="picts/ITS/ITS_Analysis_schema.gif">
26 </pre>
27 <br clear=left>
28 <font size=+2 color=red>
29 <p>Roberto Barbera is in charge of the ITS Offline code (1999).
30 <a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
31 </font>
32 <pre>
33 */
34 //End_Html
35 //
36 //  AliITS. Inner Traking System base class.
37 //  This class contains the base procedures for the Inner Tracking System
38 //
39 //Begin_Html
40 /*
41 <img src="picts/ITS/AliITS_Class_Diagram.gif">
42 </pre>
43 <br clear=left>
44 <font size=+2 color=red>
45 <p>This show the class diagram of the different elements that are part of
46 the AliITS class.
47 </font>
48 <pre>
49 */
50 //End_Html
51 //
52 // Version: 0
53 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
54 //
55 // Version: 1
56 // Modified and documented by Bjorn S. Nilsen
57 // July 11 1999
58 //
59 // Version: 2
60 // Modified and documented by A. Bologna
61 // October 18 1999
62 //
63 // AliITS is the general base class for the ITS. Also see AliDetector for
64 // futher information.
65 //
66 ///////////////////////////////////////////////////////////////////////////////
67
68 #include <stdlib.h>
69 #include <TClonesArray.h>
70 #include <TFile.h>
71 #include <TParticle.h>
72 #include <TString.h>
73 #include <TTree.h>
74 #include <TVirtualMC.h>
75 #include "AliDetector.h"
76 #include "AliITS.h"
77 #include "AliITSDetTypeSim.h"
78 #include "AliITSDDLRawData.h"
79 #include "AliITSLoader.h"
80 #include "AliITShit.h"
81 #include "AliITSmodule.h"
82 #include "AliITSpListItem.h"
83 #include "AliITSsimulation.h"
84 #include "AliITSsimulationFastPoints.h"
85 #include "AliMC.h"
86 #include "AliITSDigitizer.h"
87 #include "AliITSRecPoint.h"
88 #include "AliITSsegmentationSPD.h"
89 #include "AliITSsegmentationSDD.h"
90 #include "AliITSsegmentationSSD.h"
91 #include "AliITSRawStreamSPD.h"
92 #include "AliITSRawStreamSSD.h"
93 #include "AliITSRawStreamSDD.h"
94 #include "AliRawReader.h"
95 #include "AliRun.h"
96 #include "AliLog.h"
97 #include "AliITSInitGeometry.h"
98 #include "AliITSFOSignalsSPD.h"
99
100 ClassImp(AliITS)
101
102 //______________________________________________________________________
103 AliITS::AliITS() : AliDetector(),
104 fDetTypeSim(0),
105 fEuclidOut(0),
106 fOpt("All"),
107 fIdN(0),
108 fIdSens(0),
109 fIdName(0),
110 fITSmodules(0),
111 fTiming(kFALSE),
112 fSimuParam(0)
113 {
114   // Default initializer for ITS
115   //      The default constructor of the AliITS class. In addition to
116   // creating the AliITS class it zeros the variables fIshunt (a member
117   // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
118   // fIdSens, and fIdName. The AliDetector default constructor
119   // is also called.
120   
121 //    SetDetectors(); // default to fOpt="All". This variable not written out.
122 //PH    SetMarkerColor(kRed);
123 }
124 //______________________________________________________________________
125 AliITS::AliITS(const Char_t *title):
126   AliDetector("ITS",title),
127   fDetTypeSim(0),
128   fEuclidOut(0),
129   fOpt("All"),
130   fIdN(0),
131   fIdSens(0),
132   fIdName(0),
133   fITSmodules(0),
134   fTiming(kFALSE),
135   fSimuParam(0)
136 {
137     //     The standard Constructor for the ITS class. 
138     // It also zeros the variables
139     // fIshunt (a member of AliDetector class), fEuclidOut, and zeros
140     // the pointers fIdSens and fIdName. To help in displaying hits via the
141     // ROOT macro display.C AliITS also sets the marker color to red. The
142     // variables passes with this constructor, const char *name and *title,
143     // are used by the constructor of AliDetector class. See AliDetector
144     // class for a description of these parameters and its constructor
145     // functions.
146     // Inputs:
147     //   Char_t *title  Simulation title for the ITS
148     // Outputs:
149     //   none.
150     // Return:
151     //   none.
152   
153     fHits = new TClonesArray("AliITShit",1560); // from AliDetector
154     if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
155     //fNhits=0;  //done in AliDetector(name,title)
156     SetDetectors(); // default to fOpt="All". This variable not written out.
157     fDetTypeSim   = new AliITSDetTypeSim();
158     //PH  SetMarkerColor(kRed);
159     if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
160     fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
161 }
162 //______________________________________________________________________
163 AliITS::AliITS(const char *name, const char *title):
164   AliDetector(name,title),
165   fDetTypeSim(0),
166   fEuclidOut(0),
167   fOpt("All"),
168   fIdN(0),
169   fIdSens(0),
170   fIdName(0),
171   fITSmodules(0),
172   fTiming(kFALSE),
173   fSimuParam(0)
174 {
175   //     The standard Constructor for the ITS class. 
176   // It also zeros the variables
177   // fIshunt (a member of AliDetector class), fEuclidOut, and zeros
178   // the pointers fIdSens and fIdName. To help in displaying hits via the
179   // ROOT macro display.C AliITS also sets the marker color to red. The
180   // variables passes with this constructor, const char *name and *title,
181   // are used by the constructor of AliDetector class. See AliDetector
182   // class for a description of these parameters and its constructor
183   // functions.
184   
185   fHits = new TClonesArray("AliITShit",1560);
186   if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
187   //fNhits=0;  //done in AliDetector(name,title)
188
189   SetDetectors(); // default to fOpt="All". This variable not written out.
190     
191   fDetTypeSim   = new AliITSDetTypeSim();
192   //PH  SetMarkerColor(kRed);
193   if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
194   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
195
196 }
197 //______________________________________________________________________
198 AliITS::~AliITS(){
199     // Default destructor for ITS.
200     //     The default destructor of the AliITS class. In addition to deleting
201     // the AliITS class it deletes the memory pointed to by 
202     // fIdSens, fIdName, fDetTypeSim and it's contents.
203     // Inputs:
204     //      none.
205     // Outputs:
206     //      none.
207     // Return:
208     //      none.
209
210     if (fHits) {
211       fHits->Delete();
212       delete fHits;
213       fHits=0;
214     }
215     if(fITSmodules) {
216         this->ClearModules();
217         delete fITSmodules;
218         fITSmodules = 0;
219     }// end if fITSmodules!=0
220
221     delete[] fIdName;  // Array of TStrings
222     delete[] fIdSens;
223
224     if (fDetTypeSim){
225       delete fDetTypeSim;
226       fDetTypeSim = 0;
227     }
228     if(fSimuParam){
229       delete fSimuParam;
230       fSimuParam=0;
231     }
232 }
233 //______________________________________________________________________
234 AliDigitizer* AliITS::CreateDigitizer(AliRunDigitizer* manager)const{
235     // Creates the AliITSDigitizer in a standard way for use via AliModule.
236     // This function can not be included in the .h file because of problems
237     // with the order of inclusion (recursive).
238     // Inputs:
239     //    AliRunDigitizer *manager  The Manger class for Digitization
240     // Output:
241     //    none.
242     // Return:
243     //    A new AliITSRunDigitizer (cast as a AliDigitizer).
244
245      return new AliITSDigitizer(manager);
246 }
247 //______________________________________________________________________
248 void AliITS::Init(){
249     // Initializer ITS after it has been built
250     //     This routine initializes the AliITS class. It is intended to be
251     // called from the Init function in AliITSv?. Besides displaying a banner
252     // indicating that it has been called it initializes the array fIdSens
253     // and sets the default segmentation, response, digit and raw cluster
254     // classes therefore it should be called after a call to CreateGeometry.
255     // Inputs:
256     //      none.
257     // Outputs:
258     //      none.
259     // Return:
260     //      none.
261     Int_t i;
262     // Array of TStrings
263     if(gMC) for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
264  
265 }
266 //______________________________________________________________________
267 void AliITS::SetDefaults(){
268     // sets the default segmentation, response, digit and raw cluster classes.
269     // Inputs:
270     //      none.
271     // Outputs:
272     //      none.
273     // Return:
274     //      none.
275     AliInfoClass("AliITS::Setting Defaults");
276     if(!fDetTypeSim) { 
277      Error("SetDefaults()","fDetTypeSim is 0!"); 
278      return;
279     }
280
281     fDetTypeSim->SetDefaults();
282     if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
283
284 }
285 //______________________________________________________________________
286 void AliITS::SetDefaultSimulation(){
287     // sets the default simulation.
288     // Inputs:
289     //      none.
290     // Outputs:
291     //      none.
292     // Return:
293     //      none.
294     if(!fDetTypeSim) { 
295      Error("SetDefaultSimulation()","fDetTypeSim is 0!"); 
296      return;
297     }
298
299     fDetTypeSim->SetDefaultSimulation();
300     if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
301
302 }
303
304
305 //______________________________________________________________________
306 void AliITS::MakeBranch(Option_t* option){
307     // Creates Tree branches for the ITS.
308     // Inputs:
309     //      Option_t *option    String of Tree types S,D, and/or R.
310     //      const char *file    String of the file name where these branches
311     //                          are to be stored. If blank then these branches
312     //                          are written to the same tree as the Hits were
313     //                          read from.
314     // Outputs:
315     //      none.
316     // Return:
317     //      none.
318   if(!fDetTypeSim) {
319     Error("MakeBranch","fDetTypeSim is 0!");
320     return;
321   }
322
323   Bool_t cH = (strstr(option,"H")!=0);
324   Bool_t cS = (strstr(option,"S")!=0);
325   Bool_t cD = (strstr(option,"D")!=0);
326   
327   if(cH && (fHits == 0x0)) fHits = new TClonesArray("AliITShit", 1560);
328   AliDetector::MakeBranch(option);
329   
330   if(cS) MakeBranchS(0);
331   if(cD) MakeBranchD(0);
332
333
334 }
335 //___________________________________________________________________
336 void AliITS::MakeBranchS(const char* fl){
337
338   // Creates Tree Branch for the ITS summable digits.
339   // Inputs:
340   //      cont char *fl  File name where SDigits branch is to be written
341   //                     to. If blank it write the SDigits to the same
342   //                     file in which the Hits were found.
343
344   
345   if(!fDetTypeSim){
346     Error("MakeBranchS","fDetTypeSim is 0!");
347   }
348   Int_t buffersize = 4000;
349   char branchname[30];
350
351   // only one branch for SDigits.
352   sprintf(branchname,"%s",GetName());
353
354   if(fLoader->TreeS()){
355     TClonesArray* sdig = (TClonesArray*)fDetTypeSim->GetSDigits();
356     MakeBranchInTree(fLoader->TreeS(),branchname,&sdig,buffersize,fl);
357   } 
358 }
359 //______________________________________________________________________
360 void AliITS::MakeBranchD(const char* file){
361
362   //Make branch for digits
363   if(!fDetTypeSim) {
364     Warning("MakeBranchD","fDetTypeSim is 0!");
365     return;
366   }
367   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
368   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
369   MakeBranchInTreeD(fLoader->TreeD(),file);
370 }
371
372 //___________________________________________________________________
373 void AliITS:: MakeBranchInTreeD(TTree* treeD, const char* file){
374   // Creates Tree branches for the ITS.
375
376   if(!fDetTypeSim){
377     Error("MakeBranchS","fDetTypeSim is 0!");
378   }
379   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
380   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
381
382   const Char_t *det[3] = {"SPD","SDD","SSD"};
383   const Char_t* digclass;
384   Int_t buffersize = 4000;
385   Char_t branchname[30];
386   
387   if(!fDetTypeSim->GetDigits()){
388     fDetTypeSim->SetDigits(new TObjArray(fgkNTYPES));
389   }
390   for(Int_t i=0;i<fgkNTYPES;i++){
391     digclass = fDetTypeSim->GetDigitClassName(i);
392     TString classn = digclass;
393     if(!((fDetTypeSim->GetDigits())->At(i))){
394       (fDetTypeSim->GetDigits())->AddAt(new TClonesArray(classn.Data(),1000),i);
395     }
396     else ResetDigits(i);  
397     if(fgkNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
398     else sprintf(branchname,"%sDigits%d",GetName(),i+1);
399     TObjArray* dig = DigitsAddress(i);
400     if(GetDigits() && treeD) AliDetector::MakeBranchInTree(treeD,branchname, &dig,buffersize,file);
401   }
402
403 }
404 //______________________________________________________________________
405 void AliITS::SetTreeAddress(){
406     // Set branch address for the Trees.
407     // Inputs:
408     //      none.
409     // Outputs:
410     //      none.
411     // Return:
412     //      none.
413     
414   if(!fDetTypeSim) {
415     Error("SetTreeAddress","fDetTypeSim is 0!");
416     return;
417   }
418
419   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
420   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
421
422   TTree *treeS = fLoader->TreeS();
423   TTree *treeD = fLoader->TreeD();
424   if (fLoader->TreeH() && (fHits == 0x0)) {
425       fHits = new TClonesArray("AliITShit", 1560);
426   }
427   AliDetector::SetTreeAddress();
428
429   fDetTypeSim->SetTreeAddressS(treeS, (Char_t*)GetName());
430   fDetTypeSim->SetTreeAddressD(treeD, (Char_t*)GetName());
431 }
432 //______________________________________________________________________
433 void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
434     // Add an ITS hit
435     //     The function to add information to the AliITShit class. See the
436     // AliITShit class for a full description. This function allocates the
437     // necessary new space for the hit information and passes the variable
438     // track, and the pointers *vol and *hits to the AliITShit constructor
439     // function.
440     // Inputs:
441     //      Int_t   track   Track number which produced this hit.
442     //      Int_t   *vol    Array of Integer Hit information. See AliITShit.h
443     //      Float_t *hits   Array of Floating Hit information.  see AliITShit.h
444     // Outputs:
445     //      none.
446     // Return:
447     //      none.
448   TClonesArray &lhits = *fHits;
449   new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
450 }
451
452 //______________________________________________________________________
453 void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
454                          Option_t *option, const char *filename){
455   // fill the modules with the sorted by module hits; add hits from
456   // background if option=Add.
457
458   static TTree *trH1;                 //Tree with background hits
459   static Bool_t first=kTRUE;
460   static TFile *file;
461   const char *addBgr = strstr(option,"Add");
462   
463   evnt = nmodules; // Dummy use of variables to remove warnings
464   if (addBgr ) {
465     if(first) {
466       file=new TFile(filename);
467     } // end if first
468     first=kFALSE;
469     file->cd();
470     file->ls();
471     // Get Hits Tree header from file
472     if(trH1) delete trH1;
473     trH1=0;
474     
475     char treeName[20];
476     sprintf(treeName,"TreeH%d",bgrev);
477     trH1 = (TTree*)gDirectory->Get(treeName);
478     if (!trH1) {
479       Error("FillModules","cannot find Hits Tree for event:%d",bgrev);
480     } // end if !trH1
481     // Set branch addresses
482   } // end if addBgr
483   
484   FillModules(fLoader->TreeH(),0); // fill from this file's tree.
485     
486   if (addBgr ) {
487     FillModules(trH1,10000000); // Default mask 10M.
488     TTree *fAli=fLoader->GetRunLoader()->TreeK();
489     TFile *fileAli=0;
490     if (fAli) fileAli =fAli->GetCurrentFile();
491     fileAli->cd();
492   } // end if add
493   
494   
495 }
496 //______________________________________________________________________
497 void AliITS::FillModules(TTree *treeH, Int_t mask) {
498     // fill the modules with the sorted by module hits; 
499     // can be called many times to do a merging
500     // Inputs:
501     //      TTree *treeH  The tree containing the hits to be copied into
502     //                    the modules.
503     //      Int_t mask    The track number mask to indecate which file
504     //                    this hits came from.
505     // Outputs:
506     //      none.
507     // Return:
508     //      none.
509
510     if (treeH == 0x0)
511      {
512        Error("FillModules","Tree is NULL");
513      }
514     Int_t lay,lad,det,index;
515     AliITShit *itsHit=0;
516     AliITSmodule *mod=0;
517     char branchname[20];
518     sprintf(branchname,"%s",GetName());
519     TBranch *branch = treeH->GetBranch(branchname);
520     if (!branch) {
521         Error("FillModules","%s branch in TreeH not found",branchname);
522         return;
523     } // end if !branch
524     branch->SetAddress(&fHits);
525     Int_t nTracks =(Int_t) treeH->GetEntries();
526     Int_t iPrimTrack,h;
527     for(iPrimTrack=0; iPrimTrack<nTracks; iPrimTrack++){
528         ResetHits();
529         Int_t nBytes = treeH->GetEvent(iPrimTrack);
530         if (nBytes <= 0) continue;
531         Int_t nHits = fHits->GetEntriesFast();
532         for(h=0; h<nHits; h++){
533             itsHit = (AliITShit *)fHits->UncheckedAt(h);
534             itsHit->GetDetectorID(lay,lad,det);
535             if (GetITSgeom()) {
536                 index = GetITSgeom()->GetModuleIndex(lay,lad,det);
537             } else {
538                 index=det-1; // This should not be used.
539             } // end if [You must have fITSgeom for this to work!]
540             mod = GetModule(index);
541             itsHit->SetTrack(itsHit->GetTrack()+mask); // Set track mask.
542             mod->AddHit(itsHit,iPrimTrack,h);
543         } // end loop over hits 
544     } // end loop over tracks
545 }
546
547 //______________________________________________________________________
548 Bool_t AliITS::InitModules(Int_t size,Int_t &nmodules){
549     // Initialize the modules array.
550     // Inputs:
551     //      Int_t size  Size of array of the number of modules to be
552     //                  created. If size <=0 then the number of modules
553     //                  is gotten from AliITSgeom class kept in fITSgeom.
554     // Outputs:
555     //      Int_t &nmodules The number of modules existing.
556     // Return:
557     //      none.
558
559     if(fITSmodules){ 
560         fITSmodules->Delete();
561         delete fITSmodules;
562     } // end fir fITSmoudles
563
564     if(!fDetTypeSim) {
565       Error("InitModules","fDetTypeSim is null!");
566       return kFALSE;
567     }
568     if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
569
570     Int_t nl,indexMAX,index;
571
572     if(size<=0){ // default to using data stored in AliITSgeom
573         if(fDetTypeSim->GetITSgeom()==0) {
574             Error("InitModules","fITSgeom not defined");
575             return kFALSE;
576         } // end if fITSgeom==0
577         nl = fDetTypeSim->GetITSgeom()->GetNlayers();
578         indexMAX = fDetTypeSim->GetITSgeom()->GetIndexMax();
579         nmodules = indexMAX;
580         fITSmodules = new TObjArray(indexMAX);
581         for(index=0;index<indexMAX;index++){
582             fITSmodules->AddAt( new AliITSmodule(index),index);
583         } // end for index
584     }else{
585         fITSmodules = new TObjArray(size);
586         for(index=0;index<size;index++) {
587             fITSmodules->AddAt( new AliITSmodule(index),index);
588         } // end for index
589
590         nmodules = size;
591     } // end i size<=0
592     return kTRUE;
593 }
594 //______________________________________________________________________
595 void AliITS::Hits2SDigits(){
596     // Standard Hits to summable Digits function.
597     // Inputs:
598     //      none.
599     // Outputs:
600     //      none.
601   
602
603    if(!fDetTypeSim) {
604      Error("Hits2SDigits","fDetTypeSim is null!");
605      return; 
606   } 
607      
608   SetDefaults();
609   fLoader->LoadHits("read");
610   fLoader->LoadSDigits("recreate");
611   AliRunLoader* rl = fLoader->GetRunLoader(); 
612   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
613   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
614
615   for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
616         // Do the Hits to Digits operation. Use Standard input values.
617         // Event number from file, no background hit merging , use size from
618         // AliITSgeom class, option="All", input from this file only.
619     rl->GetEvent(iEvent);
620     if (!fLoader->TreeS()) fLoader->MakeTree("S");
621     MakeBranch("S");
622     SetTreeAddress();
623     HitsToPreDigits(iEvent,0,-1," ",fOpt," ");
624   } // end for iEvent
625     
626   fLoader->UnloadHits();
627   fLoader->UnloadSDigits();
628   
629 }
630 //______________________________________________________________________
631 void AliITS::Hits2Digits(){
632
633   //Conversion from hits to digits
634   if(!fDetTypeSim) {
635     Error("Hits2SDigits","fDetTypeSim is 0!");
636     return;
637   }
638    
639   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
640   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
641   SetDefaults();
642
643   fLoader->LoadHits("read");
644   fLoader->LoadDigits("recreate");
645   AliRunLoader* rl = fLoader->GetRunLoader(); 
646   for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
647     rl->GetEvent(iEvent);
648     if (!fLoader->TreeD()) fLoader->MakeTree("D");
649     MakeBranch("D");
650     SetTreeAddress();   
651     HitsToDigits(iEvent,0,-1," ",fOpt," ");
652   } 
653   
654   fLoader->UnloadHits();
655   fLoader->UnloadDigits();
656   
657 }
658
659 //______________________________________________________________________
660 void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
661                           Option_t *option,Option_t *opt,
662                           const char *filename){
663     //   Keep galice.root for signal and name differently the file for 
664     // background when add! otherwise the track info for signal will be lost !
665     // the condition below will disappear when the geom class will be
666     // initialized for all versions - for the moment it is only for v5 !
667     // 7 is the SDD beam test version.
668     // Inputs:
669     //      Int_t evnt       Event to be processed.
670     //      Int_t bgrev      Background Hit tree number.
671     //      Int_t nmodules   Not used.
672     //      Option_t *option String indicating if merging hits or not. To
673     //                       merge hits set equal to "Add". Otherwise no
674     //                       background hits are considered.
675     //      Test_t *filename File name containing the background hits..
676     // Outputs:
677     //      none.
678     // Return:
679     //      none.
680
681   if(!fDetTypeSim) {
682     Error("HitsToDigits","fDetTypeSim is null!");
683     return;
684   }
685   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
686   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
687   if(!GetITSgeom()) return; // need transformations to do digitization.
688   AliITSgeom *geom = GetITSgeom();
689
690   const char *all = strstr(opt,"All");
691   const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
692                         strstr(opt,"SSD")};
693   static Bool_t setDef=kTRUE;
694   if (setDef) SetDefaultSimulation();
695   setDef=kFALSE;
696   
697   Int_t nmodules;
698   InitModules(size,nmodules);
699   FillModules(evNumber,bgrev,nmodules,option,filename);
700  
701   // Reset Fast-OR signals for this event
702   fDetTypeSim->ResetFOSignals();
703
704   AliITSsimulation *sim      = 0;
705   AliITSmodule     *mod      = 0;
706   Int_t id;
707   for(Int_t module=0;module<geom->GetIndexMax();module++){
708     id       = geom->GetModuleType(module);
709     if (!all && !det[id]) continue;
710     sim      = (AliITSsimulation*)fDetTypeSim->GetSimulationModel(id);
711     if (!sim) {
712       Error("HitsToDigits","The simulation class was not "
713             "instanciated for module %d type %s!",module,
714             geom->GetModuleTypeName(module));
715       exit(1);
716     } // end if !sim
717     mod      = (AliITSmodule *)fITSmodules->At(module);
718     sim->DigitiseModule(mod,module,evNumber);
719     // fills all branches - wasted disk space
720     fLoader->TreeD()->Fill(); 
721     ResetDigits();
722   } // end for module
723   
724   ClearModules();
725  
726   // Add random noise to FO signals
727   if (all || det[0]) { // SPD present
728     fDetTypeSim->ProcessNoiseForFastOr();
729   }
730
731   // Add Fast-OR signals to event (only one object per event)
732   if (all || det[0]) { // SPD present
733     fDetTypeSim->WriteFOSignals();
734   }
735
736   
737   fLoader->TreeD()->GetEntries();
738   fLoader->TreeD()->AutoSave();
739   // reset tree
740   fLoader->TreeD()->Reset();
741 }
742 //_____________________________________________________________________
743 void AliITS::Hits2PreDigits(){ 
744   // Turn hits into SDigits
745
746   if(!fDetTypeSim) {
747     Error("Hits2SDigits","fDetTypeSim is 0!");
748     return;
749   }
750    
751   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
752   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
753   SetDefaults();
754   
755   HitsToPreDigits(fLoader->GetRunLoader()->GetEventNumber(),
756                   0,-1," ",fOpt," ");
757 }
758
759 //______________________________________________________________________
760 void AliITS::HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
761                              Option_t *option,Option_t *opt,
762                              const char *filename){
763     //   Keep galice.root for signal and name differently the file for 
764     // background when add! otherwise the track info for signal will be lost !
765     // the condition below will disappear when the geom class will be
766     // initialized for all versions - for the moment it is only for v5 !
767     // 7 is the SDD beam test version.
768     // Inputs:
769     //      Int_t evnt       Event to be processed.
770     //      Int_t bgrev      Background Hit tree number.
771     //      Int_t nmodules   Not used.
772     //      Option_t *option String indicating if merging hits or not. To
773     //                       merge hits set equal to "Add". Otherwise no
774     //                       background hits are considered.
775     //      Test_t *filename File name containing the background hits..
776     // Outputs:
777     //      none.
778     // Return:
779     //      none.
780
781  
782   if(!fDetTypeSim) {
783     Error("HitsToPreDigits","fDetTypeSim is null!");
784     return;
785   }
786   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
787   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
788
789   if(!GetITSgeom()){
790     Error("HitsToPreDigits","fGeom is null!");
791     return; // need transformations to do digitization.
792   }
793   AliITSgeom *geom = GetITSgeom();
794
795   const char *all = strstr(opt,"All");
796   const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
797                         strstr(opt,"SSD")};
798   static Bool_t setDef=kTRUE;
799   if (setDef) SetDefaultSimulation();
800   setDef=kFALSE;
801   
802   Int_t nmodules;
803   InitModules(size,nmodules);
804   FillModules(evNumber,bgrev,nmodules,option,filename);
805   
806
807   AliITSsimulation *sim      = 0;
808   AliITSmodule     *mod      = 0;
809   Int_t id,module;
810   for(module=0;module<geom->GetIndexMax();module++){
811     id       = geom->GetModuleType(module);
812     if (!all && !det[id]) continue;
813     sim      = (AliITSsimulation*)GetSimulationModel(id);
814     if (!sim) {
815       Error("HitsToPreDigits","The simulation class was not "
816             "instanciated for module %d type %s!",module,
817             geom->GetModuleTypeName(module));
818       exit(1);
819     } // end if !sim
820     mod      = (AliITSmodule *)fITSmodules->At(module);
821     sim->SDigitiseModule(mod,module,evNumber);
822     // fills all branches - wasted disk space
823     fLoader->TreeS()->Fill(); 
824     fDetTypeSim->ResetSDigits();
825   } // end for module
826
827   ClearModules();
828
829   
830   fLoader->TreeS()->GetEntries();
831   fLoader->TreeS()->AutoSave();
832   fLoader->WriteSDigits("OVERWRITE");
833   // reset tree
834   fLoader->TreeS()->Reset();
835 }
836
837 //_____________________________________________________________________
838 void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
839                                   Option_t *opt0,Option_t *opt1,
840                                  const char *flnm){
841     // keep galice.root for signal and name differently the file for 
842     // background when add! otherwise the track info for signal will be lost !
843     // the condition below will disappear when the geom class will be
844     // initialized for all versions - for the moment it is only for v5 !
845     // Inputs:
846     //      Int_t evnt       Event to be processed.
847     //      Int_t bgrev      Background Hit tree number.
848     //      Int_t size       Size used by InitModules. See InitModules.
849     //      Option_t *opt0   Option passed to FillModules. See FillModules.
850     //      Option_t *opt1   String indicating if merging hits or not. To
851     //                       merge hits set equal to "Add". Otherwise no
852     //                       background hits are considered.
853     //      Test_t *flnm     File name containing the background hits..
854     // Outputs:
855     //      none.
856     // Return:
857     //      none.
858
859
860
861   if(!GetITSgeom()){
862     Error("HitsToPreDigits","fGeom is null!");
863     return; // need transformations to do digitization.
864   }
865   AliITSgeom *geom = GetITSgeom();
866
867   AliITSLoader *pITSloader = (AliITSLoader*)fLoader;
868
869   const char *all = strstr(opt1,"All");
870   const char *det[3] ={strstr(opt1,"SPD"),strstr(opt1,"SDD"),
871                        strstr(opt1,"SSD")};
872   Int_t nmodules;
873   InitModules(size,nmodules);
874   FillModules(evNumber,bgrev,nmodules,opt0,flnm);
875
876   AliITSsimulation *sim      = 0;
877   AliITSmodule     *mod      = 0;
878   Int_t id,module;
879
880   TTree *lTR = pITSloader->TreeR();
881   if(!lTR) {
882     pITSloader->MakeTree("R");
883     lTR = pITSloader->TreeR();
884   }
885   
886   TClonesArray* ptarray = new TClonesArray("AliITSRecPoint",1000);
887   TBranch* branch = (TBranch*)lTR->Branch("ITSRecPointsF",&ptarray);
888   branch->SetAddress(&ptarray);
889   //m.b. : this change is nothing but a nice way to make sure
890   //the CPU goes up !    
891   for(module=0;module<geom->GetIndexMax();module++){
892     id       = geom->GetModuleType(module);
893     if (!all && !det[id]) continue;
894     sim      = (AliITSsimulation*)GetSimulationModel(id);
895     if (!sim) {
896       Error("HitsToFastPoints","The simulation class was not "
897             "instanciated for module %d type %x!",module,
898             geom->GetModuleTypeName(module));
899       exit(1);
900     } // end if !sim
901     mod      = (AliITSmodule *)fITSmodules->At(module);
902     sim->CreateFastRecPoints(mod,module,gRandom,ptarray);
903     lTR->Fill();
904     ptarray->Clear();
905   } // end for module
906
907   ClearModules();
908   fLoader->WriteRecPoints("OVERWRITE");
909   delete ptarray;
910 }
911 //_____________________________________________________________________
912 Int_t AliITS::Hits2Clusters(TTree *hTree, TTree *cTree) {
913   //------------------------------------------------------------
914   // This function creates ITS clusters
915   //------------------------------------------------------------
916   if(!GetITSgeom()){
917     Error("HitsToPreDigits","fGeom is null!");
918     return 1; // need transformations to do digitization.
919   }
920   AliITSgeom *geom=GetITSgeom();
921   Int_t mmax=geom->GetIndexMax();
922
923   InitModules(-1,mmax);
924   FillModules(hTree,0);
925
926   TClonesArray *points = new TClonesArray("AliITSRecPoint",1000);
927   TBranch *branch=cTree->GetBranch("ITSRecPoints");
928   if (!branch) cTree->Branch("ITSRecPoints",&points);
929   else branch->SetAddress(&points);
930
931   AliITSsimulationFastPoints sim;
932   Int_t ncl=0;
933   for (Int_t m=0; m<mmax; m++) {
934     AliITSmodule *mod=GetModule(m);      
935     sim.CreateFastRecPoints(mod,m,gRandom,points);      
936     ncl+=points->GetEntriesFast();
937     cTree->Fill();
938     points->Clear();
939   }
940
941   AliDebug(1,Form("Number of found fast clusters : %d",ncl));
942
943   //cTree->Write();
944
945   delete points;
946   return 0;
947 }
948
949 //_____________________________________________________________________
950 void AliITS::CheckLabels(Int_t lab[3]) const {
951   //------------------------------------------------------------
952   // Tries to find mother's labels
953   //------------------------------------------------------------
954
955   if(lab[0]<0 && lab[1]<0 && lab[2]<0) return; // In case of no labels just exit
956
957   Int_t ntracks = gAlice->GetMCApp()->GetNtrack();
958   for (Int_t i=0;i<3;i++){
959     Int_t label = lab[i];
960     if (label>=0 && label<ntracks) {
961       TParticle *part=(TParticle*)gAlice->GetMCApp()->Particle(label);
962       if (part->P() < 0.005) {
963         Int_t m=part->GetFirstMother();
964         if (m<0) {      
965           continue;
966         }
967         if (part->GetStatusCode()>0) {
968           continue;
969         }
970         lab[i]=m;       
971       }
972     }    
973   }
974   
975 }
976
977 //______________________________________________________________________
978 void AliITS::SDigitsToDigits(Option_t *opt){
979   // Standard Summable digits to Digits function.
980   // Inputs:
981   //      none.
982   // Outputs:
983   //      none.
984   if (!fDetTypeSim) {
985     AliError("fDetTypeSim is 0!");
986     return;
987   }
988
989   const char *all = strstr(opt,"All");
990   const char *det[3] ={strstr(opt,"SPD"),strstr(opt,"SDD"),
991                        strstr(opt,"SSD")};
992
993   // Reset Fast-OR signals for this event
994   fDetTypeSim->ResetFOSignals();
995
996   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
997   SetDefaults();
998   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
999   fDetTypeSim->SDigitsToDigits(opt,(Char_t*)GetName());
1000
1001   // Add random noise to FO signals
1002   if (all || det[0]) { // SPD present
1003     fDetTypeSim->ProcessNoiseForFastOr();
1004   }
1005   // Add Fast-OR signals to event (only one object per event)
1006   if (all || det[0]) { // SPD present
1007     fDetTypeSim->WriteFOSignals();
1008   }
1009 }
1010
1011 //______________________________________________________________________
1012 void AliITS::ResetDigits(){
1013     // Reset number of digits and the digits array for the ITS detector.
1014     // Inputs:
1015     //      none.
1016     // Outputs:
1017     //      none.
1018     if(!fDetTypeSim) {
1019       Error("ResetDigits","fDetTypeSim is 0!");
1020       return;
1021     }
1022    
1023     fDetTypeSim->ResetDigits();
1024
1025
1026 }
1027 //______________________________________________________________________
1028 void AliITS::ResetDigits(Int_t branch){
1029     // Reset number of digits and the digits array for this branch.
1030     // Inputs:
1031     //      none.
1032     // Outputs:
1033     //      none.
1034
1035     if(!fDetTypeSim) {
1036       Error("ResetDigits","fDetTypeSim is 0!");
1037       return;
1038     }
1039    
1040     fDetTypeSim->ResetDigits(branch);
1041
1042 }
1043 //______________________________________________________________________
1044 void AliITS::AddSumDigit(AliITSpListItem &sdig){
1045     // Adds the a module full of summable digits to the summable digits tree.
1046     // Inputs:
1047     //      AliITSpListItem &sdig   SDigit to be added to SDigits tree.
1048     // Outputs:
1049     //      none.
1050     // Return:
1051     //      none.
1052
1053     if(!fDetTypeSim) {
1054       Error("AddSumDigit","fDetTypeSim is 0!");
1055       return;
1056     }
1057     fDetTypeSim->AddSumDigit(sdig);
1058     
1059 }
1060 //______________________________________________________________________
1061 void AliITS::AddSimDigit(Int_t branch, AliITSdigit *d){
1062     //    Add a simulated digit.
1063     // Inputs:
1064     //      Int_t id        Detector type number.
1065     //      AliITSdigit *d  Digit to be added to the Digits Tree. See 
1066     //                      AliITSdigit.h
1067     // Outputs:
1068     //      none.
1069     // Return:
1070     //      none.
1071
1072     if(!fDetTypeSim) {
1073       Error("AddSimDigit","fDetTypeSim is 0!");
1074       return;
1075     }
1076     fDetTypeSim->AddSimDigit(branch,d);
1077
1078 }
1079 //______________________________________________________________________
1080 void AliITS::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,Int_t *tracks,
1081                          Int_t *hits,Float_t *charges, Int_t sigexpanded){
1082   //   Add a simulated digit to the list.
1083   // Inputs:
1084   //      Int_t id        Detector type number.
1085   //      Float_t phys    Physics indicator. See AliITSdigits.h
1086   //      Int_t *digits   Integer array containing the digits info. See 
1087   //                      AliITSdigit.h
1088   //      Int_t *tracks   Integer array [AliITSdigitS?D::GetNTracks()] 
1089   //                      containing the track numbers that contributed to
1090   //                      this digit.
1091   //      Int_t *hits     Integer array [AliITSdigitS?D::GetNTracks()]
1092   //                      containing the hit numbers, from AliITSmodule, that
1093   //                      contributed to this digit.
1094   //      Float_t *charge Floating point array of the signals contributed
1095   //                      to this digit by each track.
1096   // Outputs:
1097   //      none.
1098   // Return:
1099   //      none.
1100
1101     if(!fDetTypeSim) {
1102       Error("AddSimDigit","fDetTypeSim is 0!");
1103       return;
1104     }
1105     fDetTypeSim->AddSimDigit(branch,phys,digits,tracks,hits,charges,sigexpanded);
1106
1107 }
1108 //______________________________________________________________________
1109 void AliITS::Digits2Raw(){
1110     // convert digits of the current event to raw data
1111
1112   if(!fDetTypeSim) {
1113     Error("Digits2Raw","fDetTypeSim is 0!");
1114     return;
1115   }
1116   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
1117   SetDefaults();
1118   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
1119   fDetTypeSim->GetLoader()->LoadDigits();
1120   TTree* digits = fDetTypeSim->GetLoader()->TreeD();
1121   if (!digits) {
1122       Error("Digits2Raw", "no digits tree");
1123       return;
1124   }
1125   fDetTypeSim->SetTreeAddressD(digits,(Char_t*)GetName());
1126   
1127    // Get the FO signals for this event
1128   AliITSFOSignalsSPD* foSignals = NULL;
1129   AliRunLoader* runLoader = AliRunLoader::Instance();
1130   AliITSLoader* itsLoader = (AliITSLoader*) runLoader->GetLoader("ITSLoader");
1131   if (!itsLoader) {
1132     AliError("ITS loader is NULL.");
1133   }
1134    else {
1135       if(!itsLoader->TreeD()) AliError("   !!! No TreeD available !!!");
1136       foSignals = (AliITSFOSignalsSPD*)itsLoader->TreeD()->GetUserInfo()->FindObject("AliITSFOSignalsSPD");
1137       if(!foSignals) AliError("FO signals not retrieved");
1138      }
1139  
1140   Bool_t deleteFOsignalsLater = kFALSE;
1141   if (!foSignals) {
1142     AliError("FO signals not available. No FO bits will be written.");
1143     foSignals = new AliITSFOSignalsSPD(); // make a temporary dummy signals object
1144     deleteFOsignalsLater = kTRUE;
1145   }
1146   
1147   
1148   AliITSDDLModuleMapSDD* ddlsdd=fDetTypeSim->GetDDLModuleMapSDD();
1149   Char_t rawSDD=fDetTypeSim->GetSimuParam()->GetSDDRawDataFormat();
1150   AliITSDDLRawData rawWriter;
1151   
1152   rawWriter.SetSDDRawFormat(rawSDD);
1153   //Verbose level
1154   // 0: Silent
1155   // 1: cout messages
1156   // 2: txt files with digits 
1157   //BE CAREFUL, verbose level 2 MUST be used only for debugging and
1158   //it is highly suggested to use this mode only for debugging digits files
1159   //reasonably small, because otherwise the size of the txt files can reach
1160   //quickly several MB wasting time and disk space.
1161   rawWriter.SetVerbose(0);
1162     
1163   //SILICON PIXEL DETECTOR
1164   AliDebug(1,"Formatting raw data for SPD");
1165   rawWriter.RawDataSPD(digits->GetBranch("ITSDigitsSPD"),foSignals);
1166   if(deleteFOsignalsLater) delete foSignals;
1167     
1168   //SILICON DRIFT DETECTOR
1169   AliDebug(1,Form("Formatting raw data for SDD - Format code =%d",rawSDD));
1170   rawWriter.RawDataSDD(digits->GetBranch("ITSDigitsSDD"),ddlsdd);
1171     
1172   //SILICON STRIP DETECTOR
1173   AliDebug(1,"Formatting raw data for SSD");
1174   rawWriter.RawDataSSD(digits->GetBranch("ITSDigitsSSD"));
1175
1176   fLoader->UnloadDigits();
1177 }
1178 //______________________________________________________________________
1179 AliLoader* AliITS::MakeLoader(const char* topfoldername){ 
1180     //builds ITSgetter (AliLoader type)
1181     //if detector wants to use castomized getter, it must overload this method
1182
1183     AliDebug(1,Form("Creating AliITSLoader. Top folder is %s.",
1184          topfoldername));
1185     fLoader = new AliITSLoader(GetName(),topfoldername);
1186     return fLoader;
1187 }
1188 //______________________________________________________________________
1189 Bool_t AliITS::Raw2SDigits(AliRawReader* rawReader)
1190 {
1191   //
1192   // Converts RAW data to SDigits
1193   //
1194   // Get TreeS
1195   //
1196     Int_t last   = -1;
1197     Int_t size   = GetITSgeom()->GetIndexMax();
1198     TClonesArray** modA = new TClonesArray*[size];
1199     for (Int_t mod = 0; mod < size; mod++) modA[mod] = new TClonesArray("AliITSpListItem", 10000);
1200     
1201     AliLoader* loader =  (AliRunLoader::Instance())->GetLoader("ITSLoader");
1202     if (!loader){
1203         Error("Open","Can not get ITS loader from Run Loader");
1204         return kFALSE;
1205     }
1206
1207     TTree* tree = 0;
1208     tree = loader->TreeS();
1209     if (!tree){
1210         loader->MakeTree("S");
1211         tree = loader->TreeS();
1212     }
1213     //
1214     // Array for SDigits
1215     // 
1216     TClonesArray aSDigits("AliITSpListItem",10000), *itsSDigits=&aSDigits;
1217     Int_t bufsize = 32000;
1218     tree->Branch("ITS", &itsSDigits, bufsize);
1219     Int_t npx = 0;
1220     //
1221     // SPD
1222     //
1223     AliITSsegmentationSPD* segSPD = (AliITSsegmentationSPD*) fDetTypeSim->GetSegmentationModel(0);
1224     if(!segSPD){
1225       AliWarning("Set AliITS defaults");
1226       SetDefaults();
1227       segSPD = (AliITSsegmentationSPD*) fDetTypeSim->GetSegmentationModel(0);
1228     }
1229     npx = segSPD->Npx();
1230     Double_t thr, sigma; 
1231     
1232     AliITSRawStreamSPD inputSPD(rawReader);
1233     while(1){
1234         Bool_t next  = inputSPD.Next();
1235         if (!next) break;
1236
1237         Int_t module = inputSPD.GetModuleID();
1238         Int_t column = inputSPD.GetColumn();
1239         Int_t row    = inputSPD.GetRow();
1240         Int_t index  = npx * column + row;
1241
1242         if (module >= size) continue;
1243  
1244         last = (modA[module])->GetEntries();
1245         TClonesArray& dum = *modA[module];
1246         fDetTypeSim->GetSimuParam()->SPDThresholds(module,thr,sigma);
1247         thr += 1.;
1248         new (dum[last]) AliITSpListItem(-1, -1, module, index, thr);
1249     }
1250     rawReader->Reset();
1251
1252     //
1253     // SDD
1254     // 
1255     AliITSsegmentationSDD* segSDD = (AliITSsegmentationSDD*) fDetTypeSim->GetSegmentationModel(1);
1256     npx = segSDD->Npx();
1257     AliITSRawStreamSDD inputSDD(rawReader);
1258     AliITSDDLModuleMapSDD* ddlmap=fDetTypeSim->GetDDLModuleMapSDD();
1259     inputSDD.SetDDLModuleMap(ddlmap);
1260     while(1){
1261         Bool_t next  = inputSDD.Next();
1262         if (!next) break;
1263
1264         Int_t module = inputSDD.GetModuleID();
1265         Int_t anode  = inputSDD.GetAnode();
1266         Int_t time   = inputSDD.GetTime();
1267         Int_t signal10 = inputSDD.GetSignal();
1268         Int_t index  = npx * anode + time;
1269
1270         if (module >= size) continue;
1271         last = modA[module]->GetEntries();
1272         TClonesArray& dum = *modA[module];
1273         new (dum[last]) AliITSpListItem(-1, -1, module, index, Double_t(signal10));
1274         ((AliITSpListItem*) dum.At(last))->AddSignalAfterElect(module, index, Double_t(signal10));
1275         
1276     }
1277     rawReader->Reset();
1278
1279     //
1280     // SSD
1281     // 
1282     AliITSsegmentationSSD* segSSD = (AliITSsegmentationSSD*) fDetTypeSim->GetSegmentationModel(2);
1283     npx = segSSD->Npx();
1284     AliITSRawStreamSSD inputSSD(rawReader);
1285     while(1){
1286         Bool_t next  = inputSSD.Next();
1287         if (!next) break;
1288
1289         Int_t module  = inputSSD.GetModuleID();
1290         Int_t side    = inputSSD.GetSideFlag();
1291         Int_t strip   = inputSSD.GetStrip();
1292         Int_t signal  = inputSSD.GetSignal();
1293         Int_t index  = npx * side + strip;
1294
1295         if (module >= size) continue;
1296         
1297         last = modA[module]->GetEntries();
1298         TClonesArray& dum = *modA[module];
1299         new (dum[last]) AliITSpListItem(-1, -1, module, index, Double_t(signal));
1300     }
1301     rawReader->Reset();
1302      AliITSpListItem* sdig = 0;
1303     
1304     for (Int_t mod = 0; mod < size; mod++)
1305     {
1306         Int_t nsdig =  modA[mod]->GetEntries();
1307         for (Int_t ie = 0; ie < nsdig; ie++) {
1308             sdig = (AliITSpListItem*) (modA[mod]->At(ie));
1309             new (aSDigits[ie]) AliITSpListItem(-1, -1, mod, sdig->GetIndex(), sdig->GetSignal());
1310             Float_t sig = sdig->GetSignalAfterElect();
1311             if (sig > 0.) {
1312                 sdig = (AliITSpListItem*)aSDigits[ie];
1313                 sdig->AddSignalAfterElect(mod, sdig->GetIndex(), Double_t(sig));
1314             }
1315         }
1316         
1317         tree->Fill();
1318         aSDigits.Clear();
1319         modA[mod]->Clear();
1320     }
1321     loader->WriteSDigits("OVERWRITE");    
1322     delete modA;
1323     return kTRUE;
1324 }
1325
1326
1327 //______________________________________________________________________
1328 void AliITS::UpdateInternalGeometry(){
1329
1330   //reads new geometry from TGeo 
1331 //   AliDebug(1,"Delete ITSgeom and create a new one reading TGeo");
1332
1333   AliITSVersion_t version = (AliITSVersion_t)IsVersion();
1334   Int_t minor = 0;
1335   if(version==kvPPRasymmFMD) minor=2;  // default minor version for this geom.
1336   AliITSInitGeometry initgeom;
1337   AliITSgeom* geom = initgeom.CreateAliITSgeom(version,minor);
1338   SetITSgeom(geom);
1339 }
1340 //______________________________________________________________________
1341 AliTriggerDetector* AliITS::CreateTriggerDetector() const {
1342   // create an AliITSTrigger object (and set trigger conditions as input)
1343   return new AliITSTrigger(fDetTypeSim->GetTriggerConditions());
1344 }
1345