85e676c18e55532c62de7f1c42517839baa710b1
[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSU.cxx
1 /*
2 */
3
4 /**************************************************************************
5  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
6  *                                                                        *
7  * Author: The ALICE Off-line Project.                                    *
8  * Contributors are mentioned in the code where appropriate.              *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 /* $Id: AliITSU.cxx $ */
20
21
22 ///////////////////////////////////////////////////////////////////////////////
23 //                                                                           //
24 //      An overview of the basic philosophy of the ITS code development      //
25 // and analysis is show in the figure below.                                 //
26 //Begin_Html                                                                 //
27 /*                                               
28 <img src="picts/ITS/ITS_Analysis_schema.gif">
29 </pre>
30 <br clear=left>
31 <font size=+2 color=red>
32 <p>Roberto Barbera is in charge of the ITS Offline code (1999).
33 <a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
34 </font>
35 <pre>
36 */
37 //End_Html
38 //
39 //  AliITSU. Inner Traking System base class.
40 //  This class contains the base procedures for the Inner Tracking System
41 //
42 //Begin_Html
43 /*
44 <img src="picts/ITS/AliITS_Class_Diagram.gif">
45 </pre>
46 <br clear=left>
47 <font size=+2 color=red>
48 <p>This show the class diagram of the different elements that are part of
49 the AliITS class.
50 </font>
51 <pre>
52 */
53 //End_Html
54 //
55 // Version: 0
56 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
57 //
58 // Version: 1
59 // Modified and documented by Bjorn S. Nilsen
60 // July 11 1999
61 //
62 // Version: 2
63 // Modified and documented by A. Bologna
64 // October 18 1999
65 //
66 // AliITSU is the general base class for the ITS. Also see AliDetector for
67 // futher information.
68 //
69 ///////////////////////////////////////////////////////////////////////////////
70
71 #include <stdlib.h>
72 #include <TClonesArray.h>
73 #include <TFile.h>
74 #include <TParticle.h>
75 #include <TString.h>
76 #include <TTree.h>
77 #include <TVirtualMC.h>
78 #include <TMath.h>
79 #include "AliDetector.h"
80 #include "AliITSU.h"
81 #include "AliITSLoader.h"
82 #include "AliITSULoader.h"
83 #include "AliITSUHit.h"
84 #include "AliITSUSDigit.h"
85 #include "AliITSUSimulation.h"
86 #include "AliITSUSimulationPix.h"
87 #include "AliITSsimulationFastPoints.h"
88 #include "AliMC.h"
89 #include "AliITSUDigitizer.h"
90 #include "AliITSRecPoint.h"
91 #include "AliRawReader.h"
92 #include "AliRun.h"
93 #include "AliLog.h"
94 #include "AliITSdigit.h"
95 #include "AliITSUChip.h"
96 #include "AliITSUDigitPix.h"
97 #include "AliITSsegmentation.h"
98 #include "AliITSUSegmentationPix.h"
99 #include "AliITSUSimuParam.h"
100 #include "AliITSFOSignalsSPD.h"
101 #include "AliITSUParamList.h"
102 #include "AliCDBManager.h" // tmp! Later the simuparam should be loaded centrally
103 #include "AliCDBEntry.h"
104
105 using namespace TMath;
106
107 ClassImp(AliITSU)
108
109 //______________________________________________________________________
110 AliITSU::AliITSU() : 
111 AliDetector()
112   ,fEuclidOut(0)
113   ,fNLayers(0)
114   ,fIdSens(0)
115   ,fLayerName(0)
116   ,fTiming(kFALSE)
117   ,fGeomTGeo(0)
118   ,fSimuParam(0)
119   ,fModA(0)
120   ,fpSDigits(0)
121   ,fSDigits(0)
122   ,fDetHits(0)
123   ,fChipHits(0)
124   ,fDetDigits(0)
125   ,fSensMap(0)
126   ,fSimModelLr(0)
127   ,fSegModelLr(0)
128   ,fResponseLr(0)
129   ,fCalibration(0)
130   ,fRunNumber(0)
131   ,fSimInitDone(kFALSE)
132 {
133   // Default initializer for ITS  
134 }
135
136 //______________________________________________________________________
137 AliITSU::AliITSU(const Char_t *title, Int_t nlay) :
138   AliDetector("ITS",title)
139   ,fEuclidOut(0)
140   ,fNLayers(nlay)
141   ,fIdSens(0)
142   ,fLayerName(0)
143   ,fTiming(kFALSE)
144   ,fGeomTGeo(0)
145   ,fSimuParam(0)
146   ,fModA(0)
147   ,fpSDigits(0)
148   ,fSDigits(0)
149   ,fDetHits(0)
150   ,fChipHits(0)
151   ,fDetDigits(0)
152   ,fSensMap(0)
153   ,fSimModelLr(0)
154   ,fSegModelLr(0)
155   ,fResponseLr(0)
156   ,fCalibration(0)
157   ,fRunNumber(0)
158   ,fSimInitDone(kFALSE)
159 {
160   //     The standard Constructor for the ITS class. 
161   AliMC* mc = gAlice->GetMCApp();
162   if( mc && mc->GetHitLists() ) {
163     fHits = new TClonesArray("AliITSUHit",100); // from AliDetector
164     mc->AddHitList(fHits);  
165   }
166 }
167
168
169 //______________________________________________________________________
170 AliITSU::~AliITSU()
171 {
172   // Default destructor for ITS.
173   //  
174   delete fHits;
175   //  delete fSimuParam; // provided by the CDBManager
176   delete fSensMap;
177   if (fSimModelLr) {
178     for (int i=fNLayers;i--;) { // different layers may use the same simulation model
179       for (int j=i;j--;) if (fSimModelLr[j]==fSimModelLr[i]) fSimModelLr[j] = 0;
180       delete fSimModelLr[i];
181     }
182     delete[] fSimModelLr;
183   }
184   if (fSegModelLr) {
185     for (int i=fNLayers;i--;) { // different layers may use the same simulation model     
186       for (int j=i;j--;) if (fSegModelLr[j]==fSegModelLr[i]) fSegModelLr[j] = 0;
187       delete fSegModelLr[i];
188     }
189     delete[] fSegModelLr;
190   }
191   //
192   delete[] fResponseLr; // note: the response data is owned by the CDBManager, we don't delete them
193   //
194   delete[] fLayerName;  // Array of TStrings
195   delete[] fIdSens;
196   //
197   int nmod = fGeomTGeo ? fGeomTGeo->GetNChips() : 0;
198   if (fChipHits) fChipHits->Delete();
199   delete fChipHits;
200   if(fModA){
201     for(Int_t j=0; j<nmod; j++){
202       fModA[j]->Delete();
203       delete fModA[j];
204     }
205     delete[] fModA;
206   }
207   if (fpSDigits) { fpSDigits->Delete(); delete fpSDigits; }
208   if (fSDigits)  { fSDigits->Delete(); delete fSDigits; }
209   delete fGeomTGeo;
210   //
211 }
212
213 //______________________________________________________________________
214 AliDigitizer* AliITSU::CreateDigitizer(AliDigitizationInput* manager) const
215 {
216   // Creates the AliITSDigitizer in a standard way for use via AliChip.
217   // This function can not be included in the .h file because of problems
218   // with the order of inclusion (recursive).
219   // Inputs:
220   //    AliDigitizationInput *manager  The Manger class for Digitization
221   // Output:
222   //    none.
223   // Return:
224   //    A new AliITSRunDigitizer (cast as a AliDigitizer).
225   //
226   return new AliITSUDigitizer(manager);
227 }
228
229 //______________________________________________________________________
230 void AliITSU::Init() 
231 {
232   // Initializer ITS after it has been built
233   //     This routine initializes the AliITS class. It is intended to be
234   // called from the Init function in AliITSv?. Besides displaying a banner
235   // indicating that it has been called it initializes the array fIdSens
236   // and sets the default segmentation, response, digit and raw cluster
237   // classes therefore it should be called after a call to CreateGeometry.
238   //
239   if (!fIdSens) fIdSens = new Int_t[fNLayers];
240   for(int i=0;i<fNLayers;i++) fIdSens[i] = gMC ? gMC->VolId(fLayerName[i]) : 0;
241   fGeomTGeo     = new AliITSUGeomTGeo(kTRUE);
242   InitSimulation();
243   //
244 }
245
246 //______________________________________________________________________
247 void AliITSU::MakeBranch(Option_t* option)
248 {
249   // Creates Tree branches for the ITS.
250   // Inputs:
251   //      Option_t *option    String of Tree types S,D, and/or R.
252   //      const char *file    String of the file name where these branches
253   //                          are to be stored. If blank then these branches
254   //                          are written to the same tree as the Hits were
255   //                          read from.
256   // Outputs:
257   //      none.
258   // Return:
259   //      none.
260   
261   Bool_t cH = (strstr(option,"H")!=0);
262   Bool_t cS = (strstr(option,"S")!=0);
263   Bool_t cD = (strstr(option,"D")!=0);
264   
265   if(cH && (fHits == 0x0)) fHits = new TClonesArray("AliITSUHit", 1560);
266   AliDetector::MakeBranch(option);
267   
268   if(cS) MakeBranchS(0);
269   if(cD) MakeBranchD(0);
270   // 
271 }
272
273 //___________________________________________________________________
274 void AliITSU::MakeBranchS(const char* fl) 
275 {
276   // Creates Tree Branch for the ITS summable digits.
277   // Inputs:
278   //      cont char *fl  File name where SDigits branch is to be written
279   //                     to. If blank it write the SDigits to the same
280   //                     file in which the Hits were found.
281   //  
282   Int_t buffersize = 4000;
283   char branchname[31];
284   //
285   // only one branch for SDigits.
286   snprintf(branchname,30,"%s",GetName());
287   if(fLoader->TreeS()) MakeBranchInTree(fLoader->TreeS(),branchname,&fSDigits,buffersize,fl);
288   //
289 }
290
291 //______________________________________________________________________
292 void AliITSU::MakeBranchD(const char* file)
293 {
294   //Make branch for digits
295   MakeBranchInTreeD(fLoader->TreeD(),file);
296 }
297
298 //___________________________________________________________________
299 void AliITSU:: MakeBranchInTreeD(TTree* treeD, const char* file)
300 {
301   // Creates Tree branches for the ITS.
302   //
303   if (!treeD) {AliFatal("No tree provided");}
304   Int_t buffersize = 4000;
305   if (!fDetDigits) InitArrays();
306   //
307   for (Int_t i=0;i<kNChipTypes;i++) {
308     ResetDigits(i);
309     TClonesArray* darr = (TClonesArray*)fDetDigits->At(i);
310     AliDetector::MakeBranchInTree(treeD,Form("%sDigits%s",GetName(),fGeomTGeo->GetChipTypeName(i)),
311                                   &darr,buffersize,file);
312   }
313   //
314 }
315
316 //______________________________________________________________________
317 void AliITSU::InitArrays()
318 {
319   // initialize arrays
320   //
321   if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
322   //  
323   fDetDigits = new TObjArray(kNChipTypes);
324   for (Int_t i=0;i<kNChipTypes;i++) fDetDigits->AddAt(new TClonesArray(GetDigitClassName(i),100),i);
325   //
326   fSDigits = new TClonesArray("AliITSUSDigit",100);
327   //
328   fDetHits = new TClonesArray("AliITSUHit",100);
329   //
330   fChipHits = new TObjArray(fGeomTGeo->GetNChips());
331   for (int i=0;i<fGeomTGeo->GetNChips();i++) fChipHits->AddLast( new AliITSUChip(i,fGeomTGeo) );
332   //
333 }
334
335 //______________________________________________________________________
336 void AliITSU::SetTreeAddress()
337 {
338   // Set branch address for the Trees.
339   TTree *treeS = fLoader->TreeS();
340   if (treeS) {
341     TBranch* br = treeS->GetBranch(GetName());
342     if (br) br->SetAddress(&fSDigits);
343   }
344   //
345   TTree *treeD = fLoader->TreeD();
346   if (treeD) {
347     if (!fDetDigits) InitArrays();
348     for (int i=0;i<kNChipTypes;i++) {
349       TString brname = Form("%sDigits%s",GetName(),GetChipTypeName(i));
350       TBranch* br = treeD->GetBranch(brname.Data());
351       if (!br) continue;
352       TClonesArray* darr = (TClonesArray*)fDetDigits->At(i);
353       br->SetAddress(&darr);
354     }
355   }
356   if (fLoader->TreeH() && (fHits == 0x0)) fHits = new TClonesArray("AliITSUHit", 1560);
357   AliDetector::SetTreeAddress();
358   //
359 }
360
361 //______________________________________________________________________
362 void AliITSU::AddHit(Int_t track, Int_t *vol, Float_t *hits)
363 {
364   // Add an ITS hit
365   //     The function to add information to the AliITSUHit class. See the
366   // AliITSUHit class for a full description. This function allocates the
367   // necessary new space for the hit information and passes the variable
368   // track, and the pointers *vol and *hits to the AliITSUHit constructor
369   // function.
370   // Inputs:
371   //      Int_t   track   Track number which produced this hit.
372   //      Int_t   *vol    Array of Integer Hit information. See AliITSUHit.h
373   //      Float_t *hits   Array of Floating Hit information.  see AliITSUHit.h
374   TClonesArray &lhits = *fHits;
375   new(lhits[fNhits++]) AliITSUHit(fIshunt,track,vol,hits);
376   //
377 }
378
379 //______________________________________________________________________
380 void AliITSU::FillChips(Int_t bgrev, Option_t *option, const char *filename) 
381 {
382   // fill the chips with the sorted by chip hits; add hits from
383   // background if option=Add.
384   //
385   static TTree *trH1=0;                 //Tree with background hits
386   static Bool_t first=kTRUE;
387   static TFile *file = 0;
388   const char *addBgr = strstr(option,"Add");
389   //
390   if (addBgr ) {
391     if(first) {
392       file = new TFile(filename);    
393       first=kFALSE;
394     }
395     file->cd();
396     file->ls();
397     // Get Hits Tree header from file
398     if (trH1) {delete trH1; trH1=0;}
399     //
400     char treeName[21];
401     snprintf(treeName,20,"TreeH%d",bgrev);
402     trH1 = (TTree*)gDirectory->Get(treeName);
403     if (!trH1) Error("FillChips","cannot find Hits Tree for event:%d",bgrev);
404     // Set branch addresses
405   } // end if addBgr
406   
407   FillChips(fLoader->TreeH(),0); // fill from this file's tree.
408   //
409   if (addBgr ) {
410     FillChips(trH1,10000000); // Default mask 10M.
411     TTree *fAli=fLoader->GetRunLoader()->TreeK();
412     TFile *fileAli=0;
413     if (fAli) {
414       fileAli = fAli->GetCurrentFile();
415       fileAli->cd();
416     }
417   } // end if add
418   //  
419 }
420
421 //______________________________________________________________________
422 void AliITSU::FillChips(TTree *treeH, Int_t /*mask*/)
423 {
424   // fill the chips with the sorted by chip hits; 
425   // can be called many times to do a merging
426   // Inputs:
427   //      TTree *treeH  The tree containing the hits to be copied into
428   //                    the chips.
429   //      Int_t mask    The track number mask to indecate which file
430   //                    this hits came from.
431   //  
432   if (treeH == 0x0) { AliError("Tree H  is NULL"); return; }
433   //
434   Int_t lay,sta,ssta,mod,chip,index;
435   AliITSUHit *itsHit=0;
436   char branchname[21];
437   snprintf(branchname,20,"%s",GetName());
438   TBranch *branch = treeH->GetBranch(branchname);
439   if (!branch) {Error("FillChips","%s branch in TreeH not found",branchname); return;} // end if !branch
440   //
441   branch->SetAddress(&fHits);
442   Int_t nTracks =(Int_t) treeH->GetEntries();
443   Int_t iPrimTrack,h;
444   for (iPrimTrack=0; iPrimTrack<nTracks; iPrimTrack++) {
445     ResetHits();
446     Int_t nBytes = treeH->GetEvent(iPrimTrack);
447     if (nBytes <= 0) continue;
448     Int_t nHits = fHits->GetEntriesFast();
449     for (h=0; h<nHits; h++){
450       itsHit = (AliITSUHit *)fHits->UncheckedAt(h);
451       itsHit->GetChipID(lay,sta,ssta,mod,chip);
452       index = fGeomTGeo->GetChipIndex(lay,sta,ssta,mod,chip); // !!! AliITSHit counts indices from 1!
453       itsHit = new( (*fDetHits)[fDetHits->GetEntriesFast()] ) AliITSUHit(*itsHit);
454       itsHit->SetUniqueID(h);
455       GetChip(index)->AddHit(itsHit);
456       // do we need to add a mask?
457       // itsHit->SetTrack(itsHit->GetTrack()+mask);
458     } // end loop over hits 
459   } // end loop over tracks
460 }
461
462 //______________________________________________________________________
463 void AliITSU::ClearChips()
464 {
465   // clear accumulated hits
466   if (!fChipHits || !fDetHits) AliFatal("Hits accumulation arrays are not defined");
467   for (int i=fGeomTGeo->GetNChips();i--;) GetChip(i)->Clear();
468   fDetHits->Clear();
469 }
470
471 //______________________________________________________________________
472 void AliITSU::Hits2SDigits()
473 {
474   // Standard Hits to summable Digits function.
475   if (!IsSimInitDone()) InitSimulation();
476   fLoader->LoadHits("read");
477   fLoader->LoadSDigits("recreate");
478   AliRunLoader* rl = fLoader->GetRunLoader(); 
479   //
480   for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
481     rl->GetEvent(iEvent);
482     if (!fLoader->TreeS()) fLoader->MakeTree("S");
483     MakeBranch("S");
484     SetTreeAddress();
485     Hits2SDigits(iEvent,0," "," ");
486   } // end for iEvent
487     //
488   fLoader->UnloadHits();
489   fLoader->UnloadSDigits();
490   // 
491 }
492
493 //______________________________________________________________________
494 void AliITSU::Hits2SDigits(Int_t evNumber,Int_t bgrev,Option_t *option,const char *filename)
495 {
496   // Keep galice.root for signal and name differently the file for 
497   // background when add! otherwise the track info for signal will be lost !
498   // Inputs:
499   //      Int_t evnt       Event to be processed.
500   //      Int_t bgrev      Background Hit tree number.
501   //      Int_t nchips   Not used.
502   //      Option_t *option String indicating if merging hits or not. To
503   //                       merge hits set equal to "Add". Otherwise no
504   //                       background hits are considered.
505   //      Test_t *filename File name containing the background hits..
506   //
507   if (!IsSimInitDone()) InitSimulation();
508   FillChips(bgrev,option,filename);
509   //
510   Int_t nchips = fGeomTGeo->GetNChips();
511   int prevLr = -1;
512   float roPhase=0; // synchronysation type between layers/chips
513   Bool_t randomyzeChips = kFALSE; // do we need to randomize layers
514   //
515   for(int chip=0;chip<nchips;chip++) {
516     int lr = fGeomTGeo->GetLayer(chip);
517     AliITSUSimulation* sim = GetSimulationModel(lr);
518     sim->InitSimulationChip(GetChip(chip),evNumber/*,gAlice->GetEvNumber()*/,GetSegmentation(lr),GetResponseParam(lr));
519     //
520     if (prevLr!=lr) { // new layer started)
521       roPhase = fSimuParam->GetLrROCycleShift(lr);
522       if (Abs(roPhase)<1.) roPhase = roPhase*sim->GetReadOutCycleLength(); // chips synchronized within layer with this offset
523       else                randomyzeChips = kTRUE;                     // chips have random offset
524     }
525     if (randomyzeChips) sim->GenerateReadOutCycleOffset();
526     else                  sim->SetReadOutCycleOffset(roPhase);
527     //
528     sim->SDigitiseChip();
529     fLoader->TreeS()->Fill();      // fills all branches - wasted disk space
530     ResetSDigits();
531     prevLr = lr;
532   } 
533   //
534   ClearChips();
535   //
536   fLoader->TreeS()->GetEntries();
537   fLoader->TreeS()->AutoSave();
538   fLoader->WriteSDigits("OVERWRITE");
539   fLoader->TreeS()->Reset();
540 }
541
542 //______________________________________________________________________
543 void AliITSU::Hits2Digits()
544 {
545   // Standard Hits to Digits function.
546   if (!IsSimInitDone()) InitSimulation();
547   fLoader->LoadHits("read");
548   fLoader->LoadDigits("recreate");
549   AliRunLoader* rl = fLoader->GetRunLoader(); 
550   //
551   for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
552     rl->GetEvent(iEvent);
553     if (!fLoader->TreeD()) fLoader->MakeTree("D");
554     MakeBranch("D");
555     SetTreeAddress();
556     Hits2Digits(iEvent,0," "," ");
557   } // end for iEvent
558     //
559   fLoader->UnloadHits();
560   fLoader->UnloadSDigits();
561   // 
562 }
563
564 //______________________________________________________________________
565 void AliITSU::Hits2Digits(Int_t evNumber,Int_t bgrev,Option_t *option,const char *filename)
566 {
567   //   Keep galice.root for signal and name differently the file for 
568   // background when add! otherwise the track info for signal will be lost !
569   // Inputs:
570   //      Int_t evnt       Event to be processed.
571   //      Int_t bgrev      Background Hit tree number.
572   //      Option_t *option String indicating if merging hits or not. To
573   //                       merge hits set equal to "Add". Otherwise no
574   //                       background hits are considered.
575   //      Test_t *filename File name containing the background hits..
576   // Outputs:
577   //  
578   if (!IsSimInitDone()) InitSimulation();
579   FillChips(bgrev,option,filename);
580   // 
581   Int_t nchips = fGeomTGeo->GetNChips();
582   int prevLr = -1;
583   float roPhase=0; // synchronysation type between layers/chips
584   Bool_t randomyzeChips = kFALSE; // do we need to randomize layers
585   //
586   for (Int_t chip=0;chip<nchips;chip++) {
587     int lr = fGeomTGeo->GetLayer(chip);
588     AliITSUSimulation* sim = GetSimulationModel(lr);
589     //
590     sim->InitSimulationChip(GetChip(chip),evNumber/*gAlice->GetEvNumber()*/,GetSegmentation(lr),GetResponseParam(lr));
591     if (prevLr!=lr) { // new layer started)
592       roPhase = fSimuParam->GetLrROCycleShift(lr);
593       if (Abs(roPhase)<1.) roPhase = roPhase*sim->GenerateReadOutCycleOffset(); // chips synchronized within layer with this offset
594       else                randomyzeChips = kTRUE;                     // chips have random offset
595     }
596     if (randomyzeChips) sim->GenerateReadOutCycleOffset();
597     else                  sim->SetReadOutCycleOffset(roPhase);
598     sim->DigitiseChip();
599     // fills all branches - wasted disk space
600     fLoader->TreeD()->Fill(); 
601     ResetDigits();
602     prevLr = lr;
603   } // end for chip
604   //
605   ClearChips();
606   //
607   //    WriteFOSignals(); // Add Fast-OR signals to event (only one object per event)
608   fLoader->TreeD()->GetEntries();
609   fLoader->TreeD()->AutoSave();
610   fLoader->TreeD()->Reset(); 
611   //
612 }
613
614 //_____________________________________________________________________
615 void AliITSU::Hits2FastRecPoints(Int_t bgrev,Option_t *opt,const char *flnm)
616 {
617   // keep galice.root for signal and name differently the file for 
618   // background when add! otherwise the track info for signal will be lost !
619   // Inputs:
620   //      Int_t evnt       Event to be processed.
621   //      Int_t bgrev      Background Hit tree number.
622   //      Option_t *opt    Option passed to FillChips. See FillChips.
623   //      Test_t *flnm     File name containing the background hits..
624   // Outputs:
625   //      none.
626   // Return:
627   //      none.
628   if (!IsSimInitDone()) InitSimulation();
629   AliITSULoader *pITSloader = (AliITSULoader*)fLoader;
630   Int_t nchips = fGeomTGeo->GetNChips();
631   FillChips(bgrev,opt,flnm);
632   //
633   TTree *lTR = pITSloader->TreeR();
634   if(!lTR) {
635     pITSloader->MakeTree("R");
636     lTR = pITSloader->TreeR();
637   }
638   //
639   TClonesArray* ptarray = new TClonesArray("AliITSRecPoint",1000);
640   TBranch* branch = (TBranch*)lTR->Branch("ITSRecPointsF",&ptarray);
641   branch->SetAddress(&ptarray);
642   for (int chip=0;chip<nchips;chip++){
643     int id = fGeomTGeo->GetChipChipTypeID(chip);
644     AliITSUSimulation* sim = GetSimulationModel(id);
645     if (!sim) AliFatal(Form("The sim.class for chip %d of ChipTypeID %d is missing",chip,id));
646     sim->CreateFastRecPoints( GetChip(chip) ,chip,gRandom,ptarray);
647     lTR->Fill();
648     ptarray->Clear();
649   } // end for chip
650   //
651   ClearChips();
652   fLoader->WriteRecPoints("OVERWRITE");
653   delete ptarray;
654 }
655
656 //_____________________________________________________________________
657 Int_t AliITSU::Hits2Clusters(TTree */*hTree*/, TTree */*cTree*/)
658 {
659   /* RS: TODO
660   // This function creates ITS clusters
661   if (!IsSimInitDone()) InitSimulation();
662   Int_t mmax = 0;
663   FillChips(hTree,0);
664   //
665   TClonesArray *points = new TClonesArray("AliITSRecPoint",1000);
666   TBranch *branch=cTree->GetBranch("ITSRecPoints");
667   if (!branch) cTree->Branch("ITSRecPoints",&points);
668   else branch->SetAddress(&points);
669   //
670   AliITSsimulationFastPoints sim;
671   Int_t ncl=0;
672   for (Int_t m=0; m<mmax; m++) {
673     sim.CreateFastRecPoints(GetChip(m),m,gRandom,points);      
674     ncl+=points->GetEntriesFast();
675     cTree->Fill();
676     points->Clear();
677   }
678   //
679   ClearChips();
680   //
681   AliDebug(1,Form("Number of found fast clusters : %d",ncl));
682   //cTree->Write();
683   delete points;
684   */
685   return 0;
686 }
687
688 //_____________________________________________________________________
689 void AliITSU::CheckLabels(Int_t lab[3]) const //RSDONE
690 {
691   // Tries to find mother's labels
692   //
693   if(lab[0]<0 && lab[1]<0 && lab[2]<0) return; // In case of no labels just exit
694   //
695   Int_t ntracks = gAlice->GetMCApp()->GetNtrack();
696   for (Int_t i=0;i<3;i++){
697     Int_t label = lab[i];
698     if (label>=0 && label<ntracks) {
699       TParticle *part=(TParticle*)gAlice->GetMCApp()->Particle(label);
700       if (part->P() < 0.005) {
701         Int_t m=part->GetFirstMother();
702         if (m<0) continue;
703         if (part->GetStatusCode()>0) continue;
704         lab[i]=m;       
705       }
706     }    
707   }
708   //
709 }
710
711 //______________________________________________________________________
712 void AliITSU::ResetDigits() //RSDONE?
713 {
714   // Reset number of digits and the digits array for the ITS detector.
715   if (fDetDigits) for (int i=kNChipTypes;i--;) ResetDigits(i);
716   //
717 }
718
719 //______________________________________________________________________
720 void AliITSU::ResetDigits(Int_t branch)
721 {
722   // Reset number of digits and the digits array for this branch.
723   if (fDetDigits) ((TClonesArray*)fDetDigits->At(branch))->Clear();
724   //
725 }
726
727 //______________________________________________________________________
728 void AliITSU::AddSumDigit(AliITSUSDigit &sdig)
729 {
730   // Adds the chip summable digits to the summable digits tree.
731   new( (*fSDigits)[fSDigits->GetEntriesFast()]) AliITSUSDigit(sdig);
732   //  
733 }
734
735 //______________________________________________________________________
736 void AliITSU::AddSimDigit(Int_t branch, AliITSdigit *d)
737 {
738   //    Add a simulated digit.
739   // Inputs:
740   //      Int_t id        Detector type number.
741   //      AliITSdigit *d  Digit to be added to the Digits Tree. See 
742   //                      AliITSdigit.h
743   TClonesArray &ldigits = *((TClonesArray*)fDetDigits->At(branch));
744   int nd = ldigits.GetEntriesFast();
745   switch(branch){
746   case AliITSUGeomTGeo::kChipTypePix:
747     new(ldigits[nd]) AliITSUDigitPix(*((AliITSUDigitPix*)d));
748     break;
749   default:
750     AliFatal(Form("Unknown digits branch %d",branch));
751   }
752 }
753
754 //______________________________________________________________________
755 void AliITSU::AddSimDigit(Int_t branch,Float_t /*phys*/,Int_t *digits,Int_t *tracks,
756                           Int_t *hits,Float_t */*charges*/, Int_t /*sigexpanded*/)
757 {
758   // Add a simulated digit to the list.
759   // Inputs:
760   //      Int_t id        Detector type number.
761   //      Float_t phys    Physics indicator. See AliITSdigits.h
762   //      Int_t *digits   Integer array containing the digits info. See 
763   //                      AliITSdigit.h
764   //      Int_t *tracks   Integer array [AliITSdigitS?D::GetNTracks()] 
765   //                      containing the track numbers that contributed to
766   //                      this digit.
767   //      Int_t *hits     Integer array [AliITSdigitS?D::GetNTracks()]
768   //                      containing the hit numbers, from AliITSchip, that
769   //                      contributed to this digit.
770   //      Float_t *charge Floating point array of the signals contributed
771   //                      to this digit by each track.
772   TClonesArray &ldigits = *((TClonesArray*)fDetDigits->At(branch));
773   int nd = ldigits.GetEntriesFast();
774   switch(branch){
775   case AliITSUGeomTGeo::kChipTypePix:
776     new(ldigits[nd]) AliITSUDigitPix(digits,tracks,hits);
777     break;
778   default:
779     AliFatal(Form("Unknown digits branch %d",branch));
780   }  
781   //
782 }
783
784 //______________________________________________________________________
785 void AliITSU::Digits2Raw()
786 {
787   AliError("Not ready");
788 }
789
790 //______________________________________________________________________
791 AliLoader* AliITSU::MakeLoader(const char* topfoldername)
792
793   //builds ITSgetter (AliLoader type)
794   //if detector wants to use castomized getter, it must overload this method
795   
796   AliDebug(1,Form("Creating AliITSULoader. Top folder is %s.",topfoldername));
797   fLoader = new AliITSULoader(GetName(),topfoldername);
798   return fLoader;
799 }
800
801 //______________________________________________________________________
802 Bool_t AliITSU::Raw2SDigits(AliRawReader* /*rawReader*/)
803 {
804   AliError("Not ready");
805   return kFALSE;
806 }
807
808 //______________________________________________________________________
809 /*
810 AliTriggerDetector* AliITSU::CreateTriggerDetector() const 
811 {
812   // create an AliITSTrigger object (and set trigger conditions as input)
813   return new AliITSTrigger(fChipTypeSim->GetTriggerConditions());
814 }
815 */
816
817 //______________________________________________________________________
818 void AliITSU::WriteFOSignals()
819 {
820   // This method write FO signals in Digits tree both in Hits2Digits
821   // or SDigits2Digits
822   AliError("Not ready");
823   //  fChipTypeSim->ProcessNoiseForFastOr();
824 }
825
826 //_______________________________________________________________________
827 void AliITSU::SDigits2Digits()
828 {
829   // Standard Summable digits to Digits function.
830   //
831   if (!IsSimInitDone()) InitSimulation();
832   TTree* trees = fLoader->TreeS();
833   if( !(trees && fSDigits) ) AliFatal("Error: No trees or SDigits.");
834   TBranch* brchSDigits = trees->GetBranch(GetName());
835   //
836   int nchips = fGeomTGeo->GetNChips();
837   int prevLr = -1;
838   float roPhase=0; // synchronysation type between layers/chips
839   Bool_t randomyzeChips = kFALSE; // do we need to randomize layers
840   //
841   for (int chip=0;chip<nchips;chip++) {
842     int lr = fGeomTGeo->GetLayer(chip);
843     AliITSUSimulation* sim = GetSimulationModel(lr);
844     sim->InitSimulationChip(GetChip(chip),gAlice->GetEvNumber(),GetSegmentation(lr),GetResponseParam(lr));
845     //
846     if (prevLr!=lr) { // new layer started)
847       roPhase = fSimuParam->GetLrROCycleShift(lr);
848       if (Abs(roPhase)<1.) roPhase = roPhase*sim->GenerateReadOutCycleOffset(); // chips synchronized within layer with this offset
849       else                randomyzeChips = kTRUE;                     // chips have random offset
850     }
851     if (randomyzeChips) sim->GenerateReadOutCycleOffset();
852     else                  sim->SetReadOutCycleOffset(roPhase);
853     //
854     fSDigits->Clear();
855     brchSDigits->GetEvent(chip);
856     sim->AddSDigitsToChip(fSDigits,0);
857     sim->FinishSDigitiseChip();
858     fLoader->TreeD()->Fill();
859     ResetDigits();
860     prevLr = lr;
861   }
862   //  WriteFOSignals(); 
863   fLoader->TreeD()->GetEntries();
864   fLoader->TreeD()->AutoSave();
865   fLoader->TreeD()->Reset();
866 }
867
868 //_______________________________________________________________________
869 void AliITSU::InitSimulation()
870 {
871   // Initialize arrays, segmentations ets, needed for simulation
872   // Equivalent of old AliITSChipTypeSim construction
873   //
874   if (fSimInitDone) {AliInfo("Already done"); return;}
875   //
876   AliCDBEntry* cdbEnt = AliCDBManager::Instance()->Get("ITS/Calib/SimuParam"); // tmp: load it centrally
877   if (!cdbEnt) {AliFatal("Failed to find ITS/Calib/SimuParam on CDB"); exit(1);}
878   fSimuParam    = (AliITSUSimuParam*)cdbEnt->GetObject();
879   //
880   fSensMap      = new AliITSUSensMap("AliITSUSDigit",0,0);
881   fSimModelLr   = new AliITSUSimulation*[fNLayers];
882   fSegModelLr   = new AliITSsegmentation*[fNLayers];
883   fResponseLr   = new AliITSUParamList*[fNLayers];
884   //
885   TObjArray arrSeg;
886   AliITSUSegmentationPix::LoadSegmentations(&arrSeg, AliITSUGeomTGeo::GetITSsegmentationFileName());
887   //
888   // add known simulation types used in the setup
889   for (int i=fNLayers;i--;) {
890     fSimModelLr[i] = 0;
891     fSegModelLr[i] = 0;
892     fResponseLr[i] = 0;
893     int dType = fGeomTGeo->GetLayerChipTypeID(i);           // fine detector type: class + segmentation
894     int sType = dType/AliITSUGeomTGeo::kMaxSegmPerChipType; // detector simulation class
895     //
896     // check if the simulation of this sType was already created for preceeding layers
897     AliITSUSimulation* simUpg = 0;
898     for (int j=fNLayers-1;j>i;j--) {
899       simUpg = GetSimulationModel(j);
900       if (simUpg && int(simUpg->GetUniqueID())==sType) break;
901       else simUpg = 0;
902     }
903     //
904     if (!simUpg) { // need to create simulation for detector class sType
905       switch (sType) 
906         {
907         case AliITSUGeomTGeo::kChipTypePix : 
908           simUpg = new AliITSUSimulationPix(fSimuParam,fSensMap); 
909           break;
910         default: AliFatal(Form("No %d detector type is defined",sType));
911         }
912     }
913     fSimModelLr[i] = simUpg;
914     //
915     // add segmentations used in the setup
916     if (!(fSegModelLr[i]=(AliITSsegmentation*)arrSeg[dType])) {AliFatal(Form("Segmentation for ChipType#%d is not found",dType)); exit(1);}
917     //
918     // add response function for the detectors of this layer
919     if ( !(fResponseLr[i]=(AliITSUParamList*)fSimuParam->FindRespFunParams(dType)) ) {AliFatal(Form("Response for ChipType#%d is not found in SimuParams",dType)); exit(1);}
920   }
921   // delete non needed segmentations
922   for (int i=fNLayers;i--;) arrSeg.Remove(fSegModelLr[i]);
923   arrSeg.Delete();
924   //
925   InitArrays();
926   //
927   fSimInitDone = kTRUE;
928   //
929 }