ITSSPDPHYSda: New detector algorithm for finding dead and noisy pixels.
[u/mrichter/AliRoot.git] / ITS / AliITSDetTypeSim.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 /*
17  $Id$
18 */
19
20
21 /////////////////////////////////////////////////////////////////////
22 // Base simulation functions for ITS                               //
23 //                                                                 //
24 //                                                                 //
25 /////////////////////////////////////////////////////////////////////          
26 #include "TBranch.h"
27 #include "TClonesArray.h"
28 #include "TObjArray.h"
29 #include "TTree.h"
30
31 #include "AliRun.h"
32
33 #include "AliCDBManager.h"
34 #include "AliCDBId.h"
35 #include "AliCDBStorage.h"
36 #include "AliCDBEntry.h"
37 #include "AliCDBMetaData.h"
38
39 #include "AliITSdigit.h"
40 #include "AliITSdigitSPD.h"
41 #include "AliITSdigitSDD.h"
42 #include "AliITSdigitSSD.h"
43 #include "AliITSDetTypeSim.h"
44 #include "AliITSpListItem.h"
45 #include "AliITSresponseSDD.h"
46 #include "AliITSCalibrationSDD.h"
47 #include "AliITSMapSDD.h"
48 #include "AliITSCalibrationSSD.h"
49 #include "AliITSNoiseSSD.h"
50 #include "AliITSGainSSD.h"
51 #include "AliITSBadChannelsSSD.h"
52 #include "AliITSCalibrationSSD.h"
53 #include "AliITSsegmentationSPD.h"
54 #include "AliITSsegmentationSDD.h"
55 #include "AliITSsegmentationSSD.h"
56 #include "AliITSsimulation.h"
57 #include "AliITSsimulationSPD.h"
58 #include "AliITSsimulationSDD.h"
59 #include "AliITSsimulationSSD.h"
60
61
62 const Int_t AliITSDetTypeSim::fgkNdettypes = 3;
63 const Int_t AliITSDetTypeSim::fgkDefaultNModulesSPD =  240;
64 const Int_t AliITSDetTypeSim::fgkDefaultNModulesSDD =  260;
65 const Int_t AliITSDetTypeSim::fgkDefaultNModulesSSD = 1698;
66
67 ClassImp(AliITSDetTypeSim)
68
69 //----------------------------------------------------------------------
70 AliITSDetTypeSim::AliITSDetTypeSim():
71 TObject(),
72 fSimulation(),   // [NDet]
73 fSegmentation(), // [NDet]
74 fCalibration(),     // [NMod]
75 fPreProcess(),   // [] e.g. Fill fHitModule with hits
76 fPostProcess(),  // [] e.g. Wright Raw data
77 fNSDigits(0),    //! number of SDigits
78 fSDigits(),      //! [NMod][NSDigits]
79 fNDigits(0),     //! number of Digits
80 fRunNumber(0),   //! Run number (to access DB)
81 fDigits(),       //! [NMod][NDigits]
82 fHitClassName(), // String with Hit class name.
83 fSDigClassName(),// String with SDigit class name.
84 fDigClassName(), // String with digit class name.
85 fLoader(0),      // local pointer to loader
86 fFirstcall(kTRUE){ // flag
87     // Default Constructor
88     // Inputs:
89     //    none.
90     // Outputs:
91     //    none.
92     // Return:
93     //    A properly zero-ed AliITSDetTypeSim class.
94
95   fSimulation = new TObjArray(fgkNdettypes);
96   fSegmentation = new TObjArray(fgkNdettypes);
97   fSegmentation->SetOwner(kTRUE);
98   fSDigits = new TClonesArray("AliITSpListItem",1000);
99   fDigits = new TObjArray(fgkNdettypes);
100   fNDigits = new Int_t[fgkNdettypes];
101   fNMod[0] = fgkDefaultNModulesSPD;
102   fNMod[1] = fgkDefaultNModulesSDD;
103   fNMod[2] = fgkDefaultNModulesSSD;
104   SetRunNumber();
105 }
106 //----------------------------------------------------------------------
107 AliITSDetTypeSim::~AliITSDetTypeSim(){
108     // Destructor
109     // Inputs:
110     //    none.
111     // Outputs:
112     //    none.
113     // Return:
114     //    Nothing.
115
116     if(fSimulation){
117         fSimulation->Delete();
118         delete fSimulation;
119     }
120     fSimulation = 0;
121     if(fSegmentation){
122         fSegmentation->Delete();
123         delete fSegmentation;
124     }
125     fSegmentation = 0;
126     if(fCalibration && fRunNumber<0){
127         AliITSresponse* rspd = ((AliITSCalibration*)fCalibration->At(
128                                GetITSgeom()->GetStartSPD()))->GetResponse();
129         AliITSresponse* rsdd = ((AliITSCalibration*)fCalibration->At(
130                                GetITSgeom()->GetStartSDD()))->GetResponse();
131         AliITSresponse* rssd = ((AliITSCalibration*)fCalibration->At(
132                                GetITSgeom()->GetStartSSD()))->GetResponse();
133         if(rspd) delete rspd;
134         if(rsdd) delete rsdd;
135         if(rssd) delete rssd;
136         fCalibration->Delete();
137         delete fCalibration;
138     }
139     fCalibration = 0;
140     if(fPreProcess){
141         fPreProcess->Delete();
142         delete fPreProcess;
143     }
144     fPreProcess = 0;
145     if(fPostProcess){
146         fPostProcess->Delete();
147         delete fPostProcess;
148     }
149     fPostProcess = 0;
150     if(fNDigits) delete [] fNDigits;
151     fNDigits = 0;
152     if (fLoader)fLoader->GetModulesFolder()->Remove(this);
153     fLoader = 0; // Not deleting it.
154     if (fSDigits) {
155         fSDigits->Delete();
156         delete fSDigits;
157     }
158     fSDigits=0;
159     if (fDigits) {
160       fDigits->Delete();
161       delete fDigits;
162     }
163     fDigits=0;
164 }
165 //----------------------------------------------------------------------
166 AliITSDetTypeSim::AliITSDetTypeSim(const AliITSDetTypeSim &source) : TObject(source),
167 fSimulation(source.fSimulation),   // [NDet]
168 fSegmentation(source.fSegmentation), // [NDet]
169 fCalibration(source.fCalibration),     // [NMod]
170 fPreProcess(source.fPreProcess),   // [] e.g. Fill fHitModule with hits
171 fPostProcess(source.fPostProcess),  // [] e.g. Wright Raw data
172 fNSDigits(source.fNSDigits),    //! number of SDigits
173 fSDigits(source.fSDigits),      //! [NMod][NSDigits]
174 fNDigits(source.fNDigits),     //! number of Digits
175 fRunNumber(source.fRunNumber),   //! Run number (to access DB)
176 fDigits(source.fDigits),       //! [NMod][NDigits]
177 fHitClassName(source.fHitClassName), // String with Hit class name.
178 fSDigClassName(source.fSDigClassName),// String with SDigit class name.
179 fDigClassName(), // String with digit class name.
180 fLoader(source.fLoader),      // local pointer to loader
181 fFirstcall(source.fFirstcall)
182 {
183     // Copy Constructor for object AliITSDetTypeSim not allowed
184   for(Int_t i=0;i<fgkNdettypes;i++){
185     fDigClassName[i] = source.fDigClassName[i];
186   }
187 }
188 //----------------------------------------------------------------------
189 AliITSDetTypeSim& AliITSDetTypeSim::operator=(const AliITSDetTypeSim &source){
190     // The = operator for object AliITSDetTypeSim
191  
192   this->~AliITSDetTypeSim();
193   new(this) AliITSDetTypeSim(source);
194   return *this;
195 }
196
197 //______________________________________________________________________
198 void AliITSDetTypeSim::SetITSgeom(AliITSgeom *geom){
199     // Sets/replaces the existing AliITSgeom object kept in AliITSLoader
200     // 
201     // Inputs:
202     //   AliITSgoem   *geom  The AliITSgeom object to be used.
203     // Output:
204     //   none.
205     // Return:
206     //   none.
207   if(!fLoader){
208     Error("SetITSgeom","No pointer to loader - nothing done");
209     return;
210   }
211   else {
212     fLoader->SetITSgeom(geom);  // protections in AliITSLoader::SetITSgeom
213   }
214  
215 }
216 //______________________________________________________________________
217 void AliITSDetTypeSim::SetLoader(AliITSLoader *loader){
218     // Sets the local copy of the AliITSLoader, and passes on the
219     // AliITSgeom object as needed.
220     // Inputs
221     //   AliITSLoader  *loader pointer to AliITSLoader for local use
222     // Outputs:
223     //   none.
224     // Return:
225     //  none.
226
227     if(fLoader==loader) return; // Same do nothing
228     if(fLoader){ // alread have an existing loader
229         Error("SetLoader",
230                 "Already have an exisiting loader ptr=%p Nothing done",
231                 fLoader);
232     } // end if
233     fLoader = loader;
234 }
235 //______________________________________________________________________
236 void AliITSDetTypeSim::SetSimulationModel(Int_t dettype,AliITSsimulation *sim){
237
238   //Set simulation model for detector type
239
240   if(fSimulation==0) fSimulation = new TObjArray(fgkNdettypes);
241   fSimulation->AddAt(sim,dettype);
242 }
243 //______________________________________________________________________
244 AliITSsimulation* AliITSDetTypeSim::GetSimulationModel(Int_t dettype){
245
246   //Get simulation model for detector type
247   if(fSimulation==0)  {
248     Warning("GetSimulationModel","fSimulation is 0!");
249     return 0;     
250   }
251   return (AliITSsimulation*)(fSimulation->At(dettype));
252 }
253 //______________________________________________________________________
254 AliITSsimulation* AliITSDetTypeSim::GetSimulationModelByModule(Int_t module){
255
256   //Get simulation model by module number
257   if(GetITSgeom()==0) {
258     Warning("GetSimulationModelByModule","GetITSgeom() is 0!");
259     return 0;
260   }
261   
262   return GetSimulationModel(GetITSgeom()->GetModuleType(module));
263 }
264 //_______________________________________________________________________
265 void AliITSDetTypeSim::SetDefaultSegmentation(Int_t idet){
266     // Set default segmentation model objects
267     AliITSsegmentation *seg;
268
269     if(fSegmentation==0x0){
270         fSegmentation = new TObjArray(fgkNdettypes);
271         fSegmentation->SetOwner(kTRUE);
272     }
273     if(GetSegmentationModel(idet))
274         delete (AliITSsegmentation*)fSegmentation->At(idet);
275     if(idet==0){
276         seg = new AliITSsegmentationSPD(GetITSgeom());
277     }else if(idet==1){
278         seg = new AliITSsegmentationSDD(GetITSgeom());
279     }else {
280         seg = new AliITSsegmentationSSD(GetITSgeom());
281     }
282     SetSegmentationModel(idet,seg);
283 }
284 //______________________________________________________________________
285 void AliITSDetTypeSim::SetSegmentationModel(Int_t dettype,
286                                             AliITSsegmentation *seg){
287    
288   //Set segmentation model for detector type
289   if(fSegmentation==0x0){
290     fSegmentation = new TObjArray(fgkNdettypes);
291     fSegmentation->SetOwner(kTRUE);
292   }
293   fSegmentation->AddAt(seg,dettype);
294 }
295 //______________________________________________________________________
296 AliITSsegmentation* AliITSDetTypeSim::GetSegmentationModel(Int_t dettype){
297   //Get segmentation model for detector type
298    
299    if(fSegmentation==0) {
300        Warning("GetSegmentationModel","fSegmentation is 0!");
301        return 0; 
302    } 
303    return (AliITSsegmentation*)(fSegmentation->At(dettype));
304 }
305 //_______________________________________________________________________
306 AliITSsegmentation* AliITSDetTypeSim::GetSegmentationModelByModule(Int_t module){
307     //Get segmentation model by module number
308     if(GetITSgeom()==0){
309         Warning("GetSegmentationModelByModule","GetITSgeom() is 0!");
310         return 0;
311     }     
312     return GetSegmentationModel(GetITSgeom()->GetModuleType(module));
313 }
314 //_______________________________________________________________________
315 void AliITSDetTypeSim::CreateCalibrationArray() {
316     //Create the container of calibration functions with correct size
317     if (fCalibration) {
318         Warning("CreateCalibration","pointer to calibration object exists\n");
319         fCalibration->Delete();
320         delete fCalibration;
321     }
322
323     Int_t nModTot = GetITSgeom()->GetIndexMax();
324     fCalibration = new TObjArray(nModTot);
325     fCalibration->SetOwner(kTRUE);
326     fCalibration->Clear();
327 }
328 //_______________________________________________________________________
329 void AliITSDetTypeSim::SetCalibrationModel(Int_t iMod, AliITSCalibration *resp){
330     //Set response model for modules
331
332     if (fCalibration==0) CreateCalibrationArray();
333  
334     if (fCalibration->At(iMod)!=0)
335         delete (AliITSCalibration*) fCalibration->At(iMod);
336     fCalibration->AddAt(resp, iMod);
337 }
338 //______________________________________________________________________
339 void AliITSDetTypeSim::ResetCalibrationArray(){
340     //resets response array
341     if(fCalibration && fRunNumber<0){  // if fRunNumber<0 fCalibration is owner
342         AliITSresponse* rspd = ((AliITSCalibration*)fCalibration->At(
343                                 GetITSgeom()->GetStartSPD()))->GetResponse();
344         AliITSresponse* rsdd = ((AliITSCalibration*)fCalibration->At(
345                                 GetITSgeom()->GetStartSDD()))->GetResponse();
346         AliITSresponse* rssd = ((AliITSCalibration*)fCalibration->At(
347                                 GetITSgeom()->GetStartSSD()))->GetResponse();
348         if(rspd) delete rspd;
349         if(rsdd) delete rsdd;
350         if(rssd) delete rssd;
351         fCalibration->Clear();
352     }else if (fCalibration && fRunNumber>=0){
353         fCalibration->Clear();
354     }
355 }
356 //______________________________________________________________________
357 void AliITSDetTypeSim::ResetSegmentation(){
358     //Resets segmentation array
359     if(fSegmentation) fSegmentation->Clear();
360 }
361 //_______________________________________________________________________
362 AliITSCalibration* AliITSDetTypeSim::GetCalibrationModel(Int_t iMod){
363     //Get response model for module number iMod 
364  
365     if(fCalibration==0) {
366         AliError("fCalibration is 0!");
367         return 0; 
368     }
369   return (AliITSCalibration*)(fCalibration->At(iMod));
370 }
371 //_______________________________________________________________________
372 void AliITSDetTypeSim::SetDefaults(){
373     //Set defaults for segmentation and response
374
375     if(GetITSgeom()==0){
376         Warning("SetDefaults","GetITSgeom() is 0!");
377         return;
378     } // end if
379     if (fCalibration==0) {
380         CreateCalibrationArray();
381     } // end if
382
383     ResetSegmentation();
384     if(!GetCalibration()){AliFatal("Exit"); exit(0);}
385
386     for(Int_t idet=0;idet<fgkNdettypes;idet++){
387         //SPD
388         if(idet==0){
389             if(!GetSegmentationModel(idet)) SetDefaultSegmentation(idet);
390             const char *kData0=(GetCalibrationModel(GetITSgeom()->GetStartSPD()))->DataType();
391             if (strstr(kData0,"real")) {
392                 SetDigitClassName(idet,"AliITSdigit");
393             }else {
394                 SetDigitClassName(idet,"AliITSdigitSPD");
395             } // end if
396         } // end if idet==0
397         //SDD
398         if(idet==1){
399             if(!GetSegmentationModel(idet)) SetDefaultSegmentation(idet);
400             AliITSCalibrationSDD* rsp = 
401                 (AliITSCalibrationSDD*)GetCalibrationModel(
402                     GetITSgeom()->GetStartSDD());
403             const char *kopt = ((AliITSresponseSDD*)rsp->GetResponse())->
404                 ZeroSuppOption();
405             if((!strstr(kopt,"2D"))&&(!strstr(kopt,"1D"))) {
406                 SetDigitClassName(idet,"AliITSdigit");
407             }else {
408                 SetDigitClassName(idet,"AliITSdigitSDD");
409             } // end if
410         } // end if idet==1
411         //SSD
412         if(idet==2){
413             if(!GetSegmentationModel(idet))SetDefaultSegmentation(idet);
414             const char *kData2 = (GetCalibrationModel(
415                                   GetITSgeom()->GetStartSSD())->DataType());
416             if (strstr(kData2,"real")) {
417                 SetDigitClassName(idet,"AliITSdigit");
418             }else {
419                 SetDigitClassName(idet,"AliITSdigitSSD");
420             } // end if
421         } // end if idet==2
422     }// end for idet
423 }
424 //______________________________________________________________________
425 Bool_t AliITSDetTypeSim::GetCalibration() {
426   // Get Default calibration if a storage is not defined.
427
428   if(!fFirstcall){
429     AliITSCalibration* cal = GetCalibrationModel(0);
430     if(cal)return kTRUE;
431   }
432   else {
433     fFirstcall = kFALSE;
434   }
435
436   SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun());
437   Int_t run=GetRunNumber();
438
439   Bool_t origCacheStatus = AliCDBManager::Instance()->GetCacheFlag();
440   Bool_t isCacheActive = kTRUE;
441   if(GetRunNumber()<0){
442     isCacheActive=kFALSE;
443     fCalibration->SetOwner(kTRUE);
444   }
445   else{
446     fCalibration->SetOwner(kFALSE);
447   }
448
449   AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
450
451   AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead", run);
452   AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD", run);
453   AliCDBEntry *mapASDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsAnodeSDD",run);
454   AliCDBEntry *mapTSDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsTimeSDD",run);
455   // AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD", run);
456   AliCDBEntry *entryNoiseSSD = AliCDBManager::Instance()->Get("ITS/Calib/NoiseSSD");
457   AliCDBEntry *entryGainSSD = AliCDBManager::Instance()->Get("ITS/Calib/GainSSD");
458   AliCDBEntry *entryBadChannelsSSD = AliCDBManager::Instance()->Get("ITS/Calib/BadChannelsSSD");
459
460   AliCDBEntry *entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD", run);
461   AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD", run);
462   AliCDBEntry *entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD", run);
463
464   if(!entrySPD || !entrySDD || !entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD || 
465      !entry2SPD || !entry2SDD || !entry2SSD || !mapASDD ||!mapTSDD){
466     AliFatal("Calibration object retrieval failed! ");
467     return kFALSE;
468   }     
469
470 //   if(!entrySPD || !entrySDD || !entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD || 
471 //      !entry2SPD || !entry2SDD || !entry2SSD){
472 //     AliFatal("Calibration object retrieval failed! ");
473 //     return kFALSE;
474 //   }          
475
476   TObjArray *calSPD = (TObjArray *)entrySPD->GetObject();
477   if(!isCacheActive)entrySPD->SetObject(NULL);
478   entrySPD->SetOwner(kTRUE);
479
480   AliITSresponseSPD *pSPD = (AliITSresponseSPD*)entry2SPD->GetObject();
481   if(!isCacheActive)entry2SPD->SetObject(NULL);
482   entry2SPD->SetOwner(kTRUE);
483    
484   TObjArray *calSDD = (TObjArray *)entrySDD->GetObject();
485   if(!isCacheActive)entrySDD->SetObject(NULL);
486   entrySDD->SetOwner(kTRUE);
487
488   AliITSresponseSDD *pSDD = (AliITSresponseSDD*)entry2SDD->GetObject();
489   if(!isCacheActive)entry2SDD->SetObject(NULL);
490   entry2SDD->SetOwner(kTRUE);
491
492   TObjArray *mapAn = (TObjArray *)mapASDD->GetObject();
493   if(!isCacheActive)mapASDD->SetObject(NULL);
494   mapASDD->SetOwner(kTRUE);
495
496   TObjArray *mapT = (TObjArray *)mapTSDD->GetObject();
497   if(!isCacheActive)mapTSDD->SetObject(NULL);
498   mapTSDD->SetOwner(kTRUE);
499
500   /*
501   TObjArray *calSSD = (TObjArray *)entrySSD->GetObject();
502   if(!isCacheActive)entrySSD->SetObject(NULL);
503   entrySSD->SetOwner(kTRUE);
504   */
505
506   TObjArray *noiseSSD = (TObjArray *)entryNoiseSSD->GetObject();
507   if(!isCacheActive)entryNoiseSSD->SetObject(NULL);
508   entryNoiseSSD->SetOwner(kTRUE);
509
510   TObjArray *gainSSD = (TObjArray *)entryGainSSD->GetObject();
511   if(!isCacheActive)entryGainSSD->SetObject(NULL);
512   entryGainSSD->SetOwner(kTRUE);
513
514   TObjArray *badchannelsSSD = (TObjArray *)entryBadChannelsSSD->GetObject();
515   if(!isCacheActive)entryBadChannelsSSD->SetObject(NULL);
516   entryBadChannelsSSD->SetOwner(kTRUE);
517
518   AliITSresponseSSD *pSSD = (AliITSresponseSSD*)entry2SSD->GetObject();
519   if(!isCacheActive)entry2SSD->SetObject(NULL);
520   entry2SSD->SetOwner(kTRUE);
521   
522   // DB entries are deleted. In this way metadeta objects are deleted as well
523   if(!isCacheActive){
524     delete entrySPD;
525     delete entrySDD;
526     delete entryNoiseSSD;
527     delete entryGainSSD;
528     delete entryBadChannelsSSD;
529     delete entry2SPD;
530     delete entry2SDD;
531     delete entry2SSD;
532     delete mapASDD;   
533     delete mapTSDD;
534   }
535   
536   AliCDBManager::Instance()->SetCacheFlag(origCacheStatus);
537
538   if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!calSDD) 
539       || (!mapAn) || (!mapT) || (!noiseSSD)|| (!gainSSD)|| (!badchannelsSSD)) {
540     AliWarning("Can not get calibration from calibration database !");
541     return kFALSE;
542   }
543
544   fNMod[0] = calSPD->GetEntries();
545   fNMod[1] = calSDD->GetEntries();
546   fNMod[2] = noiseSSD->GetEntries();
547   AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
548                fNMod[0], fNMod[1], fNMod[2]));
549   AliITSCalibration* cal;
550   for (Int_t i=0; i<fNMod[0]; i++) {
551     cal = (AliITSCalibration*) calSPD->At(i);
552     cal->SetResponse(pSPD);
553     SetCalibrationModel(i, cal);
554  }
555   Int_t nn1=0;
556   Int_t nn2=0;
557   for (Int_t i=0; i<fNMod[1]; i++) {
558     cal = (AliITSCalibration*) calSDD->At(i);
559     cal->SetResponse(pSDD);
560     AliITSMapSDD* m1 = (AliITSMapSDD*)mapAn->At(nn1);nn1++;
561     AliITSMapSDD* m2 = (AliITSMapSDD*)mapAn->At(nn1);nn1++;
562     AliITSMapSDD* m3 = (AliITSMapSDD*)mapT->At(nn2);nn2++;
563     AliITSMapSDD* m4 = (AliITSMapSDD*)mapT->At(nn2);nn2++; 
564     cal->SetMapA(0,m1);
565     cal->SetMapA(1,m2);
566     cal->SetMapT(0,m3);
567     cal->SetMapT(1,m4);
568     Int_t iMod = i + fNMod[0];
569     SetCalibrationModel(iMod, cal);
570  }
571   for (Int_t i=0; i<fNMod[2]; i++) {
572     AliITSCalibrationSSD *calibSSD = new AliITSCalibrationSSD();
573     calibSSD->SetResponse((AliITSresponse*)pSSD);
574     
575     AliITSNoiseSSD *noise = (AliITSNoiseSSD*) (noiseSSD->At(i));
576     calibSSD->SetNoise(noise);
577     AliITSGainSSD *gain = (AliITSGainSSD*) (gainSSD->At(i));
578     calibSSD->SetGain(gain);
579     AliITSBadChannelsSSD *bad = (AliITSBadChannelsSSD*) (badchannelsSSD->At(i));
580     calibSSD->SetBadChannels(bad);
581
582     Int_t iMod = i + fNMod[0] + fNMod[1];
583     SetCalibrationModel(iMod, calibSSD);
584
585  }
586   return kTRUE;
587 }
588 //_______________________________________________________________________
589 void AliITSDetTypeSim::SetDefaultSimulation(){
590   //Set default simulation for detector type
591
592   if(GetITSgeom()==0){
593     Warning("SetDefaultSimulation","GetITSgeom() is 0!");
594     return;
595   }
596   if(fCalibration==0){
597     Warning("SetDefaultSimulation","fCalibration is 0!");
598     return;
599   }
600   if(fSegmentation==0){
601     Warning("SetDefaultSimulation","fSegmentation is 0!");
602     for(Int_t i=0;i<fgkNdettypes;i++) SetDefaultSegmentation(i);
603   }else for(Int_t i=0;i<fgkNdettypes;i++) if(!GetSegmentationModel(i)){
604       Warning("SetDefaultSimulation",
605               "Segmentation not defined for det %d - Default taken\n!",i);
606       SetDefaultSegmentation(i);
607   }
608   AliITSsimulation* sim;
609
610   for(Int_t idet=0;idet<fgkNdettypes;idet++){
611    //SPD
612     if(idet==0){
613       sim = GetSimulationModel(idet); 
614       if(!sim){
615         sim = new AliITSsimulationSPD(this);
616         SetSimulationModel(idet,sim);
617       }
618     }
619     //SDD
620     if(idet==1){
621       sim = GetSimulationModel(idet);
622       if(!sim){
623         sim = new AliITSsimulationSDD(this);
624         SetSimulationModel(idet,sim);
625       }      
626     }
627     //SSD
628     if(idet==2){
629       sim = GetSimulationModel(idet);
630       if(!sim){
631         sim = new AliITSsimulationSSD(this);
632         SetSimulationModel(idet,sim);
633       }
634     }
635
636   }
637 }
638 //___________________________________________________________________
639 void AliITSDetTypeSim::SetTreeAddressS(TTree* treeS, Char_t* name){
640   // Set branch address for the ITS summable digits Trees.  
641   char branchname[30];
642
643   if(!treeS){
644     return;
645   }
646   if (fSDigits ==  0x0){
647     fSDigits = new TClonesArray("AliITSpListItem",1000);
648   }
649   TBranch *branch;
650   sprintf(branchname,"%s",name);
651   branch = treeS->GetBranch(branchname);
652   if (branch) branch->SetAddress(&fSDigits);
653
654 }
655 //___________________________________________________________________
656 void AliITSDetTypeSim::SetTreeAddressD(TTree* treeD, Char_t* name){
657   // Set branch address for the digit Trees.
658   
659   const char *det[3] = {"SPD","SDD","SSD"};
660   TBranch *branch;
661   
662   char branchname[30];
663   
664   if(!treeD){
665     return;
666   }
667   if(!fDigits){
668     fDigits = new TObjArray(fgkNdettypes); 
669   }
670   for(Int_t i=0;i<fgkNdettypes;i++){
671     Char_t* digclass = GetDigitClassName(i);
672     if(digclass==0x0){
673       if(i==0) SetDigitClassName(i,"AliITSdigitSPD");
674       if(i==1) SetDigitClassName(i,"AliITSdigitSDD");
675       if(i==2) SetDigitClassName(i,"AliITSdigitSSD");
676       digclass = GetDigitClassName(i);
677     }
678     TString classn = digclass;
679     if(!(fDigits->At(i))){
680       fDigits->AddAt(new TClonesArray(classn.Data(),1000),i);
681     }else{
682       ResetDigits(i);
683     }
684     
685     if(fgkNdettypes==3) sprintf(branchname,"%sDigits%s",name,det[i]);
686     else sprintf(branchname,"%sDigits%d",name,i+1);
687     if(fDigits){
688       branch = treeD->GetBranch(branchname);
689       if(branch) branch->SetAddress(&((*fDigits)[i]));
690     }
691   }
692
693 }
694 //___________________________________________________________________
695 void AliITSDetTypeSim::ResetDigits(){
696   // Reset number of digits and the digits array for the ITS detector.  
697
698   if(!fDigits){
699     Error("ResetDigits","fDigits is null!");
700     return;
701   }
702   for(Int_t i=0;i<fgkNdettypes;i++){
703     ResetDigits(i);
704   }
705 }
706 //___________________________________________________________________
707 void AliITSDetTypeSim::ResetDigits(Int_t branch){
708   // Reset number of digits and the digits array for this branch.
709
710   if(fDigits->At(branch)){
711     ((TClonesArray*)fDigits->At(branch))->Clear();
712   }
713   if(fNDigits) fNDigits[branch]=0;
714
715 }
716
717
718
719 //_______________________________________________________________________
720 void AliITSDetTypeSim::SDigitsToDigits(Option_t* opt, Char_t* name){
721   // Standard Summable digits to Digits function.
722   if(!GetITSgeom()){
723     Warning("SDigitsToDigits","GetITSgeom() is null!!");
724     return;
725   }
726   
727   const char *all = strstr(opt,"All");
728   const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
729                         strstr(opt,"SSD")};
730   if( !det[0] && !det[1] && !det[2] ) all = "All";
731   else all = 0;
732   static Bool_t setDef = kTRUE;
733   if(setDef) SetDefaultSimulation();
734   setDef = kFALSE;
735   
736   AliITSsimulation *sim =0;
737   TTree* trees = fLoader->TreeS();
738   if( !(trees && GetSDigits()) ){
739     Error("SDigits2Digits","Error: No trees or SDigits. Returning.");
740     return;
741   } 
742   sprintf(name,"%s",name);
743   TBranch* brchSDigits = trees->GetBranch(name);
744   
745   Int_t id;
746   for(Int_t module=0;module<GetITSgeom()->GetIndexMax();module++){
747      id = GetITSgeom()->GetModuleType(module);
748     if (!all && !det[id]) continue;
749     sim = (AliITSsimulation*)GetSimulationModel(id);
750     if(!sim){
751       Error("SDigit2Digits","The simulation class was not "
752             "instanciated for module %d type %s!",module,
753             GetITSgeom()->GetModuleTypeName(module));
754       exit(1);
755     }
756     sim->InitSimulationModule(module,gAlice->GetEvNumber());
757     
758     fSDigits->Clear();
759     brchSDigits->GetEvent(module);
760     sim->AddSDigitsToModule(fSDigits,0);
761     sim->FinishSDigitiseModule();
762     fLoader->TreeD()->Fill();
763     ResetDigits();
764   }
765   fLoader->TreeD()->GetEntries();
766   fLoader->TreeD()->AutoSave();
767   fLoader->TreeD()->Reset();
768 }
769 //_________________________________________________________
770 void AliITSDetTypeSim::AddSumDigit(AliITSpListItem &sdig){  
771   //Adds the module full of summable digits to the summable digits tree.
772
773   TClonesArray &lsdig = *fSDigits;
774   new(lsdig[fNSDigits++]) AliITSpListItem(sdig);
775 }
776 //__________________________________________________________
777 void AliITSDetTypeSim::AddRealDigit(Int_t branch, Int_t *digits){
778   //   Add a real digit - as coming from data.
779
780   TClonesArray &ldigits = *((TClonesArray*)fDigits->At(branch));
781   new(ldigits[fNDigits[branch]++]) AliITSdigit(digits); 
782 }
783 //__________________________________________________________
784 void AliITSDetTypeSim::AddSimDigit(Int_t branch, AliITSdigit* d){  
785   //    Add a simulated digit.
786
787   TClonesArray &ldigits = *((TClonesArray*)fDigits->At(branch));
788   switch(branch){
789   case 0:
790     new(ldigits[fNDigits[branch]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
791     break;
792   case 1:
793     new(ldigits[fNDigits[branch]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
794     break;
795   case 2:
796     new(ldigits[fNDigits[branch]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
797     break;
798   }  
799 }
800 //______________________________________________________________________
801 void AliITSDetTypeSim::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,
802                                    Int_t *tracks,Int_t *hits,Float_t *charges){
803   //   Add a simulated digit to the list.
804
805   TClonesArray &ldigits = *((TClonesArray*)fDigits->At(branch));
806   AliITSCalibrationSDD *resp = 0;
807   switch(branch){
808   case 0:
809     new(ldigits[fNDigits[branch]++]) AliITSdigitSPD(digits,tracks,hits);
810     break;
811   case 1:
812     resp = (AliITSCalibrationSDD*)GetCalibrationModel(
813         GetITSgeom()->GetStartSDD());
814     new(ldigits[fNDigits[branch]++]) AliITSdigitSDD(phys,digits,tracks,
815                                                    hits,charges,resp);
816     break;
817   case 2:
818     new(ldigits[fNDigits[branch]++]) AliITSdigitSSD(digits,tracks,hits);
819     break;
820   } 
821 }
822 //______________________________________________________________________
823 void AliITSDetTypeSim::StoreCalibration(Int_t firstRun, Int_t lastRun,
824                                         AliCDBMetaData &md) {
825   // Store calibration in the calibration database
826   // The database must be created in an external piece of code (i.e. 
827   // a configuration macro )
828
829   if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
830     AliWarning("No storage set! Will use dummy one");
831     AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
832   }
833
834   if (!fCalibration) {
835     AliError("AliITSCalibration classes are not defined - nothing done");
836     return;
837   }
838   AliCDBId idRespSPD("ITS/Calib/SPDDead",firstRun, lastRun);
839   AliCDBId idRespSDD("ITS/Calib/CalibSDD",firstRun, lastRun);
840   AliCDBId idRespSSD("ITS/Calib/CalibSSD",firstRun, lastRun);
841
842   TObjArray respSPD(fNMod[0]);
843   TObjArray respSDD(fNMod[1]-fNMod[0]);
844   TObjArray respSSD(fNMod[2]-fNMod[1]);
845   respSPD.SetOwner(kFALSE);
846   respSSD.SetOwner(kFALSE);
847   respSSD.SetOwner(kFALSE);
848
849   Int_t index[fgkNdettypes];
850   for (Int_t i = 0; i<fgkNdettypes; i++ ) {
851     index[i] = 0;
852     for (Int_t j = 0; j<=i; j++ )
853       index[i]+=fNMod[j];
854   }
855
856   for (Int_t i = 0; i<index[0]; i++ )
857     respSPD.Add(fCalibration->At(i));
858
859   for (Int_t i = index[0]; i<index[1]; i++ )
860     respSDD.Add(fCalibration->At(i));
861
862   for (Int_t i = index[1]; i<index[2]; i++ )
863     respSSD.Add(fCalibration->At(i));
864
865   AliCDBManager::Instance()->Put(&respSPD, idRespSPD, &md);
866   AliCDBManager::Instance()->Put(&respSDD, idRespSDD, &md);
867   AliCDBManager::Instance()->Put(&respSSD, idRespSSD, &md);
868 }
869
870