]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/AliAlignObj.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Adding new calibration flavours for trigger
[u/mrichter/AliRoot.git] / STEER / AliAlignObj.cxx
... / ...
CommitLineData
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// Implementation of the alignment object class through the abstract
18// class AliAlignObj. From it two derived concrete representation of
19// alignment object class (AliAlignObjAngles, AliAlignObjMatrix) are
20// derived in separate files.
21//-----------------------------------------------------------------
22/*****************************************************************************
23 * AliAlignObjAngles: derived alignment class storing alignment information *
24 * for a single volume in form of three doubles for the translation *
25 * and three doubles for the rotation expressed with the euler angles *
26 * in the xyz-convention (http://mathworld.wolfram.com/EulerAngles.html), *
27 * also known as roll, pitch, yaw. PLEASE NOTE THE ANGLES SIGNS ARE *
28 * INVERSE WITH RESPECT TO THIS REFERENCE!!! In this way the representation*
29 * is fully consistent with the TGeo Rotation methods. *
30 *****************************************************************************/
31
32#include <TGeoManager.h>
33#include <TGeoPhysicalNode.h>
34
35#include "AliAlignObj.h"
36#include "AliTrackPointArray.h"
37#include "AliLog.h"
38#include "AliAlignObjAngles.h"
39
40ClassImp(AliAlignObj)
41
42Int_t AliAlignObj::fgLayerSize[kLastLayer - kFirstLayer] = {
43 80, 160, // ITS SPD
44 84, 176, // ITS SDD
45 748, 950, // ITS SSD
46 36, 36, // TPC
47 90, 90, 90, 90, 90, 90, // TRD
48 1674, // TOF
49 1, 1, // PHOS ??
50 7, // RICH ??
51 1 // MUON ??
52};
53
54const char* AliAlignObj::fgLayerName[kLastLayer - kFirstLayer] = {
55 "ITS inner pixels layer", "ITS outer pixels layer",
56 "ITS inner drifts layer", "ITS outer drifts layer",
57 "ITS inner strips layer", "ITS outer strips layer",
58 "TPC inner chambers layer", "TPC outer chambers layer",
59 "TRD chambers layer 1", "TRD chambers layer 2", "TRD chambers layer 3",
60 "TRD chambers layer 4", "TRD chambers layer 5", "TRD chambers layer 6",
61 "TOF layer",
62 "?","?",
63 "RICH layer",
64 "?"
65};
66
67TString* AliAlignObj::fgVolPath[kLastLayer - kFirstLayer] = {
68 0x0,0x0,
69 0x0,0x0,
70 0x0,0x0,
71 0x0,0x0,
72 0x0,0x0,0x0,
73 0x0,0x0,0x0,
74 0x0,
75 0x0,0x0,
76 0x0,
77 0x0
78};
79
80AliAlignObj** AliAlignObj::fgAlignObjs[kLastLayer - kFirstLayer] = {
81 0x0,0x0,
82 0x0,0x0,
83 0x0,0x0,
84 0x0,0x0,
85 0x0,0x0,0x0,
86 0x0,0x0,0x0,
87 0x0,
88 0x0,0x0,
89 0x0,
90 0x0
91};
92
93//_____________________________________________________________________________
94AliAlignObj::AliAlignObj():
95 fVolUID(0)
96{
97 // default constructor
98 InitVolPaths();
99}
100
101//_____________________________________________________________________________
102AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
103 TObject(theAlignObj)
104{
105 //copy constructor
106 fVolPath = theAlignObj.GetVolPath();
107 fVolUID = theAlignObj.GetVolUID();
108}
109
110//_____________________________________________________________________________
111AliAlignObj &AliAlignObj::operator =(const AliAlignObj& theAlignObj)
112{
113 // assignment operator
114 if(this==&theAlignObj) return *this;
115 fVolPath = theAlignObj.GetVolPath();
116 fVolUID = theAlignObj.GetVolUID();
117 return *this;
118}
119
120//_____________________________________________________________________________
121AliAlignObj &AliAlignObj::operator*=(const AliAlignObj& theAlignObj)
122{
123 // multiplication operator
124 // The operator can be used to 'combine'
125 // two alignment objects
126 TGeoHMatrix m1;
127 GetMatrix(m1);
128 TGeoHMatrix m2;
129 theAlignObj.GetMatrix(m2);
130 m1.MultiplyLeft(&m2);
131 SetMatrix(m1);
132 return *this;
133}
134
135//_____________________________________________________________________________
136AliAlignObj::~AliAlignObj()
137{
138 // dummy destructor
139}
140
141//_____________________________________________________________________________
142void AliAlignObj::SetVolUID(ELayerID detId, Int_t modId)
143{
144 // From detector name and module number (according to detector numbering)
145 // build fVolUID, unique numerical identity of that volume inside ALICE
146 // fVolUID is 16 bits, first 5 reserved for detID (32 possible values),
147 // remaining 11 for module ID inside det (2048 possible values).
148 //
149 fVolUID = LayerToVolUID(detId,modId);
150}
151
152//_____________________________________________________________________________
153void AliAlignObj::GetVolUID(ELayerID &layerId, Int_t &modId) const
154{
155 // From detector name and module number (according to detector numbering)
156 // build fVolUID, unique numerical identity of that volume inside ALICE
157 // fVolUID is 16 bits, first 5 reserved for detID (32 possible values),
158 // remaining 11 for module ID inside det (2048 possible values).
159 //
160 layerId = VolUIDToLayer(fVolUID,modId);
161}
162
163//_____________________________________________________________________________
164void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
165{
166 // Calculates the rotation matrix using the
167 // Euler angles in "x y z" notation
168 Double_t degrad = TMath::DegToRad();
169 Double_t sinpsi = TMath::Sin(degrad*angles[0]);
170 Double_t cospsi = TMath::Cos(degrad*angles[0]);
171 Double_t sinthe = TMath::Sin(degrad*angles[1]);
172 Double_t costhe = TMath::Cos(degrad*angles[1]);
173 Double_t sinphi = TMath::Sin(degrad*angles[2]);
174 Double_t cosphi = TMath::Cos(degrad*angles[2]);
175
176 rot[0] = costhe*cosphi;
177 rot[1] = -costhe*sinphi;
178 rot[2] = sinthe;
179 rot[3] = sinpsi*sinthe*cosphi + cospsi*sinphi;
180 rot[4] = -sinpsi*sinthe*sinphi + cospsi*cosphi;
181 rot[5] = -costhe*sinpsi;
182 rot[6] = -cospsi*sinthe*cosphi + sinpsi*sinphi;
183 rot[7] = cospsi*sinthe*sinphi + sinpsi*cosphi;
184 rot[8] = costhe*cospsi;
185}
186
187//_____________________________________________________________________________
188Bool_t AliAlignObj::MatrixToAngles(const Double_t *rot, Double_t *angles) const
189{
190 // Calculates the Euler angles in "x y z" notation
191 // using the rotation matrix
192 if(TMath::Abs(rot[0])<1e-7 || TMath::Abs(rot[8])<1e-7) return kFALSE;
193 Double_t raddeg = TMath::RadToDeg();
194 angles[0]=raddeg*TMath::ATan2(-rot[5],rot[8]);
195 angles[1]=raddeg*TMath::ASin(rot[2]);
196 angles[2]=raddeg*TMath::ATan2(-rot[1],rot[0]);
197 return kTRUE;
198}
199
200//______________________________________________________________________________
201void AliAlignObj::Transform(AliTrackPoint &p) const
202{
203 // The method transforms the space-point coordinates using the
204 // transformation matrix provided by the AliAlignObj
205 // The covariance matrix is not affected since we assume
206 // that the transformations are sufficiently small
207
208 if (fVolUID != p.GetVolumeID())
209 AliWarning(Form("Alignment object ID is not equal to the space-point ID (%d != %d)",fVolUID,p.GetVolumeID()));
210
211 TGeoHMatrix m;
212 GetMatrix(m);
213 Double_t *rot = m.GetRotationMatrix();
214 Double_t *tr = m.GetTranslation();
215
216 Float_t xyzin[3],xyzout[3];
217 p.GetXYZ(xyzin);
218 for (Int_t i = 0; i < 3; i++)
219 xyzout[i] = tr[i]+
220 xyzin[0]*rot[3*i]+
221 xyzin[1]*rot[3*i+1]+
222 xyzin[2]*rot[3*i+2];
223 p.SetXYZ(xyzout);
224
225}
226
227//______________________________________________________________________________
228void AliAlignObj::Transform(AliTrackPointArray &array) const
229{
230 AliTrackPoint p;
231 for (Int_t i = 0; i < array.GetNPoints(); i++) {
232 array.GetPoint(p,i);
233 Transform(p);
234 array.AddPoint(i,&p);
235 }
236}
237
238//_____________________________________________________________________________
239void AliAlignObj::Print(Option_t *) const
240{
241 // Print the contents of the
242 // alignment object in angles and
243 // matrix representations
244 Double_t tr[3];
245 GetTranslation(tr);
246 Double_t angles[3];
247 GetAngles(angles);
248 TGeoHMatrix m;
249 GetMatrix(m);
250 const Double_t *rot = m.GetRotationMatrix();
251// printf("Volume=%s ID=%u\n", GetVolPath(),GetVolUID());
252 ELayerID layerId;
253 Int_t modId;
254 GetVolUID(layerId,modId);
255 printf("Volume=%s LayerID=%d ModuleID=%d\n", GetVolPath(),layerId,modId);
256 printf("%12.6f%12.6f%12.6f Tx = %12.6f Psi = %12.6f\n", rot[0], rot[1], rot[2], tr[0], angles[0]);
257 printf("%12.6f%12.6f%12.6f Ty = %12.6f Theta = %12.6f\n", rot[3], rot[4], rot[5], tr[1], angles[1]);
258 printf("%12.6f%12.6f%12.6f Tz = %12.6f Phi = %12.6f\n", rot[6], rot[7], rot[8], tr[2], angles[2]);
259
260}
261
262//_____________________________________________________________________________
263UShort_t AliAlignObj::LayerToVolUID(ELayerID layerId, Int_t modId)
264{
265 // From detector (layer) name and module number (according to detector numbering)
266 // build fVolUID, unique numerical identity of that volume inside ALICE
267 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
268 // remaining 11 for module ID inside det (2048 possible values).
269 //
270 return ((UShort_t(layerId) << 11) | UShort_t(modId));
271}
272
273//_____________________________________________________________________________
274UShort_t AliAlignObj::LayerToVolUID(Int_t layerId, Int_t modId)
275{
276 // From detector (layer) index and module number (according to detector numbering)
277 // build fVolUID, unique numerical identity of that volume inside ALICE
278 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
279 // remaining 11 for module ID inside det (2048 possible values).
280 //
281 return ((UShort_t(layerId) << 11) | UShort_t(modId));
282}
283
284//_____________________________________________________________________________
285AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid, Int_t &modId)
286{
287 // From detector (layer) name and module number (according to detector numbering)
288 // build fVolUID, unique numerical identity of that volume inside ALICE
289 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
290 // remaining 11 for module ID inside det (2048 possible values).
291 //
292 modId = voluid & 0x7ff;
293
294 return VolUIDToLayer(voluid);
295}
296
297//_____________________________________________________________________________
298AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid)
299{
300 // From detector (layer) name and module number (according to detector numbering)
301 // build fVolUID, unique numerical identity of that volume inside ALICE
302 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
303 // remaining 11 for module ID inside det (2048 possible values).
304 //
305 return ELayerID((voluid >> 11) & 0x1f);
306}
307
308//_____________________________________________________________________________
309Bool_t AliAlignObj::SetLocalPars(Double_t x, Double_t y, Double_t z,
310 Double_t psi, Double_t theta, Double_t phi)
311{
312 // Set the translations and angles by using parameters
313 // defined in the local (in TGeo means) coordinate system
314 // of the alignable volume. In case that the TGeo was
315 // initialized, returns false and the object parameters are
316 // not set.
317 if (!gGeoManager || !gGeoManager->IsClosed()) {
318 AliError("Can't set the alignment object parameters! gGeoManager doesn't exist or it is still opened!");
319 return kFALSE;
320 }
321
322 const char* volpath = GetVolPath();
323 TGeoPhysicalNode* node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(volpath);
324 if (!node) {
325 AliError(Form("Volume path %s not valid!",volpath));
326 return kFALSE;
327 }
328 if (node->IsAligned())
329 AliWarning(Form("Volume %s has been already misaligned!",volpath));
330
331 TGeoHMatrix m;
332 Double_t tr[3];
333 tr[0]=x; tr[1]=y; tr[2]=z;
334 m.SetTranslation(tr);
335 Double_t angles[3] = {psi, theta, phi};
336 Double_t rot[9];
337 AnglesToMatrix(angles,rot);
338 m.SetRotation(rot);
339
340 TGeoHMatrix align,gprime,gprimeinv;
341 gprime = *node->GetMatrix();
342 gprimeinv = gprime.Inverse();
343 m.Multiply(&gprimeinv);
344 m.MultiplyLeft(&gprime);
345
346 SetMatrix(m);
347
348 return kTRUE;
349}
350
351//_____________________________________________________________________________
352Bool_t AliAlignObj::ApplyToGeometry()
353{
354 // Apply the current alignment object
355 // to the TGeo geometry
356
357 if (!gGeoManager || !gGeoManager->IsClosed()) {
358 AliError("Can't apply the alignment object! gGeoManager doesn't exist or it is still opened!");
359 return kFALSE;
360 }
361
362 const char* volpath = GetVolPath();
363 TGeoPhysicalNode* node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(volpath);
364 if (!node) {
365 AliError(Form("Volume path %s not valid!",volpath));
366 return kFALSE;
367 }
368 if (node->IsAligned()) {
369 AliWarning(Form("Volume %s has been already misaligned!",volpath));
370 return kFALSE;
371 }
372
373 TGeoHMatrix align,gprime;
374 gprime = *node->GetMatrix();
375 GetMatrix(align);
376 gprime.MultiplyLeft(&align);
377 TGeoHMatrix *ginv = new TGeoHMatrix;
378 TGeoHMatrix *g = node->GetMatrix(node->GetLevel()-1);
379 *ginv = g->Inverse();
380 *ginv *= gprime;
381 AliAlignObj::ELayerID layerId; // unique identity for volume in the alobj
382 Int_t modId; // unique identity for volume in the alobj
383 GetVolUID(layerId, modId);
384 AliInfo(Form("Aligning volume %s of detector layer %d with local ID %d",volpath,layerId,modId));
385 node->Align(ginv);
386
387 return kTRUE;
388}
389
390//_____________________________________________________________________________
391Bool_t AliAlignObj::GetFromGeometry(const char *path, AliAlignObj &alobj)
392{
393 // Get the alignment object which correspond
394 // to the TGeo volume defined by the 'path'.
395 // The method is extremely slow due to the
396 // searching by string. Therefore it should
397 // be used with great care!!
398
399 // Reset the alignment object
400 alobj.SetPars(0,0,0,0,0,0);
401 alobj.SetVolPath(path);
402
403 if (!gGeoManager || !gGeoManager->IsClosed()) {
404 AliErrorClass("Can't get the alignment object! gGeoManager doesn't exist or it is still opened!");
405 return kFALSE;
406 }
407
408 if (!gGeoManager->GetListOfPhysicalNodes()) {
409 AliErrorClass("Can't get the alignment object! gGeoManager doesn't contain any aligned nodes!");
410 return kFALSE;
411 }
412
413 TObjArray* nodesArr = gGeoManager->GetListOfPhysicalNodes();
414 TGeoPhysicalNode* node = NULL;
415 for (Int_t iNode = 0; iNode < nodesArr->GetEntriesFast(); iNode++) {
416 node = (TGeoPhysicalNode*) nodesArr->UncheckedAt(iNode);
417 const char *nodePath = node->GetName();
418 if (strcmp(path,nodePath) == 0) break;
419 }
420 if (!node) {
421 if (!gGeoManager->cd(path)) {
422 AliErrorClass(Form("Volume path %s not found!",path));
423 return kFALSE;
424 }
425 else {
426 AliWarningClass(Form("Volume (%s) has not been misaligned!",path));
427 return kTRUE;
428 }
429 }
430
431 TGeoHMatrix align,gprime,g,ginv,l;
432 gprime = *node->GetMatrix();
433 l = *node->GetOriginalMatrix();
434 g = *node->GetMatrix(node->GetLevel()-1);
435 g *= l;
436 ginv = g.Inverse();
437 align = gprime * ginv;
438 alobj.SetMatrix(align);
439
440 return kTRUE;
441}
442
443void AliAlignObj::InitAlignObjFromGeometry()
444{
445 // Loop over all alignable volumes and extract
446 // the corresponding alignment objects from
447 // the TGeo geometry
448
449 if(fgAlignObjs[0]) return;
450
451 InitVolPaths();
452
453 for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
454 fgAlignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer)];
455 for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
456 UShort_t volid = AliAlignObj::LayerToVolUID(iLayer+ AliAlignObj::kFirstLayer,iModule);
457 fgAlignObjs[iLayer][iModule] = new AliAlignObjAngles("",volid,0,0,0,0,0,0);
458 const char *path = GetVolPath(volid);
459 if (!GetFromGeometry(path, *fgAlignObjs[iLayer][iModule]))
460 AliErrorClass(Form("Failed to extract the alignment object for the volume (ID=%d and path=%s) !",volid,path));
461 }
462 }
463
464}
465
466//_____________________________________________________________________________
467AliAlignObj* AliAlignObj::GetAlignObj(ELayerID layerId, Int_t modId)
468{
469 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
470 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
471 return NULL;
472 }
473 return fgAlignObjs[layerId-kFirstLayer][modId];
474}
475
476//_____________________________________________________________________________
477const char* AliAlignObj::GetVolPath(ELayerID layerId, Int_t modId)
478{
479 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
480 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
481 return NULL;
482 }
483 return fgVolPath[layerId-kFirstLayer][modId].Data();
484}
485
486//_____________________________________________________________________________
487void AliAlignObj::InitVolPaths()
488{
489 // Initialize the LUTs which contain
490 // the TGeo volume paths for each
491 // alignable volume. The LUTs are
492 // static, so they are created during
493 // the creation of the first intance
494 // of AliAlignObj
495
496 if (fgVolPath[0]) return;
497
498 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++)
499 fgVolPath[iLayer] = new TString[fgLayerSize[iLayer]];
500
501 /********************* SPD layer1 ***********************/
502 {
503 Int_t modnum = 0;
504 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT12_1/I12B_"; //".../I12A_"
505 TString str1 = "/I10B_"; //"/I10A_";
506 TString str2 = "/I107_"; //"/I103_"
507 // TString str3 = "/I101_1/ITS1_1";
508 TString volpath, volpath1, volpath2;
509
510 for(Int_t c1 = 1; c1<=10; c1++){
511 volpath = str0;
512 volpath += c1;
513 volpath += str1;
514 for(Int_t c2 =1; c2<=2; c2++){
515 volpath1 = volpath;
516 volpath1 += c2;
517 volpath1 += str2;
518 for(Int_t c3 =1; c3<=4; c3++){
519 volpath2 = volpath1;
520 volpath2 += c3;
521 // volpath2 += str3;
522 fgVolPath[kSPD1-kFirstLayer][modnum] = volpath2.Data();
523 modnum++;
524 }
525 }
526 }
527 }
528
529 /********************* SPD layer2 ***********************/
530 {
531 Int_t modnum = 0;
532 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT12_1/I12B_"; //".../I12A_"
533 TString str1 = "/I20B_"; //"/I20A"
534 TString str2 = "/I1D7_"; //"/I1D3"
535 // TString str3 = "/I1D1_1/ITS2_1";
536 TString volpath, volpath1, volpath2;
537
538 for(Int_t c1 = 1; c1<=10; c1++){
539 volpath = str0;
540 volpath += c1;
541 volpath += str1;
542 for(Int_t c2 =1; c2<=4; c2++){
543 volpath1 = volpath;
544 volpath1 += c2;
545 volpath1 += str2;
546 for(Int_t c3 =1; c3<=4; c3++){
547 volpath2 = volpath1;
548 volpath2 += c3;
549 // volpath2 += str3;
550 fgVolPath[kSPD2-kFirstLayer][modnum] = volpath2.Data();
551 modnum++;
552 }
553 }
554 }
555 }
556
557 /********************* SDD layer1 ***********************/
558 {
559 Int_t modnum=0;
560 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I004_";
561 TString str1 = "/I302_";
562 // TString str2 = "/ITS3_1";
563 TString volpath, volpath1;
564
565 for(Int_t c1 = 1; c1<=14; c1++){
566 volpath = str0;
567 volpath += c1;
568 volpath += str1;
569 for(Int_t c2 =1; c2<=6; c2++){
570 volpath1 = volpath;
571 volpath1 += c2;
572 // volpath1 += str2;
573 fgVolPath[kSDD1-kFirstLayer][modnum] = volpath1.Data();
574 modnum++;
575 }
576 }
577 }
578
579 /********************* SDD layer2 ***********************/
580 {
581 Int_t modnum=0;
582 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I005_";
583 TString str1 = "/I402_";
584 // TString str2 = "/ITS4_1";
585 TString volpath, volpath1;
586
587 for(Int_t c1 = 1; c1<=22; c1++){
588 volpath = str0;
589 volpath += c1;
590 volpath += str1;
591 for(Int_t c2 = 1; c2<=8; c2++){
592 volpath1 = volpath;
593 volpath1 += c2;
594 // volpath1 += str2;
595 fgVolPath[kSDD2-kFirstLayer][modnum] = volpath1.Data();
596 modnum++;
597 }
598 }
599 }
600
601 /********************* SSD layer1 ***********************/
602 {
603 Int_t modnum=0;
604 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I565_";
605 TString str1 = "/I562_";
606 // TString str2 = "/ITS5_1";
607 TString volpath, volpath1;
608
609 for(Int_t c1 = 1; c1<=34; c1++){
610 volpath = str0;
611 volpath += c1;
612 volpath += str1;
613 for(Int_t c2 = 1; c2<=22; c2++){
614 volpath1 = volpath;
615 volpath1 += c2;
616 // volpath1 += str2;
617 fgVolPath[kSSD1-kFirstLayer][modnum] = volpath1.Data();
618 modnum++;
619 }
620 }
621 }
622
623 /********************* SSD layer1 ***********************/
624 {
625 Int_t modnum=0;
626 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I569_";
627 TString str1 = "/I566_";
628 // TString str2 = "/ITS6_1";
629 TString volpath, volpath1;
630
631 for(Int_t c1 = 1; c1<=38; c1++){
632 volpath = str0;
633 volpath += c1;
634 volpath += str1;
635 for(Int_t c2 = 1; c2<=25; c2++){
636 volpath1 = volpath;
637 volpath1 += c2;
638 // volpath1 += str2;
639 fgVolPath[kSSD2-kFirstLayer][modnum] = volpath1.Data();
640 modnum++;
641 }
642 }
643 }
644
645 /*************** TPC inner chambers' layer ****************/
646 {
647 Int_t modnum = 0;
648 TString str1 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_1/TPC_SECT_";
649 TString str2 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_2/TPC_SECT_";
650 TString str_in = "/TPC_IROC_1";
651 TString volpath;
652
653 for(Int_t cnt=1; cnt<=18; cnt++){
654 volpath = str1;
655 volpath += cnt;
656 volpath += str_in;
657 fgVolPath[kTPC1-kFirstLayer][modnum] = volpath.Data();
658 modnum++;
659 }
660 for(Int_t cnt=1; cnt<=18; cnt++){
661 volpath = str2;
662 volpath += cnt;
663 volpath += str_in;
664 fgVolPath[kTPC1-kFirstLayer][modnum] = volpath.Data();
665 modnum++;
666 }
667 }
668
669 /*************** TPC outer chambers' layer ****************/
670 {
671 Int_t modnum = 0;
672 TString str1 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_1/TPC_SECT_";
673 TString str2 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_2/TPC_SECT_";
674 TString str_out = "/TPC_OROC_1";
675 TString volpath;
676
677 for(Int_t cnt=1; cnt<=18; cnt++){
678 volpath = str1;
679 volpath += cnt;
680 volpath += str_out;
681 fgVolPath[kTPC2-kFirstLayer][modnum] = volpath.Data();
682 modnum++;
683 }
684 for(Int_t cnt=1; cnt<=18; cnt++){
685 volpath = str2;
686 volpath += cnt;
687 volpath += str_out;
688 fgVolPath[kTPC2-kFirstLayer][modnum] = volpath.Data();
689 modnum++;
690 }
691 }
692
693 /********************* TOF layer ***********************/
694 {
695 Int_t nstrA=15;
696 Int_t nstrB=19;
697 Int_t nstrC=20;
698 Int_t nStripSec=nstrA+2*nstrB+2*nstrC;
699
700 for (Int_t modnum=0; modnum < 1674; modnum++) {
701
702 Int_t sector = modnum/nStripSec;
703 Char_t string1[100];
704 Char_t string2[100];
705
706 Int_t icopy=-1;
707
708 if(sector<3){
709 icopy=sector+1;
710 sprintf(string1,"/ALIC_1/B077_1/B075_%i/BTO3_1",icopy);
711 }
712 else if(sector<11){
713 icopy=sector-2;
714 sprintf(string1,"/ALIC_1/B077_1/B071_%i/BTO1_1",icopy);
715 }
716 else if(sector==11 || sector==12){
717 icopy=sector-10;
718 sprintf(string1,"/ALIC_1/B077_1/B074_%i/BTO2_1",icopy);
719 }
720 else {
721 icopy=sector-4;
722 sprintf(string1,"/ALIC_1/B077_1/B071_%i/BTO1_1",icopy);
723 }
724
725 Int_t strInSec=modnum%nStripSec;
726
727 if( strInSec < nstrC){
728 icopy= nstrC - (strInSec+1) + 1;
729 sprintf(string2,"FTOC_1/FLTC_0/FSTR_%i",icopy);
730 }
731 else if(strInSec< nstrC+nstrB){
732
733 icopy= nstrB - (strInSec-nstrC+1) + 1;
734 sprintf(string2,"FTOB_1/FLTB_0/FSTR_%i",icopy);
735
736 }
737 else if(strInSec< nstrC+nstrB+nstrA){
738
739 icopy= strInSec-(nstrC+nstrB)+1;
740 sprintf(string2,"FTOA_0/FLTA_0/FSTR_%i",icopy);
741 }
742 else if(strInSec< nstrC+2*nstrB+nstrA){
743
744 icopy= strInSec-(nstrC+nstrB+nstrA)+1;
745 sprintf(string2,"FTOB_2/FLTB_0/FSTR_%i",icopy);
746
747 }
748 else {
749
750 icopy= strInSec-(nstrC+2*nstrB+nstrA)+1;
751 sprintf(string2,"FTOC_2/FLTC_0/FSTR_%i",icopy);
752
753 }
754
755 Char_t path[100];
756 sprintf(path,"%s/%s",string1,string2);
757 // printf("%d %s\n",modnum,path);
758 fgVolPath[kTOF-kFirstLayer][modnum] = path;
759 }
760 }
761
762 /********************* RICH layer ***********************/
763 {
764 TString str = "ALIC_1/RICH_";
765 TString volpath;
766
767 for (Int_t modnum=0; modnum < 7; modnum++) {
768 volpath = str;
769 volpath += (modnum+1);
770 fgVolPath[kRICH-kFirstLayer][modnum] = volpath.Data();
771 }
772 }
773}