Removing obsolete class AliITSGeant3Geometry - Test beam simulation classes back...
[u/mrichter/AliRoot.git] / ITS / AliITSvSSD03.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 // Enrico Fragiacomo - 15/03/2004
17 // Geometry for the June 2003 SSD beam test
18
19 #include <TGeometry.h>
20 #include <TNode.h>
21 #include <TLorentzVector.h>
22 #include <TClonesArray.h>
23 #include <TBRIK.h>
24 #include <TVirtualMC.h>
25 #include <TGeoMatrix.h>
26
27 #include "AliRun.h"
28 #include "AliMagF.h"
29 #include "AliTrackReference.h"
30 #include "AliITShit.h"
31 #include "AliITS.h"
32 #include "AliITSvSSD03.h"
33 #include "AliITSgeom.h"
34 #include "AliITSgeomSSD.h"
35 #include "AliITSDetTypeSim.h"
36 #include "AliITSCalibrationSSD.h"
37 #include "AliITSsegmentationSSD.h"
38 #include "AliITSsimulationSSD.h"
39 #include "AliMC.h"
40
41
42 ///////////////////////////////////////////////////////////////////////
43 // Step manager and 
44 // geometry class
45 // for the ITS 
46 // SSD test beam
47 // geometry of June 2003
48 // 
49 ///////////////////////////////////////////////////////////////////////
50 ClassImp(AliITSvSSD03)
51
52 //______________________________________________________________________
53 AliITSvSSD03::AliITSvSSD03() {
54     ////////////////////////////////////////////////////////////////////////
55     // Standard default constructor for the ITS SSD test beam 2003 version 1.
56     // Inputs:
57     //    none.
58     // Outputs:
59     //    none.
60     // Return:
61     //    A default created class.
62     ////////////////////////////////////////////////////////////////////////
63     Int_t i;
64
65     fIdN          = 0;
66     fIdName       = 0;
67     fIdSens       = 0;
68     fEuclidOut    = kFALSE; // Don't write Euclide file
69     fGeomDetOut   = kFALSE; // Don't write .det file
70     fGeomDetIn    = kFALSE; // Don't Read .det file
71     fMajorVersion = IsVersion();
72     fMinorVersion = -1;
73     fGeomNumber   = 2003; // default value
74     for(i=0;i<60;i++) fRead[i] = '\0';
75     for(i=0;i<60;i++) fWrite[i] = '\0';
76     for(i=0;i<60;i++) fEuclidGeomDet[i] = '\0';
77 }
78 //______________________________________________________________________
79 AliITSvSSD03::AliITSvSSD03(const char *title,Int_t gn) : AliITS("ITS", title){
80     ////////////////////////////////////////////////////////////////////////
81     //    Standard constructor for the ITS SSD testbeam 2003 version 1.
82     // Inputs:
83     //    const char *title    title for this ITS geometry.
84     //    Int_t      gn        Geometry version number (year) default 2003.
85     // Outputs:
86     //    none.
87     // Return:
88     //    A standard created class.
89     ////////////////////////////////////////////////////////////////////////
90     Int_t i;
91
92     fGeomNumber = gn;
93
94     fIdN = 1; 
95     fIdName = new TString[fIdN];
96     fIdName[0] = "ITST";
97     fIdSens    = new Int_t[fIdN];
98     for(i=0;i<fIdN;i++) fIdSens[i] = 0;
99
100     fMajorVersion = IsVersion();
101     fMinorVersion = 2;
102     fEuclidOut    = kFALSE; // Don't write Euclide file
103     fGeomDetOut   = kFALSE; // Don't write .det file
104     fGeomDetIn    = kFALSE; // Don't Read .det file
105
106     SetThicknessDet1();
107     SetThicknessDet2();
108     SetThicknessChip1();
109     SetThicknessChip2();                         
110
111     fEuclidGeometry="$ALICE_ROOT/ITS/ITSgeometry_vSSD03.euc";
112     strncpy(fEuclidGeomDet,"$ALICE_ROOT/ITS/ITSgeometry_vSSD03.det",60);
113     strncpy(fRead,fEuclidGeomDet,60);
114     strncpy(fWrite,fEuclidGeomDet,60);
115 }
116 //______________________________________________________________________
117 AliITSvSSD03::AliITSvSSD03(const AliITSvSSD03 &source) : AliITS(source){
118     ////////////////////////////////////////////////////////////////////////
119     //     Copy Constructor for ITS SSD test beam 2003 version 1.
120     // This class is not to be copied. Function only dummy.
121     // Inputs:
122     //    const AliITSvSSD03 &source   The class to be copied
123     // Outputs:
124     //    none.
125     // Return:
126     //    A warning message.
127     ////////////////////////////////////////////////////////////////////////
128     if(&source == this) return;
129     Warning("Copy Constructor","Not allowed to copy AliITSvSSD03");
130     return;
131 }
132 //______________________________________________________________________
133 AliITSvSSD03& AliITSvSSD03::operator=(const AliITSvSSD03 &source){
134     ////////////////////////////////////////////////////////////////////////
135     //    Assignment operator for the ITS SSD test beam 2003 version 1.
136     // This class is not to be copied. Function only dummy.
137     // Inputs:
138     //    const AliITSvSSD03 &source   The class to be copied
139     // Outputs:
140     //    none.
141     // Return:
142     //    A Warning message
143     ////////////////////////////////////////////////////////////////////////
144     if(&source == this) return *this;
145     Warning("= operator","Not allowed to copy AliITSvSSD03");
146     return *this;
147 }
148 //______________________________________________________________________
149 AliITSvSSD03::~AliITSvSSD03() {
150     ////////////////////////////////////////////////////////////////////////
151     //    Standard destructor for the ITS SSD test beam 2003 version 1.
152     // Inputs:
153     //    none.
154     // Outputs:
155     //    none.
156     // Return:
157     //    none.
158     ////////////////////////////////////////////////////////////////////////
159 }
160 //______________________________________________________________________
161 void AliITSvSSD03::BuildGeometry(){
162     ////////////////////////////////////////////////////////////////////////
163     //    Geometry builder for the ITS SSD test beam 2003 version 1.
164     //    ALIC    ALICE Mother Volume
165     //     |- ITSV     ITS Mother Volume
166     //         |- ITST       Detector under Test
167     //
168     // Inputs:
169     //    none.
170     // Outputs:
171     //    none.
172     // Return:
173     //    none.
174     ////////////////////////////////////////////////////////////////////////
175     // Get the top alice volume.
176
177     switch (fGeomNumber){
178     case 2003:
179         BuildGeometry2003();
180         break;
181     default:
182         BuildGeometry2003();
183         break;
184     } // end switch
185 }
186 //______________________________________________________________________
187 void AliITSvSSD03::BuildGeometry2003(){
188     ////////////////////////////////////////////////////////////////////////
189     //    Geometry builder for the ITS SSD test beam 2003 version 1.
190     //    ALIC    ALICE Mother Volume
191     //     |- ITSV     ITS Mother Volume
192     //         |- ITST       Detector under Test
193     // Inputs:
194     //    none.
195     // Outputs:
196     //    none.
197     // Return:
198     //    none.
199     ////////////////////////////////////////////////////////////////////////
200
201     // Get the top alice volume.
202     TNode *aALIC = gAlice->GetGeometry()->GetNode("alice");
203     aALIC->cd();
204
205     // Define ITS Mother Volume
206     Float_t data[3];
207     Float_t ddettest=300.0E-4;
208     //Float_t yposition= 0.0;
209     TRotMatrix *r0 = new TRotMatrix("ITSidrotm0","ITSidrotm0",
210                                     90.0,0,0.0,0,90.0,270.0);
211
212     // Mother volume (beam along z)
213     data[0] = 10.0;   // in centimeter
214     data[1] = 50.0;
215     data[2] = 100.0;
216     TBRIK *iITSVshape = new TBRIK("ITSVshape",
217                                   "ITS Logical Mother Volume","Air",
218                                   data[0],data[1],data[2]);
219     TNode *iITSV = new TNode("ITSV","ITS Mother Volume",iITSVshape,
220                             0.0,0.0,0.0,0,0);
221     iITSV->cd(); // set ourselve into ITSV subvolume of aALIC
222
223     // SSD part of telescope  (Note. strips in local xz plan)
224     data[0] = 3.5;   // half-length of the SSD module
225     data[1] = 0.5*ddettest;    // half-width of the SSD module 
226     data[2] = 2.0;   // half-heigth of the SSD module
227     TBRIK *iITSTshape = new TBRIK("ITSTshape","SSD sensitive volume","Si",
228                                  data[0],data[1],data[2]);
229     TNode *iITST = new TNode("ITST","SSD sensitive volume",iITSTshape,
230                             0.0,0.0,0.0,r0,0);
231
232     aALIC->cd();
233     iITST->SetLineColor(kYellow);
234     fNodes->Add(iITST);
235 }
236 //______________________________________________________________________
237 void AliITSvSSD03::CreateGeometry(){
238     ////////////////////////////////////////////////////////////////////////
239     //   Geometry builder for the ITS SSD test beam 2003 version 1.
240     //    ALIC    ALICE Mother Volume
241     //     |- ITSV     ITS Mother Volume
242     //         |- IDET       Detector under Test
243     // Inputs:
244     //    none.
245     // Outputs:
246     //    none.
247     // Return:
248     //    none.
249     ////////////////////////////////////////////////////////////////////////
250
251     switch (fGeomNumber){
252     case 2003:
253         CreateGeometry2003();
254         break;
255     default:
256         CreateGeometry2003();
257         break;
258     } // end switch
259 }
260 //______________________________________________________________________
261 void AliITSvSSD03::CreateGeometry2003(){
262   ////////////////////////////////////////////////////////////////////////
263   //
264   //    ALIC    ALICE Mother Volume
265   //     |- ITSV     Beamtest Mother Volume
266   //         |
267   //         |- ITSA       Aluminum cover for scintillator
268   //         |    |-ITSS    first Trieste trigger plastic scintillator 
269   //         |- ITSA       Aluminum cover for scintillator
270   //         |    |-ITSS    second Trieste's trigger plastic scintillator
271   //         |
272   //         |- IGAR       Black box around ITST       
273   //         |    |-IAIR    Air inside the black box
274   //         |        |-ITST    Detector under Test 
275   //         |
276   //         |- IFRA       Aluminum cover for scintillator
277   //         |    |-IFRS    French plastic scintillator 
278   //         |
279   //         |- ITSA       Aluminum cover for scintillator
280   //         |    |-ITSS    third Trieste's plastic scintillator
281   // Inputs:
282   //    none.
283   // Outputs:
284   //    none.
285   // Return:
286   //    none.
287   ////////////////////////////////////////////////////////////////////////
288   
289   Float_t data[49];
290   // Define media off-set
291   Int_t *idtmed = fIdtmed->GetArray()+1; // array of media indexes
292   Int_t idrotm[4]; // Array of rotation matrix indexes
293    //Float_t yposition= 0.0;
294   
295   if(gMC==0) return;
296   // Define Rotation-reflextion Matrixes needed
297   // 0 is the unit matrix
298
299   // Beamtest mother volume (air) positioned in ALIC mother volume
300   data[0] = 500.0;
301   data[1] = 500.0;
302   data[2] = 1000.0;
303   gMC->Gsvolu("ITSV","BOX",idtmed[0],data,3);
304   gMC->Gspos("ITSV",1,"ALIC",0.0,0.0,0.0,0,"ONLY");
305   
306   // Trieste's plastic scintillators for the trigger (2 at beam enter)
307   // ...define them (aluminum cover + scintillator inside)
308   // aluminum cover
309   data[0] = 30.01; // size+2x50 microns Kapton
310   data[1] = 1.01;
311   data[2] = 20.01;
312   //gMC->Gsvolu("ITSA","BOX ",idtmed[3],data,3);// 
313   gMC->Gsvolu("ITSA","BOX ",idtmed[4],data,3);// 
314   data[0] = 30.0;
315   data[1] = 1.0;
316   data[2] = 20.0;
317   // plastic scintillator
318   gMC->Gsvolu("ITSS","BOX ",idtmed[2],data,3);
319   gMC->Gspos("ITSS",1,"ITSA",0.0,0.0,0.0,0,"ONLY"); 
320   // ... and place them inside ITSV
321   AliMatrix(idrotm[0], 90.0,0.0, 0.0,0.0, 90.0,270.0);
322   // first scintillator 
323   gMC->Gspos("ITSA",1,"ITSV",0.0,0.0,-282.0,idrotm[0],"ONLY"); 
324   // second scintillator 
325   gMC->Gspos("ITSA",2,"ITSV",0.0,0.0,-280.0,idrotm[0],"ONLY"); 
326
327   // black kapton box with the SSD sensor inside (width 50 microns)
328   data[0] = 20.0;
329   data[1] = 20.0;
330   data[2] = 20.0;
331   gMC->Gsvolu("IGAR","BOX ",idtmed[4],data,3); //
332   // air in the black kapton box 
333   data[0] = 19.99;
334   data[1] = 19.99;
335   data[2] = 19.99;
336   gMC->Gsvolu("IAIR","BOX ",idtmed[0],data,3); //
337   // SSD sensor 
338   Float_t ddettest=300.0E-4;
339   data[0] = 3.5;
340   data[1] = 0.5*ddettest;
341   data[2] = 2.0;
342   gMC->Gsvolu("ITST","BOX ",idtmed[1],data,3);// sensitive detector volume
343   // place ITST inside IAIR (no rotation: it will be rotated with IGAR)
344   gMC->Gspos("ITST",1,"IAIR",0.0,0.0,0.0,0,"ONLY"); 
345   // place IAIR inside IGAR
346   gMC->Gspos("IAIR",1,"IGAR",0.0,0.0,0.0,0,"ONLY"); 
347   // place IGAR inside ITSV
348   AliMatrix(idrotm[0], 90.0,0.0, 0.0,0.0, 90.0,270.0);
349   gMC->Gspos("IGAR",1,"ITSV",0.0,0.0,0.0,idrotm[0],"ONLY"); 
350   //gMC->Gspos("IGAR",1,"ITSV",0.0,0.0,0.0,0,"ONLY"); 
351  
352   // The so called French detector 
353   // ...define it (Kapton cover + scintillator inside)
354   // Kapton cover
355   data[0] = 2.01; // size+2x50 microns Kapton width
356   data[1] = 1.01;
357   data[2] = 1.01;
358   gMC->Gsvolu("IFRA","BOX ",idtmed[4],data,3);// 
359   data[0] = 2.0;
360   data[1] = 1.0;
361   data[2] = 1.0;
362   // plastic scintillator
363   gMC->Gsvolu("IFRS","BOX ",idtmed[2],data,3);
364   gMC->Gspos("IFRS",1,"IFRA",0.0,0.0,0.0,0,"ONLY"); 
365   // ... and place it inside ITSV
366   AliMatrix(idrotm[0], 90.0,0.0, 0.0,0.0, 90.0,270.0); 
367   gMC->Gspos("IFRA",1,"ITSV",0.0,0.0,16.0,idrotm[0],"ONLY"); 
368
369   // An other Trieste's plastic scintillator for the trigger 
370   // ...just place an other copy inside ITSV
371   AliMatrix(idrotm[0], 90.0,0.0, 0.0,0.0, 90.0,270.0);
372   gMC->Gspos("ITSA",3,"ITSV",0.0,0.0,270.0,idrotm[0],"ONLY"); 
373  
374 }
375
376 //______________________________________________________________________
377 void AliITSvSSD03::CreateMaterials(){
378     ////////////////////////////////////////////////////////////////////////
379     //
380     // Create ITS SSD test beam materials
381     //     This function defines the default materials used in the Geant
382     // Monte Carlo simulations for the geometries AliITSv1, AliITSv3,
383     // AliITSvSSD03.
384     // In general it is automatically replaced by
385     // the CreateMaterials routine defined in AliITSv?. Should the function
386     // CreateMaterials not exist for the geometry version you are using this
387     // one is used. See the definition found in AliITSv5 or the other routine
388     // for a complete definition.
389     //
390     // Inputs:
391     //    none.
392     // Outputs:
393     //    none.
394     // Return:
395     //    none.
396     /////////////////////////////////////////////////////////////////////////
397
398     switch (fGeomNumber){
399     case 2003:
400         CreateMaterials2003();
401         break;
402     default:
403         CreateMaterials2003();
404         break;
405     } // end switch
406 }
407 //______________________________________________________________________
408 void AliITSvSSD03::CreateMaterials2003(){
409     ////////////////////////////////////////////////////////////////////////
410     //
411     // Create ITS SSD test beam materials
412     //     This function defines the default materials used in the Geant
413     // Monte Carlo simulations for the geometries AliITSv1, AliITSv3,
414     // AliITSvSSD03.
415     // In general it is automatically replaced by
416     // the CreateMaterials routine defined in AliITSv?. Should the function
417     // CreateMaterials not exist for the geometry version you are using this
418     // one is used. See the definition found in AliITSv5 or the other routine
419     // for a complete definition.
420     //
421     // Inputs:
422     //    none.
423     // Outputs:
424     //    none.
425     // Return:
426     //    none.
427     /////////////////////////////////////////////////////////////////////////
428
429     Int_t   ifield = gAlice->Field()->Integ();
430     Float_t fieldm = gAlice->Field()->Max();   
431
432     // Scintillator CH
433     Float_t ascin[2]={1.01,12.01};
434     Float_t zscin[2]={1,6};
435     Float_t wscin[2]={1,1};
436     Float_t denscin=1.03;
437     AliMixture( 3, "Scintillator$",ascin,zscin,denscin,-2,wscin);
438     AliMedium(3, "Scintillator$", 3, 1, ifield, fieldm, 0.1, .01, 
439               0.1, .0001, 0.0);
440     
441     // Aluminum
442     Float_t tmaxfdAl = 0.1; // Degree
443     Float_t stemaxAl = 0.01; // cm
444     Float_t deemaxAl = 0.1; // Fraction of particle's energy 0<deemax<=1
445     Float_t epsilAl  = 1.0E-4;//
446     Float_t stminAl  = 0.0; // cm "Default value used"
447     AliMaterial(4,  "Al$", 26.98, 13., 2.7, 8.9, 37.2);
448     AliMedium(4,  "Al$",  4, 0, ifield, fieldm, tmaxfdAl, stemaxAl, 
449               deemaxAl, epsilAl, stminAl);
450
451     // Air
452     Float_t tmaxfdAir = 0.1; // Degree
453     Float_t stemaxAir = .10000E+01; // cm
454     Float_t deemaxAir = 0.1; // Fraction of particle's energy 0<deemax<=1
455     Float_t epsilAir  = 1.0E-4;//
456     Float_t stminAir  = 0.0; // cm "Default value used"
457     AliMaterial(1,"AIR$",0.14610E+03,0.73000E+01,0.12050E-03,
458                 0.30423E+05,0.99900E+03);
459     AliMedium(1,"AIR$",1,0,ifield,fieldm,tmaxfdAir,stemaxAir,deemaxAir,
460               epsilAir,stminAir);
461     
462     // Silicon
463     Float_t tmaxfdSi = 0.1; // Degree
464     //Float_t stemaxSi = 0.0075; // cm
465     //Float_t deemaxSi = 0.1; // Fraction of particle's energy 0<deemax<=1
466     //Float_t stminSi  = 0.0; // cm "Default value used"
467     //Float_t tmaxfdSi = 10; // Degree
468     Float_t stemaxSi = 0.01; // cm
469     Float_t deemaxSi = 0.1; // Fraction of particle's energy 0<deemax<=1
470     Float_t epsilSi  = 1.0E-4;//
471     //Float_t epsilSi  = 0.003;//
472     Float_t stminSi  = 0.003; // cm "Default value used"
473     AliMaterial(2,"SSD SI$",0.28086E+02,0.14000E+02,0.23300E+01,
474                 0.93600E+01,0.99900E+03);
475     AliMedium(2,"SSD SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
476               epsilSi,stminSi);
477
478     // Kapton
479     AliMaterial(5, "Kapton$", 12.011, 6., 1.3, 31.27, 999.);
480     AliMedium(5, "Kapton$",    5, 0,ifield,fieldm, 10., .01, .1, .003, .003);
481 }
482 //______________________________________________________________________
483 void AliITSvSSD03::InitAliITSgeom(){
484   // sturture.
485   // Inputs:
486   //    none.
487   // Outputs:
488   //    none.
489   // Return:
490   //    none.
491     const Int_t knlayers=1;
492     const TString kname="ALIC_1/ITSV_1/IGAR_1/IAIR_1/ITST_1";
493     const Int_t knlad[knlayers]={knlayers*1},kndet[knlayers]={knlayers*1};
494     Int_t npar;
495     Float_t par[20];
496     Double_t trans[3]={3*0.0},rot[10]={10*0.0};
497     TGeoHMatrix materix;
498
499     AliITSgeom* geom = new AliITSgeom(0,knlayers,knlad,kndet,1);
500     SetITSgeom(geom);
501     npar=3;par[0]=3.5;par[1]=0.5*300.0E-4;par[2]=2.0;
502     geom->ReSetShape(kSSD,new AliITSgeomSSD275and75(npar,par));
503     gMC->GetTransformation(kname.Data(),materix);
504     geom->CreateMatrix(0,1,1,1,kSSD,trans,rot);
505     geom->SetTrans(0,materix.GetTranslation());
506     geom->SetRotMatrix(0,materix.GetRotationMatrix());
507     geom->GetGeomMatrix(0)->SetPath(kname.Data());
508     return;
509 }
510 //______________________________________________________________________
511 void AliITSvSSD03::Init(){
512     ////////////////////////////////////////////////////////////////////////
513     //     Initialise the ITS after it has been created.
514     // Inputs:
515     //    none.
516     // Outputs:
517     //    none.
518     // Return:
519     //    none.
520     ////////////////////////////////////////////////////////////////////////
521     Int_t i;
522
523     cout << endl;
524     for(i=0;i<26;i++) cout << "*";
525     cout << " ITSvSSD03" << fMinorVersion << "_Init ";
526     for(i=0;i<25;i++) cout << "*";cout << endl;
527 //
528     if(fRead[0]=='\0') strncpy(fRead,fEuclidGeomDet,60);
529     if(fWrite[0]=='\0') strncpy(fWrite,fEuclidGeomDet,60);
530     if(GetITSgeom()!=0) SetITSgeom(0x0);
531     AliITSgeom* geom = new AliITSgeom();
532     SetITSgeom(geom);
533     if(fGeomDetIn) GetITSgeom()->ReadNewFile(fRead);
534     if(!fGeomDetIn) this->InitAliITSgeom();
535     if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
536     AliITS::Init();
537 //
538     for(i=0;i<72;i++) cout << "*";
539     cout << endl;
540     if(gMC) fIDMother = gMC->VolId("ITSV"); // ITS Mother Volume ID.
541     else fIDMother = 0;
542 }
543 //______________________________________________________________________
544 void AliITSvSSD03::SetDefaults(){
545     // sets the default segmentation, rerponse, digit and raw cluster classes
546     // Inputs:
547     //    none.
548     // Outputs:
549     //    none.
550     // Return:
551     //    none.
552     const Float_t kconv = 1.0e+04; // convert cm to microns
553
554     Info("SetDefaults","Setting up only SSD detector");
555
556     if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
557     fDetTypeSim->SetITSgeom(GetITSgeom());
558     AliITSgeomSSD  *s0;
559     fDetTypeSim->ResetCalibrationArray();
560     fDetTypeSim->ResetSegmentation();
561  
562     //SSD
563
564     // Get shape info. Do it this way for now.
565     s0 = (AliITSgeomSSD*) GetITSgeom()->GetShape(kSSD);
566     AliITSCalibration *resp0=new AliITSCalibrationSSD("simulated");
567     SetCalibrationModel(GetITSgeom()->GetStartSSD(),resp0);     
568
569     AliITSsegmentationSSD *seg0=new AliITSsegmentationSSD();
570     seg0->SetDetSize(s0->GetDx()*2.*kconv, // base this on AliITSgeomSSD
571                      s0->GetDz()*2.*kconv, // for now.
572                      s0->GetDy()*2.*kconv); // x,z,y full width in microns.
573     //seg0->SetNPads(256,160);// Number of Bins in x and z
574
575     SetSegmentationModel(kSSD,seg0);
576
577     // set digit and raw cluster classes to be used
578     const char *kData0=(fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSSD()))->DataType();
579     if (strstr(kData0,"real")) fDetTypeSim->SetDigitClassName(kSSD,"AliITSdigit");
580     else fDetTypeSim->SetDigitClassName(kSSD,"AliITSdigitSSD");
581 //    SetSimulationModel(kSSD,new AliITSsimulationSSD(seg0,resp0));
582 //    iDetType->ReconstructionModel(new AliITSClusterFinderSSD());
583
584 /*
585     SetResponseModel(kSPD,new AliITSCalibrationSPD());
586     SetSegmentationModel(kSPD,new AliITSsegmentationSPD());
587     fDetTypeSim->SetDigitClassName(kSPD,"AliITSdigitSPD");
588
589     SetResponseModel(kSDD,new AliITSCalibrationSDD());
590     SetSegmentationModel(kSDD,new AliITSsegmentationSDD());
591     fDetTypeSim->SetDigitClassName(kSDD,"AliITSdigitSDD");
592 */
593
594
595     if(fgkNTYPES>3){
596         Warning("SetDefaults",
597                 "Only the four basic detector types are initialised!");
598     }// end if
599     return;
600 }
601 //______________________________________________________________________
602 void AliITSvSSD03::SetDefaultSimulation(){
603     // sets the default simulation.
604     // Inputs:
605     //      none.
606     // Outputs:
607     //      none.
608     // Return:
609     //      none.
610
611   if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
612
613   AliITSsimulation *sim;
614   //  AliITSsegmentation *seg;
615   // AliITSCalibration *res;
616   /*
617   //SPD
618   if(fDetTypeSim){
619     sim = fDetTypeSim->GetSimulationModel(kSPD);
620     if (!sim) {
621       seg = (AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSPD);
622       res = (AliITSCalibration*)fDetTypeSim->GetResponseModel(nspd);
623       sim = new AliITSsimulationSPDdubna(seg,res,1);
624       SetSimulationModel(kSPD,sim);
625     }else{ // simulation exists, make sure it is set up properly.
626       sim->SetSegmentationModel((AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSPD));
627       sim->SetResponseModel((AliITSCalibration*)fDetTypeSim->GetResponseModel(nspd));
628       ((AliITSsimulation*)sim)->Init();
629       //        if(sim->GetResponseModel()==0) sim->SetResponseModel(
630       //            (AliITSCalibration*)iDetType->GetResponseModel());
631       //        if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
632       //            (AliITSsegmentation*)iDetType->GetSegmentationModel());
633     } // end if
634   } // end if !fDetTypeSim
635
636   //SDD
637   if(fDetTypeSim){
638     sim = fDetTypeSim->GetSimulationModel(kSDD);
639     if (!sim) {
640       seg = (AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSDD);
641       res = (AliITSCalibration*)fDetTypeSim->GetResponseModel(nsdd);
642       sim = new AliITSsimulationSDD(seg,res);
643       SetSimulationModel(kSDD,sim);
644     }else{ // simulation exists, make sure it is set up properly.
645       sim->SetSegmentationModel((AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSDD));
646       sim->SetResponseModel((AliITSCalibration*)fDetTypeSim->GetResponseModel(nsdd));
647
648       ((AliITSsimulation*)sim)->Init();
649       //        if(sim->GetResponseModel()==0) sim->SetResponseModel(
650       //            (AliITSCalibration*)iDetType->GetResponseModel());
651       //        if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
652       //            (AliITSsegmentation*)iDetType->GetSegmentationModel());
653     } //end if
654   } // end if !iDetType
655   */
656   //SSD
657   if(fDetTypeSim){
658     sim = fDetTypeSim->GetSimulationModel(kSSD);
659     if (!sim) {
660       //  seg = (AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSSD);
661       // res = (AliITSCalibration*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSSD());
662       sim = new AliITSsimulationSSD(fDetTypeSim);
663       SetSimulationModel(kSSD,sim);
664     }else{ // simulation exists, make sure it is set up properly.
665       sim->SetSegmentationModel(kSSD,(AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSSD));
666       sim->SetCalibrationModel(GetITSgeom()->GetStartSSD(),(AliITSCalibration*)fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSSD()));
667       ((AliITSsimulation*)sim)->Init();
668       //        if(sim->GetResponseModel()==0) sim->SetResponseModel(
669       //            (AliITSCalibration*)iDetType->GetResponseModel());
670       //        if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
671       //            (AliITSsegmentation*)iDetType->GetSegmentationModel());
672     } // end if
673   } // end if !iDetType
674 }
675
676 //______________________________________________________________________
677 void AliITSvSSD03::DrawModule() const {
678     ////////////////////////////////////////////////////////////////////////
679     //     Draw a shaded view of the ITS SSD test beam version 1.
680     // Inputs:
681     //    none.
682     // Outputs:
683     //    none.
684     // Return:
685     //    none.
686     ////////////////////////////////////////////////////////////////////////
687
688     gMC->Gsatt("*", "seen", -1);
689     gMC->Gsatt("ALIC","SEEN",0);
690     gMC->Gsatt("ITSV","SEEN",0);
691     gMC->Gsatt("ITSA","SEEN",1);
692     gMC->Gsatt("ITSS","SEEN",1);
693     gMC->Gsatt("IGAR","SEEN",1);
694     gMC->Gsatt("IAIR","SEEN",0);
695     gMC->Gsatt("ITST","SEEN",1);
696     gMC->Gsatt("IFRA","SEEN",1);
697     gMC->Gsatt("IFRS","SEEN",1);
698 }
699 //______________________________________________________________________
700 void AliITSvSSD03::StepManager(){
701     ////////////////////////////////////////////////////////////////////////
702     //    Called for every step in the ITS SSD, then calles the 
703     // AliITShit class  creator with the information to be recoreded about
704     //  that hit.
705     //     The value of the macro ALIITSPRINTGEOM if set to 1 will allow the
706     // printing of information to a file which can be used to create a .det
707     // file read in by the routine CreateGeometry(). If set to 0 or any other
708     // value except 1, the default behavior, then no such file is created nor
709     // it the extra variables and the like used in the printing allocated.
710     // Inputs:
711     //    none.
712     // Outputs:
713     //    none.
714     // Return:
715     //    none.
716     ////////////////////////////////////////////////////////////////////////
717     Int_t         copy=0, id;
718     TLorentzVector position, momentum;
719     static TLorentzVector position0;
720     static Int_t stat0=0;
721
722     if((id=gMC->CurrentVolID(copy) == fIDMother)&&
723        (gMC->IsTrackEntering()||gMC->IsTrackExiting())){
724         copy = fTrackReferences->GetEntriesFast();
725         TClonesArray &lTR = *fTrackReferences;
726         // Fill TrackReference structure with this new TrackReference.
727         new(lTR[copy]) AliTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber());
728     } // if Outer ITS mother Volume
729
730     if(!(this->IsActive())){
731         return;
732     } // end if !Active volume.
733
734
735     Int_t   vol[5];
736     TClonesArray &lhits = *fHits;
737     //
738     // Track status
739     vol[3] = 0;
740     vol[4] = 0;
741     if(gMC->IsTrackInside())      vol[3] +=  1;
742     if(gMC->IsTrackEntering())    vol[3] +=  2;
743     if(gMC->IsTrackExiting())     vol[3] +=  4;
744     if(gMC->IsTrackOut())         vol[3] +=  8;
745     if(gMC->IsTrackDisappeared()) vol[3] += 16;
746     if(gMC->IsTrackStop())        vol[3] += 32;
747     if(gMC->IsTrackAlive())       vol[3] += 64;
748     //
749     // Fill hit structure.
750     if(!(gMC->TrackCharge())) return;
751     id = gMC->CurrentVolID(copy);
752     if(id==fIdSens[0]){  // Volume name "ITST"
753         vol[2] = vol[1] = vol[0] = 1; // Det, ladder
754     } else return; // end if
755     //
756     gMC->TrackPosition(position);
757     gMC->TrackMomentum(momentum);
758     vol[4] = stat0;
759     if(gMC->IsTrackEntering()){
760         position0 = position;
761         stat0 = vol[3];
762         return;
763     } // end if IsEntering
764
765     // Fill hit structure with this new hit only for non-entrerance hits.
766     else new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,
767                                         gMC->Edep(),gMC->TrackTime(),position,
768                                         position0,momentum);
769     //cout<<gMC->Edep()<<endl;
770     //
771     position0 = position;
772     stat0 = vol[3];
773
774     return;
775 }
776