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