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