Strings compared instead of pointers
[u/mrichter/AliRoot.git] / ITS / AliITSvtest.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 $Log$
18 Revision 1.9  2001/05/30 14:04:31  hristov
19 Dynamic cast replaced (F.Carminati)
20
21 Revision 1.8  2001/02/13 16:53:35  nilsen
22 Fixed a but when trying to use GEANT4. Needed to replace
23 if(!((TGeant3*)gMC)) with if(!(dynamic_casst<TGeant3*>(gMC)))
24 because just casting gMC to be TGeant3* even when it realy is a TGeant3 pointer
25 did not result in a zero value. For AliITSv5asymm and AliITSv5symm, needed
26 to fix a bug in the initilizers and a bug in BuildGeometry. This is now done
27 in the same way as in AliITSv5.cxx.
28
29 Revision 1.7  2001/02/09 20:06:26  nilsen
30 Fixed bug in distructor. Can't distroy fixxed length arrays. Thanks Peter.
31
32 Revision 1.6  2001/02/09 00:05:31  nilsen
33 Added fMajor/MinorVersion variables and made other changes to better make
34 use of the new code changes in AliITSgeom related classes.
35
36 Revision 1.5  2001/01/30 09:23:14  hristov
37 Streamers removed (R.Brun)
38
39 Revision 1.4  2001/01/18 06:25:09  barbera
40 ITS geometry using test Euclid files
41
42 Revision 1.1.2.8  2000/10/05 20:28:18  nilsen
43 Now using root generated streamer function.
44
45 Revision 1.1.2.7  2000/07/31 13:51:22  barbera
46 Updated from the release
47
48 Revision 1.2  2000/07/10 16:07:19  fca
49 Release version of ITS code
50
51 Revision 1.1.2.2  2000/03/02 21:53:36  nilsen
52 to make it compatable with the changes in AliRun/AliModule.
53
54 Revision 1.1.2.1  2000/01/12 20:19:03  nilsen
55         The changes made with this latest inclusion of code is very large.
56 Many of the new files were added just in December when P. Cerello added his
57 SDD simulations to the distrobutions. Also added are some file of P. Skowronski
58 for SSD cluster finding and ghost RecPoints. None of this "new" code has been
59 proporly tested. Other code new to this cvs repository is explained in the
60 ITS Off-line web page. In general the changes are too large to give a resonable
61 discription of them but probably should be taken as the starting point for
62 the developement branch (ITS-working).
63     B. S. Nilsen
64
65 Revision 1.13  1999/10/16 19:49:00  BSN
66 $Name$
67 $Author$
68 $Id$
69 */
70
71 ///////////////////////////////////////////////////////////////////////////////
72 //                                                                           //
73 //  Inner Traking System version Test                                        //
74 //  This class contains the base procedures for the Inner Tracking System    //
75 //                                                                           //
76 // Authors: R. Barbera, B. S. Nilsen.                                        //
77 // version  Test                                                             //
78 // Created October 16 1999.                                                  //
79 //                                                                           //
80 ///////////////////////////////////////////////////////////////////////////////
81 #include <stdio.h>
82 #include <stdlib.h>
83 #include <TMath.h>
84 #include <TGeometry.h>
85 #include <TNode.h>
86 #include <TTUBE.h>
87 #include <TFile.h>    // only required for Tracking function?
88 #include <TCanvas.h>
89 #include <TObjArray.h>
90 #include <TObjString.h>
91 #include <TClonesArray.h>
92 #include <TLorentzVector.h>
93 #include <TBRIK.h>
94 #include <TSystem.h>
95
96 #include "AliMC.h"
97 #include "AliRun.h"
98 #include "../TGeant3/TGeant3.h"
99 #include "AliITSGeant3Geometry.h"
100 #include "AliITShit.h"
101 #include "AliITS.h"
102 #include "AliITSvtest.h"
103 #include "AliITSgeom.h"
104 #include "AliITSgeomSPD.h"
105 #include "AliITSgeomSDD.h"
106 #include "AliITSgeomSSD.h"
107
108 ClassImp(AliITSvtest)
109  
110 //_____________________________________________________________________________
111 AliITSvtest::AliITSvtest() {
112     // Standard constructor for the ITS
113     Int_t i;
114
115     fIdN    = 0;
116     fIdName = 0;
117     fIdSens = 0;
118     fEuclidOut    = kFALSE; // Don't write Euclide file
119     fGeomDetOut   = kFALSE; // Don't write .det file
120     fGeomDetIn    = kTRUE; // Read .det file
121     fMajorVersion = IsVersion();
122     fMinorVersion = -1;
123     for(i=0;i<60;i++) fRead[i] = '\0';
124     for(i=0;i<60;i++) fWrite[i] = '\0';
125     for(i=0;i<60;i++) fEuclidGeomDet[i] = '\0';
126 }
127 //____________________________________________________________________________
128 AliITSvtest::AliITSvtest(const AliITSvtest &source){
129 ////////////////////////////////////////////////////////////////////////
130 //     Copy Constructor for ITS test version.
131 ////////////////////////////////////////////////////////////////////////
132     if(&source == this) return;
133     Warning("Copy Constructor","Not allowed to copy AliITSvtest");
134     return;
135 }
136 //_____________________________________________________________________________
137 AliITSvtest& AliITSvtest::operator=(const AliITSvtest &source){
138 ////////////////////////////////////////////////////////////////////////
139 //    Assignment operator for the ITS version 1.
140 ////////////////////////////////////////////////////////////////////////
141         if(&source == this) return *this;
142         Warning("= operator","Not allowed to copy AliITSvtest");
143         return *this;
144 }
145 //_____________________________________________________________________________
146 AliITSvtest::~AliITSvtest() {
147     // Standard destructor for the ITS
148 }
149 //_____________________________________________________________________________
150 AliITSvtest::AliITSvtest(const char *fileeuc,const char *filetme,
151                          const char *name, const char *title) 
152     : AliITS(name, title){
153     //
154     // Standard constructor for the ITS
155     //
156     fIdN    = 6;
157     fIdName    = new TString[fIdN];
158     fIdName[0] = "ITS1";
159     fIdName[1] = "ITS2";
160     fIdName[2] = "ITS3";
161     fIdName[3] = "ITS4";
162     fIdName[4] = "ITS5";
163     fIdName[5] = "ITS6";
164     fIdSens    = new Int_t[fIdN];
165     for (Int_t i=0;i<fIdN;i++) fIdSens[i] = 0;
166     fMajorVersion = IsVersion();
167     fMinorVersion = 1;
168     fEuclidOut    = kFALSE; // Don't write Euclide file
169     fGeomDetOut   = kFALSE; // Don't write .det file
170     fGeomDetIn    = kTRUE; // Read .det file
171
172     fEuclidMaterial = filetme;
173     fEuclidGeometry = fileeuc;
174     strncpy(fEuclidGeomDet,"$ALICE_ROOT/ITS/ITSgeometry_PPR.det",60);
175     strncpy(fRead,fEuclidGeomDet,60);
176     strncpy(fWrite,fEuclidGeomDet,60);
177 //  The .det file for the geometry must have the same name as fileeuc with
178 //  .euc replaced by .det.
179 }
180
181  
182 //_____________________________________________________________________________
183 void AliITSvtest::CreateMaterials(){
184   //
185   // Read materials for the ITS
186   //
187     char *filtmp;
188 //
189   filtmp = gSystem->ExpandPathName(fEuclidMaterial.Data());
190 //  FILE *file = fopen(fEuclidMaterial.Data(),"r");
191   FILE *file = fopen(filtmp,"r");
192   if(file) {
193     fclose(file);
194 //    ReadEuclidMedia(fEuclidMaterial.Data(),this);
195     ReadEuclidMedia(filtmp);
196   } else {
197     Error("CreateMaterials"," THE MEDIA FILE %s DOES NOT EXIST !",
198 //        fEuclidMaterial.Data());
199           filtmp);
200     exit(1);
201   } // end if(file)
202 }
203
204 //_____________________________________________________________________________
205 void AliITSvtest::CreateGeometry(){
206 //////////////////////////////////////////////////////////////////////
207 ////////////////////////////////////////////////////////////////////////
208 // Read geometry for the ITS
209 //
210     char topvol[5];
211     char *filtmp;
212 //
213   filtmp = gSystem->ExpandPathName(fEuclidGeometry.Data());
214   FILE *file = fopen(filtmp,"r");
215   delete [] filtmp;
216   if(file) {
217     fclose(file);
218     printf("Ready to read Euclid geometry file\n");
219     ReadEuclid(fEuclidGeometry.Data(),topvol);
220     printf("Read in euclid geometries\n");
221   } else {
222     Error("CreateGeometry"," THE GEOM FILE %s DOES NOT EXIST !",
223           fEuclidGeometry.Data());
224     exit(1);
225   } // end if(file)
226   //
227   //---Place the ITS ghost volume ITSV in its mother volume (ALIC) and make it
228   //     invisible
229   //
230   gMC->Gspos("ITSV",1,"ALIC",0,0,0,0,"ONLY");
231   //
232   //---Outputs the geometry tree in the EUCLID/CAD format
233   
234     if (fEuclidOut) {
235       gMC->WriteEuclid("ITSgeometry", "ITSV", 1, 5);
236     } // end if (fEuclidOut)
237     cout <<"finished with euclid geometrys"<< endl;
238 }
239 //______________________________________________________________________
240 void AliITSvtest::InitAliITSgeom(){
241 //     Based on the geometry tree defined in Geant 3.21, this
242 // routine initilizes the Class AliITSgeom from the Geant 3.21 ITS geometry
243 // sturture.
244     if(strcmp(gMC->GetName(),"TGeant3")) {
245         Error("InitAliITSgeom",
246                 "Wrong Monte Carlo. InitAliITSgeom uses TGeant3 calls");
247         return;
248     } // end if
249     cout << "Reading Geometry transformation directly from Geant 3." << endl;
250     const Int_t nlayers = 6;
251     const Int_t ndeep = 9;
252     Int_t itsGeomTreeNames[nlayers][ndeep],lnam[20],lnum[20];
253     Int_t nlad[nlayers],ndet[nlayers];
254     Double_t t[3],r[10];
255     Float_t  par[20],att[20];
256     Int_t    npar,natt,idshape,imat,imed;
257     AliITSGeant3Geometry *ig = new AliITSGeant3Geometry();
258     Int_t mod,lay,lad,det,i,j,k;
259     char *names[nlayers][ndeep] = {
260      {"ALIC","ITSV","ITSD","IT12","I12B","I10B","I107","I101","ITS1"}, // lay=1
261      {"ALIC","ITSV","ITSD","IT12","I12B","I20B","I1D7","I1D1","ITS2"}, // lay=2
262      {"ALIC","ITSV","ITSD","IT34","I004","I302","ITS3","    ","    "}, // lay=3
263      {"ALIC","ITSV","ITSD","IT34","I005","I402","ITS4","    ","    "}, // lay=4
264      {"ALIC","ITSV","ITSD","IT56","I565","I562","ITS5","    ","    "}, // lay=5
265      {"ALIC","ITSV","ITSD","IT56","I569","I566","ITS6","    ","    "}};// lay=6
266     Int_t itsGeomTreeCopys[nlayers][ndeep] = {{1,1,1,1,10, 2, 4, 1, 1},// lay=1
267                                               {1,1,1,1,10, 4, 4, 1, 1},// lay=2
268                                               {1,1,1,1,14, 6, 1, 0, 0},// lay=3
269                                               {1,1,1,1,22, 8, 1, 0, 0},// lay=4
270                                               {1,1,1,1,34,22, 1, 0, 0},// lay=5
271                                               {1,1,1,1,38,25, 1, 0, 0}};//lay=6
272
273     // Sorry, but this is not very pritty code. It should be replaced
274     // at some point with a version that can search through the geometry
275     // tree its self.
276     cout << "Reading Geometry informaton from Geant3 common blocks" << endl;
277     for(i=0;i<20;i++) lnam[i] = lnum[i] = 0;
278     for(i=0;i<nlayers;i++)for(j=0;j<ndeep;j++) 
279         itsGeomTreeNames[i][j] = ig->StringToInt(names[i][j]);
280     mod = 0;
281     for(i=0;i<nlayers;i++){
282         k = 1;
283         for(j=0;j<ndeep;j++) if(itsGeomTreeCopys[i][j]!=0)
284             k *= TMath::Abs(itsGeomTreeCopys[i][j]);
285         mod += k;
286     } // end for i
287
288     if(fITSgeom!=0) delete fITSgeom;
289     nlad[0]=20;nlad[1]=40;nlad[2]=14;nlad[3]=22;nlad[4]=34;nlad[5]=38;
290     ndet[0]=4;ndet[1]=4;ndet[2]=6;ndet[3]=8;ndet[4]=22;ndet[5]=25;
291     fITSgeom = new AliITSgeom(0,6,nlad,ndet,mod);
292     mod = -1;
293     for(lay=1;lay<=nlayers;lay++){
294         for(j=0;j<ndeep;j++) lnam[j] = itsGeomTreeNames[lay-1][j];
295         for(j=0;j<ndeep;j++) lnum[j] = itsGeomTreeCopys[lay-1][j];
296         switch (lay){
297         case 1: case 2: // layers 1 and 2 are a bit special
298             lad = 0;
299             for(j=1;j<=itsGeomTreeCopys[lay-1][4];j++){
300                 lnum[4] = j;
301                 for(k=1;k<=itsGeomTreeCopys[lay-1][5];k++){
302                     lad++;
303                     lnum[5] = k;
304                     for(det=1;det<=itsGeomTreeCopys[lay-1][6];det++){
305                         lnum[6] = det;
306                         mod++;
307                         ig->GetGeometry(ndeep,lnam,lnum,t,r,idshape,npar,natt,
308                                         par,att,imat,imed);
309                         fITSgeom->CreatMatrix(mod,lay,lad,det,kSPD,t,r);
310                         if(!(fITSgeom->IsShapeDefined((Int_t)kSPD)))
311                             if(fMinorVersion==1){
312                              fITSgeom->ReSetShape(kSPD,
313                                                   new AliITSgeomSPD425Short());
314                             } else if(fMinorVersion==2)
315                              fITSgeom->ReSetShape(kSPD,
316                                                   new AliITSgeomSPD425Short());
317                     } // end for det
318                 } // end for k
319             } // end for j
320             break;
321         case 3: case 4: case 5: case 6: // layers 3-6
322             lnum[6] = 1;
323             for(lad=1;lad<=itsGeomTreeCopys[lay-1][4];lad++){
324                 lnum[4] = lad;
325                 for(det=1;det<=itsGeomTreeCopys[lay-1][5];det++){
326                     lnum[5] = det;
327                     mod++;
328                     ig->GetGeometry(7,lnam,lnum,t,r,idshape,npar,natt,
329                                     par,att,imat,imed);
330                     switch (lay){
331                     case 3: case 4:
332                         fITSgeom->CreatMatrix(mod,lay,lad,det,kSDD,t,r);
333                         if(!(fITSgeom->IsShapeDefined(kSDD))) 
334                             fITSgeom->ReSetShape(kSDD,new AliITSgeomSDD256());
335                             break;
336                         case 5:
337                             fITSgeom->CreatMatrix(mod,lay,lad,det,kSSD,t,r);
338                             if(!(fITSgeom->IsShapeDefined(kSSD))) 
339                                 fITSgeom->ReSetShape(kSSD,new AliITSgeomSSD275and75());
340                             break;
341                         case 6:
342                             fITSgeom->CreatMatrix(mod,lay,lad,det,kSSDp,t,r);
343                             if(!(fITSgeom->IsShapeDefined(kSSDp))) 
344                                 fITSgeom->ReSetShape(kSSDp,new AliITSgeomSSD75and275());
345                             break;
346                         } // end switch
347                 } // end for det
348             } // end for lad
349             break;
350         } // end switch
351     } // end for lay
352     return;
353 }
354 //_____________________________________________________________________________
355 void AliITSvtest::Init(){
356 ////////////////////////////////////////////////////////////////////////
357 //     Initialise the ITS after it has been created.
358 ////////////////////////////////////////////////////////////////////////
359     Int_t i;
360
361     cout << endl;
362     for(i=0;i<29;i++) cout << "*";cout << " ITSvtest_Init ";
363     for(i=0;i<28;i++) cout << "*";cout << endl;
364 //
365     if(fRead[0]=='\0') strncpy(fRead,fEuclidGeomDet,60);
366     if(fWrite[0]=='\0') strncpy(fWrite,fEuclidGeomDet,60);
367     if(fITSgeom!=0) delete fITSgeom;
368     fITSgeom = new AliITSgeom();
369     if(fGeomDetIn) fITSgeom->ReadNewFile(fRead);
370     if(!fGeomDetIn) this->InitAliITSgeom();
371     if(fGeomDetOut) fITSgeom->WriteNewFile(fWrite);
372     AliITS::Init();
373 //
374     for(i=0;i<72;i++) cout << "*";
375     cout << endl;
376 }
377 //_____________________________________________________________________________
378 void AliITSvtest::StepManager(){
379   //
380   // Called for every step in the ITS
381   //
382   Int_t          copy, id;
383   Int_t          copy1,copy2;
384   Float_t        hits[8];
385   Int_t          vol[4];
386   TLorentzVector position, momentum;
387   TClonesArray   &lhits = *fHits;
388   //
389   // Track status
390   vol[3] = 0;
391   if(gMC->IsTrackInside())      vol[3] +=  1;
392   if(gMC->IsTrackEntering())    vol[3] +=  2;
393   if(gMC->IsTrackExiting())     vol[3] +=  4;
394   if(gMC->IsTrackOut())         vol[3] +=  8;
395   if(gMC->IsTrackDisappeared()) vol[3] += 16;
396   if(gMC->IsTrackStop())        vol[3] += 32;
397   if(gMC->IsTrackAlive())       vol[3] += 64;
398   //
399   // Fill hit structure.
400   if(!(gMC->TrackCharge())) return;
401   //
402   // Only entering charged tracks
403   if((id = gMC->CurrentVolID(copy)) == fIdSens[0]) {
404       vol[0] = 1;
405       id = gMC->CurrentVolOffID(0,copy);
406       //detector copy in the ladder = 1<->4  (ITS1)
407       vol[1] = copy;
408       gMC->CurrentVolOffID(1,copy1);
409       //ladder copy in the module   = 1<->2  (I186)
410       gMC->CurrentVolOffID(2,copy2);
411       //module copy in the layer    = 1<->10 (I132)
412       vol[2] = copy1+(copy2-1)*2;//# of ladders in one module  = 2
413   } else if(id == fIdSens[1]){
414       vol[0] = 2;
415       id = gMC->CurrentVolOffID(0,copy);
416       //detector copy in the ladder = 1<->4  (ITS2)
417       vol[1] = copy;
418       gMC->CurrentVolOffID(1,copy1);
419       //ladder copy in the module   = 1<->4  (I131)
420       gMC->CurrentVolOffID(2,copy2);
421       //module copy in the layer    = 1<->10 (I132)
422       vol[2] = copy1+(copy2-1)*4;//# of ladders in one module  = 4
423   } else if(id == fIdSens[2]){
424       vol[0] = 3;
425       id = gMC->CurrentVolOffID(1,copy);
426       //detector copy in the ladder = 1<->5  (ITS3 is inside I314)
427       vol[1] = copy;
428       id = gMC->CurrentVolOffID(2,copy);
429       //ladder copy in the layer    = 1<->12 (I316)
430       vol[2] = copy;
431   } else if(id == fIdSens[3]){
432       vol[0] = 4;
433       id = gMC->CurrentVolOffID(1,copy);
434       //detector copy in the ladder = 1<->8  (ITS4 is inside I414)
435       vol[1] = copy;
436       id = gMC->CurrentVolOffID(2,copy);
437       //ladder copy in the layer    = 1<->22 (I417)
438       vol[2] = copy;
439   }else if(id == fIdSens[4]){
440       vol[0] = 5;
441       id = gMC->CurrentVolOffID(1,copy);
442       //detector copy in the ladder = 1<->23  (ITS5 is inside I562)
443       vol[1] = copy;
444       id = gMC->CurrentVolOffID(2,copy);
445      //ladder copy in the layer    = 1<->34 (I565)
446       vol[2] = copy;
447   }else if(id == fIdSens[5]){
448       vol[0] = 6;
449       id = gMC->CurrentVolOffID(1,copy);
450       //detector copy in the ladder = 1<->26  (ITS6 is inside I566)
451       vol[1] = copy;
452       id = gMC->CurrentVolOffID(2,copy);
453       //ladder copy in the layer = 1<->38 (I569)
454       vol[2] = copy;
455   } else {
456       return; // not an ITS volume?
457   } // end if/else if (gMC->CurentVolID(copy) == fIdSens[i])
458 //
459   gMC->TrackPosition(position);
460   gMC->TrackMomentum(momentum);
461   hits[0]=position[0];
462   hits[1]=position[1];
463   hits[2]=position[2];
464   hits[3]=momentum[0];
465   hits[4]=momentum[1];
466   hits[5]=momentum[2];
467   hits[6]=gMC->Edep();
468   hits[7]=gMC->TrackTime();
469   // Fill hit structure with this new hit.
470   new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
471   return;
472 }
473