]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliAlignObj.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PropagateToDCA in case of track and vertex (M.Ivanov)
[u/mrichter/AliRoot.git] / STEER / AliAlignObj.cxx
CommitLineData
c18195b9 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//-----------------------------------------------------------------
befe2c08 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.
c18195b9 21//-----------------------------------------------------------------
fdf65bb5 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 *****************************************************************************/
c18195b9 31
995ad051 32#include <TGeoManager.h>
33#include <TGeoPhysicalNode.h>
34
c18195b9 35#include "AliAlignObj.h"
03b18860 36#include "AliTrackPointArray.h"
37#include "AliLog.h"
c5304981 38#include "AliAlignObjAngles.h"
98937d93 39
c18195b9 40ClassImp(AliAlignObj)
41
98937d93 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
da027ef2 48 1638, // TOF
98937d93 49 1, 1, // PHOS ??
03b18860 50 7, // RICH ??
98937d93 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 "?","?",
03b18860 63 "RICH layer",
98937d93 64 "?"
65};
66
7604a026 67TString* AliAlignObj::fgVolPath[kLastLayer - kFirstLayer] = {
03b18860 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
c5304981 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
c18195b9 93//_____________________________________________________________________________
94AliAlignObj::AliAlignObj():
95 fVolUID(0)
96{
03b18860 97 // default constructor
98 InitVolPaths();
c18195b9 99}
100
101//_____________________________________________________________________________
d9cc42ed 102AliAlignObj::AliAlignObj(const char* volpath, UShort_t voluid) : TObject()
103{
104 // standard constructor
105 //
106 fVolPath=volpath;
107 fVolUID=voluid;
108}
109
110AliAlignObj::AliAlignObj(const char* volpath, ELayerID detId, Int_t volId) : TObject()
111{
112 // standard constructor
113 //
114 fVolPath=volpath;
115 SetVolUID(detId,volId);
116}
117
118//_____________________________________________________________________________
c18195b9 119AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
120 TObject(theAlignObj)
121{
122 //copy constructor
123 fVolPath = theAlignObj.GetVolPath();
124 fVolUID = theAlignObj.GetVolUID();
125}
126
127//_____________________________________________________________________________
128AliAlignObj &AliAlignObj::operator =(const AliAlignObj& theAlignObj)
129{
130 // assignment operator
131 if(this==&theAlignObj) return *this;
132 fVolPath = theAlignObj.GetVolPath();
133 fVolUID = theAlignObj.GetVolUID();
134 return *this;
135}
136
38b3a170 137//_____________________________________________________________________________
138AliAlignObj &AliAlignObj::operator*=(const AliAlignObj& theAlignObj)
139{
140 // multiplication operator
141 // The operator can be used to 'combine'
142 // two alignment objects
143 TGeoHMatrix m1;
144 GetMatrix(m1);
145 TGeoHMatrix m2;
146 theAlignObj.GetMatrix(m2);
147 m1.MultiplyLeft(&m2);
148 SetMatrix(m1);
149 return *this;
150}
151
c18195b9 152//_____________________________________________________________________________
153AliAlignObj::~AliAlignObj()
154{
155 // dummy destructor
156}
157
befe2c08 158//_____________________________________________________________________________
159void AliAlignObj::SetVolUID(ELayerID detId, Int_t modId)
160{
161 // From detector name and module number (according to detector numbering)
162 // build fVolUID, unique numerical identity of that volume inside ALICE
163 // fVolUID is 16 bits, first 5 reserved for detID (32 possible values),
164 // remaining 11 for module ID inside det (2048 possible values).
165 //
166 fVolUID = LayerToVolUID(detId,modId);
167}
168
169//_____________________________________________________________________________
170void AliAlignObj::GetVolUID(ELayerID &layerId, Int_t &modId) const
171{
172 // From detector name and module number (according to detector numbering)
173 // build fVolUID, unique numerical identity of that volume inside ALICE
174 // fVolUID is 16 bits, first 5 reserved for detID (32 possible values),
175 // remaining 11 for module ID inside det (2048 possible values).
176 //
177 layerId = VolUIDToLayer(fVolUID,modId);
178}
179
4b94e753 180//_____________________________________________________________________________
181Int_t AliAlignObj::GetLevel() const
182{
183 // Return the geometry level of
184 // the alignable volume to which
185 // the alignment object is associated
186 TString volpath = fVolPath;
187 return (volpath.CountChar('/')+1);
188}
189
190//_____________________________________________________________________________
191Int_t AliAlignObj::Compare(const TObject *obj) const
192{
193 // Compare the levels of two
194 // alignment objects
195 // Used in the sorting during
196 // the application of alignment
197 // objects to the geometry
198 Int_t level = GetLevel();
199 Int_t level2 = ((AliAlignObj *)obj)->GetLevel();
200 if (level == level2)
201 return 0;
202 else
203 return ((level > level2) ? 1 : -1);
204}
205
c18195b9 206//_____________________________________________________________________________
207void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
208{
fdf65bb5 209 // Calculates the rotation matrix using the
210 // Euler angles in "x y z" notation
c18195b9 211 Double_t degrad = TMath::DegToRad();
212 Double_t sinpsi = TMath::Sin(degrad*angles[0]);
213 Double_t cospsi = TMath::Cos(degrad*angles[0]);
214 Double_t sinthe = TMath::Sin(degrad*angles[1]);
215 Double_t costhe = TMath::Cos(degrad*angles[1]);
216 Double_t sinphi = TMath::Sin(degrad*angles[2]);
217 Double_t cosphi = TMath::Cos(degrad*angles[2]);
218
219 rot[0] = costhe*cosphi;
220 rot[1] = -costhe*sinphi;
221 rot[2] = sinthe;
222 rot[3] = sinpsi*sinthe*cosphi + cospsi*sinphi;
223 rot[4] = -sinpsi*sinthe*sinphi + cospsi*cosphi;
224 rot[5] = -costhe*sinpsi;
225 rot[6] = -cospsi*sinthe*cosphi + sinpsi*sinphi;
226 rot[7] = cospsi*sinthe*sinphi + sinpsi*cosphi;
227 rot[8] = costhe*cospsi;
228}
229
230//_____________________________________________________________________________
231Bool_t AliAlignObj::MatrixToAngles(const Double_t *rot, Double_t *angles) const
232{
fdf65bb5 233 // Calculates the Euler angles in "x y z" notation
234 // using the rotation matrix
900d2087 235 if(TMath::Abs(rot[0])<1e-7 || TMath::Abs(rot[8])<1e-7) return kFALSE;
c18195b9 236 Double_t raddeg = TMath::RadToDeg();
237 angles[0]=raddeg*TMath::ATan2(-rot[5],rot[8]);
238 angles[1]=raddeg*TMath::ASin(rot[2]);
239 angles[2]=raddeg*TMath::ATan2(-rot[1],rot[0]);
240 return kTRUE;
241}
242
03b18860 243//______________________________________________________________________________
244void AliAlignObj::Transform(AliTrackPoint &p) const
245{
246 // The method transforms the space-point coordinates using the
247 // transformation matrix provided by the AliAlignObj
248 // The covariance matrix is not affected since we assume
249 // that the transformations are sufficiently small
250
251 if (fVolUID != p.GetVolumeID())
252 AliWarning(Form("Alignment object ID is not equal to the space-point ID (%d != %d)",fVolUID,p.GetVolumeID()));
253
254 TGeoHMatrix m;
255 GetMatrix(m);
256 Double_t *rot = m.GetRotationMatrix();
257 Double_t *tr = m.GetTranslation();
258
259 Float_t xyzin[3],xyzout[3];
260 p.GetXYZ(xyzin);
261 for (Int_t i = 0; i < 3; i++)
262 xyzout[i] = tr[i]+
263 xyzin[0]*rot[3*i]+
264 xyzin[1]*rot[3*i+1]+
265 xyzin[2]*rot[3*i+2];
266 p.SetXYZ(xyzout);
267
268}
269
270//______________________________________________________________________________
271void AliAlignObj::Transform(AliTrackPointArray &array) const
272{
273 AliTrackPoint p;
274 for (Int_t i = 0; i < array.GetNPoints(); i++) {
275 array.GetPoint(p,i);
276 Transform(p);
277 array.AddPoint(i,&p);
278 }
279}
280
c18195b9 281//_____________________________________________________________________________
282void AliAlignObj::Print(Option_t *) const
283{
284 // Print the contents of the
285 // alignment object in angles and
286 // matrix representations
287 Double_t tr[3];
288 GetTranslation(tr);
289 Double_t angles[3];
290 GetAngles(angles);
291 TGeoHMatrix m;
292 GetMatrix(m);
293 const Double_t *rot = m.GetRotationMatrix();
c18195b9 294
c041444f 295 printf("Volume=%s\n",GetVolPath());
296 if (GetVolUID() != 0) {
297 ELayerID layerId;
298 Int_t modId;
299 GetVolUID(layerId,modId);
300 printf("VolumeID=%d LayerID=%d ( %s ) ModuleID=%d\n", GetVolUID(),layerId,LayerName(layerId),modId);
301 }
302 printf("%12.8f%12.8f%12.8f Tx = %12.8f Psi = %12.8f\n", rot[0], rot[1], rot[2], tr[0], angles[0]);
303 printf("%12.8f%12.8f%12.8f Ty = %12.8f Theta = %12.8f\n", rot[3], rot[4], rot[5], tr[1], angles[1]);
304 printf("%12.8f%12.8f%12.8f Tz = %12.8f Phi = %12.8f\n", rot[6], rot[7], rot[8], tr[2], angles[2]);
305
306}
307
308//_____________________________________________________________________________
309Int_t AliAlignObj::LayerSize(Int_t layerId)
310{
311 // Get the corresponding layer size.
312 // Implemented only for ITS,TPC,TRD,TOF and RICH
313 if (layerId < kFirstLayer || layerId >= kLastLayer) {
314 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
315 return 0;
316 }
317 else {
318 return fgLayerSize[layerId - kFirstLayer];
319 }
320}
321
322//_____________________________________________________________________________
323const char* AliAlignObj::LayerName(Int_t layerId)
324{
325 // Get the corresponding layer name.
326 // Implemented only for ITS,TPC,TRD,TOF and RICH
327 if (layerId < kFirstLayer || layerId >= kLastLayer) {
328 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
329 return "Invalid Layer!";
330 }
331 else {
332 return fgLayerName[layerId - kFirstLayer];
333 }
c18195b9 334}
335
c18195b9 336//_____________________________________________________________________________
befe2c08 337UShort_t AliAlignObj::LayerToVolUID(ELayerID layerId, Int_t modId)
c18195b9 338{
befe2c08 339 // From detector (layer) name and module number (according to detector numbering)
340 // build fVolUID, unique numerical identity of that volume inside ALICE
341 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
342 // remaining 11 for module ID inside det (2048 possible values).
c18195b9 343 //
befe2c08 344 return ((UShort_t(layerId) << 11) | UShort_t(modId));
c18195b9 345}
346
46ae650f 347//_____________________________________________________________________________
348UShort_t AliAlignObj::LayerToVolUID(Int_t layerId, Int_t modId)
349{
350 // From detector (layer) index and module number (according to detector numbering)
351 // build fVolUID, unique numerical identity of that volume inside ALICE
352 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
353 // remaining 11 for module ID inside det (2048 possible values).
354 //
355 return ((UShort_t(layerId) << 11) | UShort_t(modId));
356}
357
c18195b9 358//_____________________________________________________________________________
befe2c08 359AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid, Int_t &modId)
c18195b9 360{
befe2c08 361 // From detector (layer) name and module number (according to detector numbering)
362 // build fVolUID, unique numerical identity of that volume inside ALICE
363 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
364 // remaining 11 for module ID inside det (2048 possible values).
365 //
366 modId = voluid & 0x7ff;
c18195b9 367
befe2c08 368 return VolUIDToLayer(voluid);
c18195b9 369}
370
371//_____________________________________________________________________________
befe2c08 372AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid)
c18195b9 373{
befe2c08 374 // From detector (layer) name and module number (according to detector numbering)
375 // build fVolUID, unique numerical identity of that volume inside ALICE
376 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
377 // remaining 11 for module ID inside det (2048 possible values).
378 //
379 return ELayerID((voluid >> 11) & 0x1f);
c18195b9 380}
03b18860 381
1bfe7ffc 382//_____________________________________________________________________________
383Bool_t AliAlignObj::SetLocalPars(Double_t x, Double_t y, Double_t z,
384 Double_t psi, Double_t theta, Double_t phi)
385{
386 // Set the translations and angles by using parameters
387 // defined in the local (in TGeo means) coordinate system
388 // of the alignable volume. In case that the TGeo was
389 // initialized, returns false and the object parameters are
390 // not set.
391 if (!gGeoManager || !gGeoManager->IsClosed()) {
392 AliError("Can't set the alignment object parameters! gGeoManager doesn't exist or it is still opened!");
393 return kFALSE;
394 }
395
396 const char* volpath = GetVolPath();
397 TGeoPhysicalNode* node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(volpath);
398 if (!node) {
399 AliError(Form("Volume path %s not valid!",volpath));
400 return kFALSE;
401 }
402 if (node->IsAligned())
403 AliWarning(Form("Volume %s has been already misaligned!",volpath));
404
405 TGeoHMatrix m;
406 Double_t tr[3];
407 tr[0]=x; tr[1]=y; tr[2]=z;
408 m.SetTranslation(tr);
409 Double_t angles[3] = {psi, theta, phi};
410 Double_t rot[9];
411 AnglesToMatrix(angles,rot);
412 m.SetRotation(rot);
413
414 TGeoHMatrix align,gprime,gprimeinv;
415 gprime = *node->GetMatrix();
416 gprimeinv = gprime.Inverse();
417 m.Multiply(&gprimeinv);
418 m.MultiplyLeft(&gprime);
419
420 SetMatrix(m);
421
422 return kTRUE;
423}
424
995ad051 425//_____________________________________________________________________________
426Bool_t AliAlignObj::ApplyToGeometry()
427{
428 // Apply the current alignment object
429 // to the TGeo geometry
430
431 if (!gGeoManager || !gGeoManager->IsClosed()) {
432 AliError("Can't apply the alignment object! gGeoManager doesn't exist or it is still opened!");
433 return kFALSE;
434 }
435
436 const char* volpath = GetVolPath();
437 TGeoPhysicalNode* node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(volpath);
438 if (!node) {
439 AliError(Form("Volume path %s not valid!",volpath));
440 return kFALSE;
441 }
442 if (node->IsAligned()) {
443 AliWarning(Form("Volume %s has been already misaligned!",volpath));
444 return kFALSE;
445 }
446
447 TGeoHMatrix align,gprime;
448 gprime = *node->GetMatrix();
449 GetMatrix(align);
450 gprime.MultiplyLeft(&align);
451 TGeoHMatrix *ginv = new TGeoHMatrix;
452 TGeoHMatrix *g = node->GetMatrix(node->GetLevel()-1);
453 *ginv = g->Inverse();
454 *ginv *= gprime;
455 AliAlignObj::ELayerID layerId; // unique identity for volume in the alobj
456 Int_t modId; // unique identity for volume in the alobj
457 GetVolUID(layerId, modId);
458 AliInfo(Form("Aligning volume %s of detector layer %d with local ID %d",volpath,layerId,modId));
459 node->Align(ginv);
460
461 return kTRUE;
462}
463
464//_____________________________________________________________________________
465Bool_t AliAlignObj::GetFromGeometry(const char *path, AliAlignObj &alobj)
466{
467 // Get the alignment object which correspond
468 // to the TGeo volume defined by the 'path'.
469 // The method is extremely slow due to the
470 // searching by string. Therefore it should
471 // be used with great care!!
472
473 // Reset the alignment object
474 alobj.SetPars(0,0,0,0,0,0);
475 alobj.SetVolPath(path);
476
477 if (!gGeoManager || !gGeoManager->IsClosed()) {
478 AliErrorClass("Can't get the alignment object! gGeoManager doesn't exist or it is still opened!");
479 return kFALSE;
480 }
481
482 if (!gGeoManager->GetListOfPhysicalNodes()) {
483 AliErrorClass("Can't get the alignment object! gGeoManager doesn't contain any aligned nodes!");
484 return kFALSE;
485 }
486
487 TObjArray* nodesArr = gGeoManager->GetListOfPhysicalNodes();
488 TGeoPhysicalNode* node = NULL;
489 for (Int_t iNode = 0; iNode < nodesArr->GetEntriesFast(); iNode++) {
490 node = (TGeoPhysicalNode*) nodesArr->UncheckedAt(iNode);
491 const char *nodePath = node->GetName();
492 if (strcmp(path,nodePath) == 0) break;
493 }
494 if (!node) {
e1c4b551 495 if (!gGeoManager->cd(path)) {
496 AliErrorClass(Form("Volume path %s not found!",path));
497 return kFALSE;
498 }
499 else {
500 AliWarningClass(Form("Volume (%s) has not been misaligned!",path));
501 return kTRUE;
502 }
995ad051 503 }
504
505 TGeoHMatrix align,gprime,g,ginv,l;
506 gprime = *node->GetMatrix();
507 l = *node->GetOriginalMatrix();
508 g = *node->GetMatrix(node->GetLevel()-1);
509 g *= l;
510 ginv = g.Inverse();
511 align = gprime * ginv;
512 alobj.SetMatrix(align);
513
514 return kTRUE;
515}
516
c5304981 517void AliAlignObj::InitAlignObjFromGeometry()
518{
519 // Loop over all alignable volumes and extract
520 // the corresponding alignment objects from
521 // the TGeo geometry
25b4e81e 522
523 if(fgAlignObjs[0]) return;
c5304981 524
525 InitVolPaths();
526
c041444f 527 for (Int_t iLayer = kFirstLayer; iLayer < AliAlignObj::kLastLayer; iLayer++) {
528 fgAlignObjs[iLayer-kFirstLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer)];
c5304981 529 for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
c041444f 530 UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
531 fgAlignObjs[iLayer-kFirstLayer][iModule] = new AliAlignObjAngles("",volid,0,0,0,0,0,0);
c5304981 532 const char *path = GetVolPath(volid);
c041444f 533 if (!GetFromGeometry(path, *fgAlignObjs[iLayer-kFirstLayer][iModule]))
c5304981 534 AliErrorClass(Form("Failed to extract the alignment object for the volume (ID=%d and path=%s) !",volid,path));
535 }
536 }
537
538}
539
540//_____________________________________________________________________________
541AliAlignObj* AliAlignObj::GetAlignObj(ELayerID layerId, Int_t modId)
542{
543 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
544 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
545 return NULL;
546 }
547 return fgAlignObjs[layerId-kFirstLayer][modId];
548}
549
e7570944 550//_____________________________________________________________________________
551const char* AliAlignObj::GetVolPath(ELayerID layerId, Int_t modId)
552{
553 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
554 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
555 return NULL;
556 }
557 return fgVolPath[layerId-kFirstLayer][modId].Data();
558}
559
03b18860 560//_____________________________________________________________________________
561void AliAlignObj::InitVolPaths()
562{
563 // Initialize the LUTs which contain
564 // the TGeo volume paths for each
565 // alignable volume. The LUTs are
566 // static, so they are created during
567 // the creation of the first intance
568 // of AliAlignObj
569
570 if (fgVolPath[0]) return;
571
572 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++)
7604a026 573 fgVolPath[iLayer] = new TString[fgLayerSize[iLayer]];
03b18860 574
575 /********************* SPD layer1 ***********************/
576 {
577 Int_t modnum = 0;
578 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT12_1/I12B_"; //".../I12A_"
579 TString str1 = "/I10B_"; //"/I10A_";
580 TString str2 = "/I107_"; //"/I103_"
995ad051 581 // TString str3 = "/I101_1/ITS1_1";
03b18860 582 TString volpath, volpath1, volpath2;
583
584 for(Int_t c1 = 1; c1<=10; c1++){
585 volpath = str0;
586 volpath += c1;
587 volpath += str1;
588 for(Int_t c2 =1; c2<=2; c2++){
589 volpath1 = volpath;
590 volpath1 += c2;
591 volpath1 += str2;
592 for(Int_t c3 =1; c3<=4; c3++){
593 volpath2 = volpath1;
594 volpath2 += c3;
995ad051 595 // volpath2 += str3;
03b18860 596 fgVolPath[kSPD1-kFirstLayer][modnum] = volpath2.Data();
597 modnum++;
598 }
599 }
600 }
601 }
602
603 /********************* SPD layer2 ***********************/
604 {
605 Int_t modnum = 0;
606 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT12_1/I12B_"; //".../I12A_"
607 TString str1 = "/I20B_"; //"/I20A"
608 TString str2 = "/I1D7_"; //"/I1D3"
995ad051 609 // TString str3 = "/I1D1_1/ITS2_1";
03b18860 610 TString volpath, volpath1, volpath2;
611
612 for(Int_t c1 = 1; c1<=10; c1++){
613 volpath = str0;
614 volpath += c1;
615 volpath += str1;
616 for(Int_t c2 =1; c2<=4; c2++){
617 volpath1 = volpath;
618 volpath1 += c2;
619 volpath1 += str2;
620 for(Int_t c3 =1; c3<=4; c3++){
621 volpath2 = volpath1;
622 volpath2 += c3;
995ad051 623 // volpath2 += str3;
03b18860 624 fgVolPath[kSPD2-kFirstLayer][modnum] = volpath2.Data();
625 modnum++;
626 }
627 }
628 }
629 }
630
631 /********************* SDD layer1 ***********************/
632 {
633 Int_t modnum=0;
634 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I004_";
635 TString str1 = "/I302_";
995ad051 636 // TString str2 = "/ITS3_1";
03b18860 637 TString volpath, volpath1;
638
639 for(Int_t c1 = 1; c1<=14; c1++){
640 volpath = str0;
641 volpath += c1;
642 volpath += str1;
643 for(Int_t c2 =1; c2<=6; c2++){
644 volpath1 = volpath;
645 volpath1 += c2;
995ad051 646 // volpath1 += str2;
03b18860 647 fgVolPath[kSDD1-kFirstLayer][modnum] = volpath1.Data();
648 modnum++;
649 }
650 }
651 }
652
653 /********************* SDD layer2 ***********************/
654 {
655 Int_t modnum=0;
656 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I005_";
657 TString str1 = "/I402_";
995ad051 658 // TString str2 = "/ITS4_1";
03b18860 659 TString volpath, volpath1;
660
661 for(Int_t c1 = 1; c1<=22; c1++){
662 volpath = str0;
663 volpath += c1;
664 volpath += str1;
665 for(Int_t c2 = 1; c2<=8; c2++){
666 volpath1 = volpath;
667 volpath1 += c2;
995ad051 668 // volpath1 += str2;
03b18860 669 fgVolPath[kSDD2-kFirstLayer][modnum] = volpath1.Data();
670 modnum++;
671 }
672 }
673 }
674
675 /********************* SSD layer1 ***********************/
676 {
677 Int_t modnum=0;
678 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I565_";
679 TString str1 = "/I562_";
995ad051 680 // TString str2 = "/ITS5_1";
03b18860 681 TString volpath, volpath1;
682
683 for(Int_t c1 = 1; c1<=34; c1++){
684 volpath = str0;
685 volpath += c1;
686 volpath += str1;
687 for(Int_t c2 = 1; c2<=22; c2++){
688 volpath1 = volpath;
689 volpath1 += c2;
995ad051 690 // volpath1 += str2;
03b18860 691 fgVolPath[kSSD1-kFirstLayer][modnum] = volpath1.Data();
692 modnum++;
693 }
694 }
695 }
696
697 /********************* SSD layer1 ***********************/
698 {
699 Int_t modnum=0;
700 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I569_";
701 TString str1 = "/I566_";
995ad051 702 // TString str2 = "/ITS6_1";
03b18860 703 TString volpath, volpath1;
704
705 for(Int_t c1 = 1; c1<=38; c1++){
706 volpath = str0;
707 volpath += c1;
708 volpath += str1;
709 for(Int_t c2 = 1; c2<=25; c2++){
710 volpath1 = volpath;
711 volpath1 += c2;
995ad051 712 // volpath1 += str2;
03b18860 713 fgVolPath[kSSD2-kFirstLayer][modnum] = volpath1.Data();
714 modnum++;
715 }
716 }
717 }
718
e7570944 719 /*************** TPC inner chambers' layer ****************/
720 {
721 Int_t modnum = 0;
722 TString str1 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_1/TPC_SECT_";
723 TString str2 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_2/TPC_SECT_";
724 TString str_in = "/TPC_IROC_1";
725 TString volpath;
726
727 for(Int_t cnt=1; cnt<=18; cnt++){
728 volpath = str1;
729 volpath += cnt;
730 volpath += str_in;
731 fgVolPath[kTPC1-kFirstLayer][modnum] = volpath.Data();
732 modnum++;
733 }
734 for(Int_t cnt=1; cnt<=18; cnt++){
735 volpath = str2;
736 volpath += cnt;
737 volpath += str_in;
738 fgVolPath[kTPC1-kFirstLayer][modnum] = volpath.Data();
739 modnum++;
740 }
741 }
742
743 /*************** TPC outer chambers' layer ****************/
744 {
745 Int_t modnum = 0;
746 TString str1 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_1/TPC_SECT_";
747 TString str2 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_2/TPC_SECT_";
748 TString str_out = "/TPC_OROC_1";
749 TString volpath;
750
751 for(Int_t cnt=1; cnt<=18; cnt++){
752 volpath = str1;
753 volpath += cnt;
754 volpath += str_out;
755 fgVolPath[kTPC2-kFirstLayer][modnum] = volpath.Data();
756 modnum++;
757 }
758 for(Int_t cnt=1; cnt<=18; cnt++){
759 volpath = str2;
760 volpath += cnt;
761 volpath += str_out;
762 fgVolPath[kTPC2-kFirstLayer][modnum] = volpath.Data();
763 modnum++;
764 }
765 }
766
9abb5d7b 767 /********************* TOF layer ***********************/
768 {
769 Int_t nstrA=15;
770 Int_t nstrB=19;
da027ef2 771 Int_t nstrC=19;
772 Int_t nsec=18;
9abb5d7b 773 Int_t nStripSec=nstrA+2*nstrB+2*nstrC;
da027ef2 774 Int_t nStrip=nStripSec*nsec;
9abb5d7b 775
da027ef2 776 for (Int_t modnum=0; modnum < nStrip; modnum++) {
9abb5d7b 777
778 Int_t sector = modnum/nStripSec;
9abb5d7b 779 Char_t string1[100];
780 Char_t string2[100];
781
782 Int_t icopy=-1;
38b3a170 783
784 if(sector<3){
9abb5d7b 785 icopy=sector+1;
da027ef2 786 sprintf(string1,"/ALIC_1/B077_1/B075_%i/BTO3_1/FTOA_0/FLTA_0",icopy);
9abb5d7b 787 }
788 else if(sector<11){
da027ef2 789 icopy=sector+3;
790 sprintf(string1,"/ALIC_1/B077_1/B071_%i/BTO1_1/FTOA_0/FLTA_0",icopy);
9abb5d7b 791 }
792 else if(sector==11 || sector==12){
793 icopy=sector-10;
da027ef2 794 sprintf(string1,"/ALIC_1/B077_1/B074_%i/BTO2_1/FTOA_0/FLTA_0",icopy);
9abb5d7b 795 }
796 else {
da027ef2 797 icopy=sector-12;
798 sprintf(string1,"/ALIC_1/B077_1/B071_%i/BTO1_1/FTOA_0/FLTA_0",icopy);
9abb5d7b 799 }
da027ef2 800
9abb5d7b 801 Int_t strInSec=modnum%nStripSec;
da027ef2 802 icopy= strInSec;
803 icopy++;
804 sprintf(string2,"FSTR_%i",icopy);
9abb5d7b 805 Char_t path[100];
806 sprintf(path,"%s/%s",string1,string2);
807 // printf("%d %s\n",modnum,path);
808 fgVolPath[kTOF-kFirstLayer][modnum] = path;
809 }
810 }
c8874495 811
812 /********************* RICH layer ***********************/
813 {
814 TString str = "ALIC_1/RICH_";
815 TString volpath;
816
817 for (Int_t modnum=0; modnum < 7; modnum++) {
818 volpath = str;
819 volpath += (modnum+1);
820 fgVolPath[kRICH-kFirstLayer][modnum] = volpath.Data();
821 }
822 }
274fcc1a 823
824 /********************* TRD layers 0-6 *******************/
825 {
a1a23a88 826 TString strSM[18]={"ALIC_1/B077_1/B075_1/BTR3_1/UTR1_3/UTS1_1/UTI1_1/UT",
827 "ALIC_1/B077_1/B075_2/BTR3_1/UTR1_3/UTS1_1/UTI1_1/UT",
828 "ALIC_1/B077_1/B075_3/BTR3_1/UTR1_3/UTS1_1/UTI1_1/UT",
829 "ALIC_1/B077_1/B071_6/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
830 "ALIC_1/B077_1/B071_7/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
831 "ALIC_1/B077_1/B071_8/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
832 "ALIC_1/B077_1/B071_9/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
833 "ALIC_1/B077_1/B071_10/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
834 "ALIC_1/B077_1/B071_11/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
835 "ALIC_1/B077_1/B071_12/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
836 "ALIC_1/B077_1/B071_13/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
837 "ALIC_1/B077_1/B074_1/BTR2_1/UTR1_2/UTS1_1/UTI1_1/UT",
838 "ALIC_1/B077_1/B074_2/BTR2_1/UTR1_2/UTS1_1/UTI1_1/UT",
839 "ALIC_1/B077_1/B071_1/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
840 "ALIC_1/B077_1/B071_2/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
841 "ALIC_1/B077_1/B071_3/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
842 "ALIC_1/B077_1/B071_4/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
843 "ALIC_1/B077_1/B071_5/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT"};
274fcc1a 844 TString strPost = "_1";
a1a23a88 845 TString zeroStr = "0";
274fcc1a 846 TString volpath;
a1a23a88 847
274fcc1a 848 Int_t TRDlayId[6] = {kTRD1, kTRD2, kTRD3, kTRD4, kTRD5, kTRD6};
849
a1a23a88 850 for(Int_t layer=0; layer<6; layer++){
851 Int_t modnum=0;
852 for(Int_t sm = 0; sm < 18; sm++){
853 for(Int_t stacknum = 0; stacknum < 5; stacknum++){
854 Int_t chnum = layer + stacknum*6;
274fcc1a 855 volpath = strSM[sm];
a1a23a88 856 if(chnum<10) volpath += zeroStr;
274fcc1a 857 volpath += chnum;
858 volpath += strPost;
859 fgVolPath[TRDlayId[layer]-kFirstLayer][modnum] = volpath.Data();
860 modnum++;
861 }
862 }
863 }
864 }
865
03b18860 866}