1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
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 *****************************************************************************/
32 #include <TGeoManager.h>
33 #include <TGeoPhysicalNode.h>
35 #include "AliAlignObj.h"
36 #include "AliTrackPointArray.h"
38 #include "AliAlignObjAngles.h"
42 Int_t AliAlignObj::fgLayerSize[kLastLayer - kFirstLayer] = {
47 90, 90, 90, 90, 90, 90, // TRD
54 const 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",
67 TString* AliAlignObj::fgVolPath[kLastLayer - kFirstLayer] = {
80 AliAlignObj** AliAlignObj::fgAlignObjs[kLastLayer - kFirstLayer] = {
93 //_____________________________________________________________________________
94 AliAlignObj::AliAlignObj():
97 // default constructor
101 //_____________________________________________________________________________
102 AliAlignObj::AliAlignObj(const char* volpath, UShort_t voluid) : TObject()
104 // standard constructor
110 AliAlignObj::AliAlignObj(const char* volpath, ELayerID detId, Int_t volId) : TObject()
112 // standard constructor
115 SetVolUID(detId,volId);
118 //_____________________________________________________________________________
119 AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
123 fVolPath = theAlignObj.GetVolPath();
124 fVolUID = theAlignObj.GetVolUID();
127 //_____________________________________________________________________________
128 AliAlignObj &AliAlignObj::operator =(const AliAlignObj& theAlignObj)
130 // assignment operator
131 if(this==&theAlignObj) return *this;
132 fVolPath = theAlignObj.GetVolPath();
133 fVolUID = theAlignObj.GetVolUID();
137 //_____________________________________________________________________________
138 AliAlignObj &AliAlignObj::operator*=(const AliAlignObj& theAlignObj)
140 // multiplication operator
141 // The operator can be used to 'combine'
142 // two alignment objects
146 theAlignObj.GetMatrix(m2);
147 m1.MultiplyLeft(&m2);
152 //_____________________________________________________________________________
153 AliAlignObj::~AliAlignObj()
158 //_____________________________________________________________________________
159 void AliAlignObj::SetVolUID(ELayerID detId, Int_t modId)
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).
166 fVolUID = LayerToVolUID(detId,modId);
169 //_____________________________________________________________________________
170 void AliAlignObj::GetVolUID(ELayerID &layerId, Int_t &modId) const
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).
177 layerId = VolUIDToLayer(fVolUID,modId);
180 //_____________________________________________________________________________
181 Int_t AliAlignObj::GetLevel() const
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);
190 //_____________________________________________________________________________
191 Int_t AliAlignObj::Compare(const TObject *obj) const
193 // Compare the levels of two
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();
203 return ((level > level2) ? 1 : -1);
206 //_____________________________________________________________________________
207 void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
209 // Calculates the rotation matrix using the
210 // Euler angles in "x y z" notation
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]);
219 rot[0] = costhe*cosphi;
220 rot[1] = -costhe*sinphi;
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;
230 //_____________________________________________________________________________
231 Bool_t AliAlignObj::MatrixToAngles(const Double_t *rot, Double_t *angles) const
233 // Calculates the Euler angles in "x y z" notation
234 // using the rotation matrix
235 if(TMath::Abs(rot[0])<1e-7 || TMath::Abs(rot[8])<1e-7) return kFALSE;
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]);
243 //______________________________________________________________________________
244 void AliAlignObj::Transform(AliTrackPoint &p) const
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
251 if (fVolUID != p.GetVolumeID())
252 AliWarning(Form("Alignment object ID is not equal to the space-point ID (%d != %d)",fVolUID,p.GetVolumeID()));
256 Double_t *rot = m.GetRotationMatrix();
257 Double_t *tr = m.GetTranslation();
259 Float_t xyzin[3],xyzout[3];
261 for (Int_t i = 0; i < 3; i++)
270 //______________________________________________________________________________
271 void AliAlignObj::Transform(AliTrackPointArray &array) const
274 for (Int_t i = 0; i < array.GetNPoints(); i++) {
277 array.AddPoint(i,&p);
281 //_____________________________________________________________________________
282 void AliAlignObj::Print(Option_t *) const
284 // Print the contents of the
285 // alignment object in angles and
286 // matrix representations
293 const Double_t *rot = m.GetRotationMatrix();
294 // printf("Volume=%s ID=%u\n", GetVolPath(),GetVolUID());
297 GetVolUID(layerId,modId);
298 printf("Volume=%s LayerID=%d ModuleID=%d\n", GetVolPath(),layerId,modId);
299 printf("%12.6f%12.6f%12.6f Tx = %12.6f Psi = %12.6f\n", rot[0], rot[1], rot[2], tr[0], angles[0]);
300 printf("%12.6f%12.6f%12.6f Ty = %12.6f Theta = %12.6f\n", rot[3], rot[4], rot[5], tr[1], angles[1]);
301 printf("%12.6f%12.6f%12.6f Tz = %12.6f Phi = %12.6f\n", rot[6], rot[7], rot[8], tr[2], angles[2]);
305 //_____________________________________________________________________________
306 UShort_t AliAlignObj::LayerToVolUID(ELayerID layerId, Int_t modId)
308 // From detector (layer) name and module number (according to detector numbering)
309 // build fVolUID, unique numerical identity of that volume inside ALICE
310 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
311 // remaining 11 for module ID inside det (2048 possible values).
313 return ((UShort_t(layerId) << 11) | UShort_t(modId));
316 //_____________________________________________________________________________
317 UShort_t AliAlignObj::LayerToVolUID(Int_t layerId, Int_t modId)
319 // From detector (layer) index and module number (according to detector numbering)
320 // build fVolUID, unique numerical identity of that volume inside ALICE
321 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
322 // remaining 11 for module ID inside det (2048 possible values).
324 return ((UShort_t(layerId) << 11) | UShort_t(modId));
327 //_____________________________________________________________________________
328 AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid, Int_t &modId)
330 // From detector (layer) name and module number (according to detector numbering)
331 // build fVolUID, unique numerical identity of that volume inside ALICE
332 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
333 // remaining 11 for module ID inside det (2048 possible values).
335 modId = voluid & 0x7ff;
337 return VolUIDToLayer(voluid);
340 //_____________________________________________________________________________
341 AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid)
343 // From detector (layer) name and module number (according to detector numbering)
344 // build fVolUID, unique numerical identity of that volume inside ALICE
345 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
346 // remaining 11 for module ID inside det (2048 possible values).
348 return ELayerID((voluid >> 11) & 0x1f);
351 //_____________________________________________________________________________
352 Bool_t AliAlignObj::SetLocalPars(Double_t x, Double_t y, Double_t z,
353 Double_t psi, Double_t theta, Double_t phi)
355 // Set the translations and angles by using parameters
356 // defined in the local (in TGeo means) coordinate system
357 // of the alignable volume. In case that the TGeo was
358 // initialized, returns false and the object parameters are
360 if (!gGeoManager || !gGeoManager->IsClosed()) {
361 AliError("Can't set the alignment object parameters! gGeoManager doesn't exist or it is still opened!");
365 const char* volpath = GetVolPath();
366 TGeoPhysicalNode* node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(volpath);
368 AliError(Form("Volume path %s not valid!",volpath));
371 if (node->IsAligned())
372 AliWarning(Form("Volume %s has been already misaligned!",volpath));
376 tr[0]=x; tr[1]=y; tr[2]=z;
377 m.SetTranslation(tr);
378 Double_t angles[3] = {psi, theta, phi};
380 AnglesToMatrix(angles,rot);
383 TGeoHMatrix align,gprime,gprimeinv;
384 gprime = *node->GetMatrix();
385 gprimeinv = gprime.Inverse();
386 m.Multiply(&gprimeinv);
387 m.MultiplyLeft(&gprime);
394 //_____________________________________________________________________________
395 Bool_t AliAlignObj::ApplyToGeometry()
397 // Apply the current alignment object
398 // to the TGeo geometry
400 if (!gGeoManager || !gGeoManager->IsClosed()) {
401 AliError("Can't apply the alignment object! gGeoManager doesn't exist or it is still opened!");
405 const char* volpath = GetVolPath();
406 TGeoPhysicalNode* node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(volpath);
408 AliError(Form("Volume path %s not valid!",volpath));
411 if (node->IsAligned()) {
412 AliWarning(Form("Volume %s has been already misaligned!",volpath));
416 TGeoHMatrix align,gprime;
417 gprime = *node->GetMatrix();
419 gprime.MultiplyLeft(&align);
420 TGeoHMatrix *ginv = new TGeoHMatrix;
421 TGeoHMatrix *g = node->GetMatrix(node->GetLevel()-1);
422 *ginv = g->Inverse();
424 AliAlignObj::ELayerID layerId; // unique identity for volume in the alobj
425 Int_t modId; // unique identity for volume in the alobj
426 GetVolUID(layerId, modId);
427 AliInfo(Form("Aligning volume %s of detector layer %d with local ID %d",volpath,layerId,modId));
433 //_____________________________________________________________________________
434 Bool_t AliAlignObj::GetFromGeometry(const char *path, AliAlignObj &alobj)
436 // Get the alignment object which correspond
437 // to the TGeo volume defined by the 'path'.
438 // The method is extremely slow due to the
439 // searching by string. Therefore it should
440 // be used with great care!!
442 // Reset the alignment object
443 alobj.SetPars(0,0,0,0,0,0);
444 alobj.SetVolPath(path);
446 if (!gGeoManager || !gGeoManager->IsClosed()) {
447 AliErrorClass("Can't get the alignment object! gGeoManager doesn't exist or it is still opened!");
451 if (!gGeoManager->GetListOfPhysicalNodes()) {
452 AliErrorClass("Can't get the alignment object! gGeoManager doesn't contain any aligned nodes!");
456 TObjArray* nodesArr = gGeoManager->GetListOfPhysicalNodes();
457 TGeoPhysicalNode* node = NULL;
458 for (Int_t iNode = 0; iNode < nodesArr->GetEntriesFast(); iNode++) {
459 node = (TGeoPhysicalNode*) nodesArr->UncheckedAt(iNode);
460 const char *nodePath = node->GetName();
461 if (strcmp(path,nodePath) == 0) break;
464 if (!gGeoManager->cd(path)) {
465 AliErrorClass(Form("Volume path %s not found!",path));
469 AliWarningClass(Form("Volume (%s) has not been misaligned!",path));
474 TGeoHMatrix align,gprime,g,ginv,l;
475 gprime = *node->GetMatrix();
476 l = *node->GetOriginalMatrix();
477 g = *node->GetMatrix(node->GetLevel()-1);
480 align = gprime * ginv;
481 alobj.SetMatrix(align);
486 void AliAlignObj::InitAlignObjFromGeometry()
488 // Loop over all alignable volumes and extract
489 // the corresponding alignment objects from
492 if(fgAlignObjs[0]) return;
496 for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
497 fgAlignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer)];
498 for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
499 UShort_t volid = AliAlignObj::LayerToVolUID(iLayer+ AliAlignObj::kFirstLayer,iModule);
500 fgAlignObjs[iLayer][iModule] = new AliAlignObjAngles("",volid,0,0,0,0,0,0);
501 const char *path = GetVolPath(volid);
502 if (!GetFromGeometry(path, *fgAlignObjs[iLayer][iModule]))
503 AliErrorClass(Form("Failed to extract the alignment object for the volume (ID=%d and path=%s) !",volid,path));
509 //_____________________________________________________________________________
510 AliAlignObj* AliAlignObj::GetAlignObj(ELayerID layerId, Int_t modId)
512 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
513 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
516 return fgAlignObjs[layerId-kFirstLayer][modId];
519 //_____________________________________________________________________________
520 const char* AliAlignObj::GetVolPath(ELayerID layerId, Int_t modId)
522 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
523 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
526 return fgVolPath[layerId-kFirstLayer][modId].Data();
529 //_____________________________________________________________________________
530 void AliAlignObj::InitVolPaths()
532 // Initialize the LUTs which contain
533 // the TGeo volume paths for each
534 // alignable volume. The LUTs are
535 // static, so they are created during
536 // the creation of the first intance
539 if (fgVolPath[0]) return;
541 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++)
542 fgVolPath[iLayer] = new TString[fgLayerSize[iLayer]];
544 /********************* SPD layer1 ***********************/
547 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT12_1/I12B_"; //".../I12A_"
548 TString str1 = "/I10B_"; //"/I10A_";
549 TString str2 = "/I107_"; //"/I103_"
550 // TString str3 = "/I101_1/ITS1_1";
551 TString volpath, volpath1, volpath2;
553 for(Int_t c1 = 1; c1<=10; c1++){
557 for(Int_t c2 =1; c2<=2; c2++){
561 for(Int_t c3 =1; c3<=4; c3++){
565 fgVolPath[kSPD1-kFirstLayer][modnum] = volpath2.Data();
572 /********************* SPD layer2 ***********************/
575 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT12_1/I12B_"; //".../I12A_"
576 TString str1 = "/I20B_"; //"/I20A"
577 TString str2 = "/I1D7_"; //"/I1D3"
578 // TString str3 = "/I1D1_1/ITS2_1";
579 TString volpath, volpath1, volpath2;
581 for(Int_t c1 = 1; c1<=10; c1++){
585 for(Int_t c2 =1; c2<=4; c2++){
589 for(Int_t c3 =1; c3<=4; c3++){
593 fgVolPath[kSPD2-kFirstLayer][modnum] = volpath2.Data();
600 /********************* SDD layer1 ***********************/
603 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I004_";
604 TString str1 = "/I302_";
605 // TString str2 = "/ITS3_1";
606 TString volpath, volpath1;
608 for(Int_t c1 = 1; c1<=14; c1++){
612 for(Int_t c2 =1; c2<=6; c2++){
616 fgVolPath[kSDD1-kFirstLayer][modnum] = volpath1.Data();
622 /********************* SDD layer2 ***********************/
625 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I005_";
626 TString str1 = "/I402_";
627 // TString str2 = "/ITS4_1";
628 TString volpath, volpath1;
630 for(Int_t c1 = 1; c1<=22; c1++){
634 for(Int_t c2 = 1; c2<=8; c2++){
638 fgVolPath[kSDD2-kFirstLayer][modnum] = volpath1.Data();
644 /********************* SSD layer1 ***********************/
647 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I565_";
648 TString str1 = "/I562_";
649 // TString str2 = "/ITS5_1";
650 TString volpath, volpath1;
652 for(Int_t c1 = 1; c1<=34; c1++){
656 for(Int_t c2 = 1; c2<=22; c2++){
660 fgVolPath[kSSD1-kFirstLayer][modnum] = volpath1.Data();
666 /********************* SSD layer1 ***********************/
669 TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I569_";
670 TString str1 = "/I566_";
671 // TString str2 = "/ITS6_1";
672 TString volpath, volpath1;
674 for(Int_t c1 = 1; c1<=38; c1++){
678 for(Int_t c2 = 1; c2<=25; c2++){
682 fgVolPath[kSSD2-kFirstLayer][modnum] = volpath1.Data();
688 /*************** TPC inner chambers' layer ****************/
691 TString str1 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_1/TPC_SECT_";
692 TString str2 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_2/TPC_SECT_";
693 TString str_in = "/TPC_IROC_1";
696 for(Int_t cnt=1; cnt<=18; cnt++){
700 fgVolPath[kTPC1-kFirstLayer][modnum] = volpath.Data();
703 for(Int_t cnt=1; cnt<=18; cnt++){
707 fgVolPath[kTPC1-kFirstLayer][modnum] = volpath.Data();
712 /*************** TPC outer chambers' layer ****************/
715 TString str1 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_1/TPC_SECT_";
716 TString str2 = "ALIC_1/TPC_M_1/TPC_Drift_1/TPC_ENDCAP_2/TPC_SECT_";
717 TString str_out = "/TPC_OROC_1";
720 for(Int_t cnt=1; cnt<=18; cnt++){
724 fgVolPath[kTPC2-kFirstLayer][modnum] = volpath.Data();
727 for(Int_t cnt=1; cnt<=18; cnt++){
731 fgVolPath[kTPC2-kFirstLayer][modnum] = volpath.Data();
736 /********************* TOF layer ***********************/
742 Int_t nStripSec=nstrA+2*nstrB+2*nstrC;
743 Int_t nStrip=nStripSec*nsec;
745 for (Int_t modnum=0; modnum < nStrip; modnum++) {
747 Int_t sector = modnum/nStripSec;
755 sprintf(string1,"/ALIC_1/B077_1/B075_%i/BTO3_1/FTOA_0/FLTA_0",icopy);
759 sprintf(string1,"/ALIC_1/B077_1/B071_%i/BTO1_1/FTOA_0/FLTA_0",icopy);
761 else if(sector==11 || sector==12){
763 sprintf(string1,"/ALIC_1/B077_1/B074_%i/BTO2_1/FTOA_0/FLTA_0",icopy);
767 sprintf(string1,"/ALIC_1/B077_1/B071_%i/BTO1_1/FTOA_0/FLTA_0",icopy);
770 Int_t strInSec=modnum%nStripSec;
773 sprintf(string2,"FSTR_%i",icopy);
775 sprintf(path,"%s/%s",string1,string2);
776 // printf("%d %s\n",modnum,path);
777 fgVolPath[kTOF-kFirstLayer][modnum] = path;
781 /********************* RICH layer ***********************/
783 TString str = "ALIC_1/RICH_";
786 for (Int_t modnum=0; modnum < 7; modnum++) {
788 volpath += (modnum+1);
789 fgVolPath[kRICH-kFirstLayer][modnum] = volpath.Data();
793 /********************* TRD layers 0-6 *******************/
795 TString strSM[18]={"ALIC_1/B077_1/B075_1/BTR3_1/UTR3_3/UTS3_3/UTI3_3/UT",
796 "ALIC_1/B077_1/B075_2/BTR3_1/UTR3_3/UTS3_3/UTI3_3/UT",
797 "ALIC_1/B077_1/B075_3/BTR3_1/UTR3_3/UTS3_3/UTI3_3/UT",
798 "ALIC_1/B077_1/B071_6/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
799 "ALIC_1/B077_1/B071_7/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
800 "ALIC_1/B077_1/B071_8/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
801 "ALIC_1/B077_1/B071_9/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
802 "ALIC_1/B077_1/B071_10/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
803 "ALIC_1/B077_1/B071_11/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
804 "ALIC_1/B077_1/B071_12/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
805 "ALIC_1/B077_1/B071_13/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
806 "ALIC_1/B077_1/B074_1/BTR2_1/UTR2_2/UTS2_2/UTI2_2/UT",
807 "ALIC_1/B077_1/B074_2/BTR2_1/UTR2_2/UTS2_2/UTI2_2/UT",
808 "ALIC_1/B077_1/B071_1/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
809 "ALIC_1/B077_1/B071_2/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
810 "ALIC_1/B077_1/B071_3/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
811 "ALIC_1/B077_1/B071_4/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT",
812 "ALIC_1/B077_1/B071_5/BTR1_1/UTR1_1/UTS1_1/UTI1_1/UT"};
813 Int_t start[18] = {60,60,60,0,0,0,0,0,0,0,0,30,30,0,0,0,0,0};
814 TString strPost = "_1";
815 TString ZeroStr = "0";
817 Int_t layer, sm, stacknum, chnum, modnum;
819 Int_t TRDlayId[6] = {kTRD1, kTRD2, kTRD3, kTRD4, kTRD5, kTRD6};
821 for(layer=0; layer<6; layer++){
823 for(sm = 0; sm<18; sm++){
824 for(stacknum = 0; stacknum<5; stacknum++){
825 chnum = start[sm] + layer + stacknum*6;
827 if(chnum<10) volpath += ZeroStr;
830 fgVolPath[TRDlayId[layer]-kFirstLayer][modnum] = volpath.Data();