Fixed typo
[u/mrichter/AliRoot.git] / STEER / AliGeomManager.cxx
CommitLineData
67dd5535 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// Implementation of AliGeomManager, the geometry manager class
17// which interfaces to TGeo and the look-up table mapping unique
18// volume indices to symbolic volume names. For that it collects
19// several static methods.
20//-------------------------------------------------------------------------
21
22#include <TClass.h>
23#include <TFile.h>
24#include <TGeoManager.h>
25#include <TObjString.h>
26#include <TGeoPhysicalNode.h>
27#include <TClonesArray.h>
28#include <TGeoMatrix.h>
29#include <TGeoPhysicalNode.h>
99de26a3 30#include <TSystem.h>
5590c6c3 31#include <TStopwatch.h>
32#include <TGeoOverlap.h>
33#include <TPluginManager.h>
34#include <TROOT.h>
67dd5535 35
36#include "AliGeomManager.h"
37#include "AliLog.h"
38#include "AliAlignObj.h"
90dbf5fb 39#include "AliAlignObjParams.h"
67dd5535 40#include "AliCDBManager.h"
41#include "AliCDBStorage.h"
42#include "AliCDBEntry.h"
43
44ClassImp(AliGeomManager)
45
46Int_t AliGeomManager::fgLayerSize[kLastLayer - kFirstLayer] = {
47 80, 160, // ITS SPD first and second layer
48 84, 176, // ITS SDD first and second layer
49 748, 950, // ITS SSD first and second layer
50 36, 36, // TPC inner and outer chambers
51 90, 90, 90, 90, 90, 90, // 6 TRD chambers' layers
52 1638, // TOF
df117114 53 5, 5, // PHOS,CPV
67dd5535 54 7, // HMPID ??
3dfc15c0 55 1, // MUON ??
56 12 // EMCAL
67dd5535 57};
58
59const char* AliGeomManager::fgLayerName[kLastLayer - kFirstLayer] = {
60 "ITS inner pixels layer", "ITS outer pixels layer",
61 "ITS inner drifts layer", "ITS outer drifts layer",
62 "ITS inner strips layer", "ITS outer strips layer",
63 "TPC inner chambers layer", "TPC outer chambers layer",
64 "TRD chambers layer 1", "TRD chambers layer 2", "TRD chambers layer 3",
65 "TRD chambers layer 4", "TRD chambers layer 5", "TRD chambers layer 6",
66 "TOF layer",
df117114 67 "PHOS EMC layer","PHOS CPV layer",
3dfc15c0 68 "HMPID layer",
69 "MUON ?",
70 "EMCAL layer"
67dd5535 71};
72
67dd5535 73TGeoPNEntry** AliGeomManager::fgPNEntry[kLastLayer - kFirstLayer] = {
74 0x0,0x0,
75 0x0,0x0,
76 0x0,0x0,
77 0x0,0x0,
78 0x0,0x0,0x0,
79 0x0,0x0,0x0,
80 0x0,
81 0x0,0x0,
82 0x0,
3dfc15c0 83 0x0,
67dd5535 84 0x0
85};
86
36b010bf 87AliAlignObj** AliGeomManager::fgAlignObjs[kLastLayer - kFirstLayer] = {
88 0x0,0x0,
89 0x0,0x0,
90 0x0,0x0,
91 0x0,0x0,
92 0x0,0x0,0x0,
93 0x0,0x0,0x0,
94 0x0,
95 0x0,0x0,
96 0x0,
3dfc15c0 97 0x0,
36b010bf 98 0x0
99};
67dd5535 100
4fbb8e9d 101const char* AliGeomManager::fgkDetectorName[AliGeomManager::fgkNDetectors] = {"GRP","ITS","TPC","TRD","TOF","PHOS","HMPID","EMCAL","MUON","FMD","ZDC","PMD","T0","VZERO","ACORDE"};
102Int_t AliGeomManager::fgNalignable[fgkNDetectors] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
103
104
67dd5535 105TGeoManager* AliGeomManager::fgGeometry = 0x0;
106
107//_____________________________________________________________________________
36b010bf 108void AliGeomManager::LoadGeometry(const char *geomFileName)
67dd5535 109{
9d47e237 110 // initialization
111 // Load geometry either from a file
112 // or from the corresponding CDB entry
67dd5535 113
a9870fe8 114 if(fgGeometry->IsLocked()){
115 AliErrorClass("Cannot load a new geometry, the current one being locked. Setting internal geometry to null!!");
116 fgGeometry = NULL;
117 return;
118 }
119
36b010bf 120 fgGeometry = NULL;
b8cf7791 121 if (geomFileName && (!gSystem->AccessPathName(geomFileName))) {
36b010bf 122 fgGeometry = TGeoManager::Import(geomFileName);
4fbb8e9d 123 AliInfoClass(Form("From now on using geometry from custom geometry file \"%s\"",geomFileName));
36b010bf 124 }
125
126 if (!fgGeometry) {
36b010bf 127 AliCDBPath path("GRP","Geometry","Data");
128
129 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
130 if(!entry) AliFatalClass("Couldn't load geometry data from CDB!");
131
132 entry->SetOwner(0);
133 fgGeometry = (TGeoManager*) entry->GetObject();
134 if (!fgGeometry) AliFatalClass("Couldn't find TGeoManager in the specified CDB entry!");
b8cf7791 135
4fbb8e9d 136 AliInfoClass(Form("From now on using geometry from CDB base folder \"%s\"",
b8cf7791 137 AliCDBManager::Instance()->GetURI("Geometry/Align/Data")));
36b010bf 138 }
3564f2da 139 ResetPNEntriesLUT();
67dd5535 140 InitPNEntriesLUT();
4fbb8e9d 141 InitNalignable();
67dd5535 142}
143
144//_____________________________________________________________________________
53dd673d 145void AliGeomManager::SetGeometry(TGeoManager * const geom)
9d47e237 146{
147 // Load already active geometry
148 if (!geom) AliFatalClass("Pointer to the active geometry is 0x0!");
3564f2da 149 ResetPNEntriesLUT();
9d47e237 150 fgGeometry = geom;
9d47e237 151 InitPNEntriesLUT();
4fbb8e9d 152 InitNalignable();
9d47e237 153}
154
155//_____________________________________________________________________________
67dd5535 156AliGeomManager::AliGeomManager():
36b010bf 157 TObject()
67dd5535 158{
159 // default constructor
160}
161
162//_____________________________________________________________________________
163AliGeomManager::~AliGeomManager()
164{
165 // dummy destructor
67dd5535 166}
167
168//_____________________________________________________________________________
169Int_t AliGeomManager::LayerSize(Int_t layerId)
170{
171 // Get the layer size for layer corresponding to layerId.
172 // Implemented only for ITS,TPC,TRD,TOF and HMPID
173 //
174 if (layerId < kFirstLayer || layerId >= kLastLayer) {
175 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
176 return 0;
177 }
178 else {
179 return fgLayerSize[layerId - kFirstLayer];
5aedd709 180 }
67dd5535 181}
182
183//_____________________________________________________________________________
184const char* AliGeomManager::LayerName(Int_t layerId)
185{
186 // Get the layer name corresponding to layerId.
187 // Implemented only for ITS,TPC,TRD,TOF and HMPID
188 //
189 if (layerId < kFirstLayer || layerId >= kLastLayer) {
190 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
191 return "Invalid Layer!";
192 }
193 else {
194 return fgLayerName[layerId - kFirstLayer];
5aedd709 195 }
67dd5535 196}
197
198//_____________________________________________________________________________
199UShort_t AliGeomManager::LayerToVolUID(ELayerID layerId, Int_t modId)
200{
201 // From detector (layer) name and module number (according to detector
202 // internal numbering) build the unique numerical identity of that volume
203 // inside ALICE
204 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
205 // remaining 11 for module ID inside det (2048 possible values).
206 // NO check for validity of given modId inside the layer for speed's sake.
207 //
208 return ((UShort_t(layerId) << 11) | UShort_t(modId));
209}
210
211//_____________________________________________________________________________
212UShort_t AliGeomManager::LayerToVolUID(Int_t layerId, Int_t modId)
213{
214 // From detector (layer) name and module number (according to detector
215 // internal numbering) build the unique numerical identity of that volume
216 // inside ALICE
217 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
218 // remaining 11 for module ID inside det (2048 possible values).
219 // NO check for validity of given modId inside the layer for speed's sake.
220 //
221 return ((UShort_t(layerId) << 11) | UShort_t(modId));
222}
223
224//_____________________________________________________________________________
225UShort_t AliGeomManager::LayerToVolUIDSafe(ELayerID layerId, Int_t modId)
226{
227 // From detector (layer) name and module number (according to detector
228 // internal numbering) build the unique numerical identity of that volume
229 // inside ALICE
230 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
231 // remaining 11 for module ID inside det (2048 possible values).
232 // Check validity of given modId inside the layer.
233 //
234 if(modId < 0 || modId >= LayerSize(layerId)){
235 AliErrorClass(Form("Invalid volume id %d ! Range of valid ids for layer \"%s\" is [0, %d] !",modId,LayerName(layerId),LayerSize(layerId)-1));
236 return 0;
237 }
238 return ((UShort_t(layerId) << 11) | UShort_t(modId));
239}
240
241//_____________________________________________________________________________
242UShort_t AliGeomManager::LayerToVolUIDSafe(Int_t layerId, Int_t modId)
243{
244 // From detector (layer) name and module number (according to detector
245 // internal numbering) build the unique numerical identity of that volume
246 // inside ALICE
247 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
248 // remaining 11 for module ID inside det (2048 possible values).
249 // Check validity of given modId inside the layer.
250 //
251 if(modId < 0 || modId >= LayerSize(layerId)){
252 AliErrorClass(Form("Invalid volume id %d ! Range of valid ids for layer \"%s\" is [0, %d] !",modId,LayerName(layerId),LayerSize(layerId)-1));
253 return 0;
254 }
255 return ((UShort_t(layerId) << 11) | UShort_t(modId));
256}
257
258//_____________________________________________________________________________
259AliGeomManager::ELayerID AliGeomManager::VolUIDToLayer(UShort_t voluid, Int_t &modId)
260{
261 // From voluid, unique numerical identity of that volume inside ALICE,
262 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
263 // remaining 11 for module ID inside det (2048 possible values)), return
264 // the identity of the layer to which that volume belongs and sets the
265 // argument modId to the identity of that volume internally to the layer.
266 // NO check for validity of given voluid for speed's sake.
267 //
268 modId = voluid & 0x7ff;
269
270 return VolUIDToLayer(voluid);
271}
272
273//_____________________________________________________________________________
274AliGeomManager::ELayerID AliGeomManager::VolUIDToLayer(UShort_t voluid)
275{
276 // From voluid, unique numerical identity of that volume inside ALICE,
277 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
278 // remaining 11 for module ID inside det (2048 possible values)), return
279 // the identity of the layer to which that volume belongs
280 // NO check for validity of given voluid for speed's sake.
281 //
282 return ELayerID(voluid >> 11);
283}
284
285//_____________________________________________________________________________
286AliGeomManager::ELayerID AliGeomManager::VolUIDToLayerSafe(UShort_t voluid, Int_t &modId)
287{
288 // From voluid, unique numerical identity of that volume inside ALICE,
289 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
290 // remaining 11 for module ID inside det (2048 possible values)), returns
291 // the identity of the layer to which that volume belongs and sets the
292 // argument modId to the identity of that volume internally to the layer.
293 // Checks the validity of the given voluid
294 //
295 ELayerID layId = VolUIDToLayerSafe(voluid);
1d059662 296 if(layId != AliGeomManager::kInvalidLayer){
67dd5535 297 Int_t mId = Int_t(voluid & 0x7ff);
298 if( mId>=0 && mId<LayerSize(layId)){
299 modId = mId;
300 return layId;
301 }
302 }
303
304 AliErrorClass(Form("Invalid unique volume id: %d !",voluid));
305 modId = -1;
306 return kInvalidLayer;
307
308}
309
310//_____________________________________________________________________________
311AliGeomManager::ELayerID AliGeomManager::VolUIDToLayerSafe(UShort_t voluid)
312{
313 // From voluid, unique numerical identity of that volume inside ALICE,
314 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
315 // remaining 11 for module ID inside det (2048 possible values)), returns
316 // the identity of the layer to which that volume belongs
317 // Checks the validity of the given voluid
318 //
319 if( (voluid >> 11) < kLastLayer) return ELayerID(voluid >> 11);
320
321 AliErrorClass(Form("Invalid layer id: %d !",(voluid >> 11)));
322 return kInvalidLayer;
323
324}
325
326//_____________________________________________________________________________
327Bool_t AliGeomManager::GetFromGeometry(const char *symname, AliAlignObj &alobj)
328{
329 // Get the alignment object which corresponds to the symbolic volume name
330 // symname (in case equal to the TGeo volume path)
331 // The method is extremely slow due to the searching by string,
332 // therefore it should be used with great care!!
333 // This method returns FALSE if the symname of the object was not
334 // valid neither to get a TGeoPEntry nor as a volume path, or if the path
335 // associated to the TGeoPNEntry was not valid.
336 //
337
338 // Reset the alignment object
339 alobj.SetPars(0,0,0,0,0,0);
340 alobj.SetSymName(symname);
341
36b010bf 342 if (!fgGeometry || !fgGeometry->IsClosed()) {
67dd5535 343 AliErrorClass("Can't get the alignment object! gGeoManager doesn't exist or it is still opened!");
344 return kFALSE;
345 }
346
36b010bf 347 if (!fgGeometry->GetListOfPhysicalNodes()) {
67dd5535 348 AliErrorClass("Can't get the alignment object! gGeoManager doesn't contain any aligned nodes!");
349 return kFALSE;
350 }
351
67dd5535 352 const char *path;
36b010bf 353 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
67dd5535 354 if(pne){
355 path = pne->GetTitle();
356 }else{
357 AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
358 path = symname;
359 }
36b010bf 360 TObjArray* nodesArr = fgGeometry->GetListOfPhysicalNodes();
67dd5535 361 TGeoPhysicalNode* node = NULL;
362 for (Int_t iNode = 0; iNode < nodesArr->GetEntriesFast(); iNode++) {
363 TGeoPhysicalNode* tempNode = (TGeoPhysicalNode*) nodesArr->UncheckedAt(iNode);
364 const char *nodePath = tempNode->GetName();
365 if (strcmp(path,nodePath) == 0) {
366 node = tempNode;
367 break;
368 }
369 }
370
371 if (!node) {
36b010bf 372 if (!fgGeometry->cd(path)) {
67dd5535 373 AliErrorClass(Form("%s not valid neither as symbolic volume name nor as volume path!",path));
374 return kFALSE;
375 }
376 else {
377 AliWarningClass(Form("Volume (%s) has not been misaligned!",path));
378 return kTRUE;
379 }
380 }
381
382 TGeoHMatrix align,gprime,g,ginv,l;
383 gprime = *node->GetMatrix();
384 l = *node->GetOriginalMatrix();
385 g = *node->GetMatrix(node->GetLevel()-1);
386 g *= l;
387 ginv = g.Inverse();
388 align = gprime * ginv;
389
390 return alobj.SetMatrix(align);
391}
392
393
394//_____________________________________________________________________________
395void AliGeomManager::InitAlignObjFromGeometry()
396{
5aedd709 397 // Loop over all alignable volumes and extract
398 // the corresponding alignment objects from
399 // the TGeo geometry
3564f2da 400 //
67dd5535 401 for (Int_t iLayer = kFirstLayer; iLayer < AliGeomManager::kLastLayer; iLayer++) {
3564f2da 402 if (!fgAlignObjs[iLayer-kFirstLayer]) {
403 fgAlignObjs[iLayer-kFirstLayer] = new AliAlignObj*[LayerSize(iLayer)];
3564f2da 404 }
67dd5535 405 for (Int_t iModule = 0; iModule < LayerSize(iLayer); iModule++) {
406 UShort_t volid = LayerToVolUID(iLayer,iModule);
ebb8460f 407 fgAlignObjs[iLayer-kFirstLayer][iModule] = new AliAlignObjParams("",volid,0,0,0,0,0,0,kTRUE);
67dd5535 408 const char *symname = SymName(volid);
409 if (!GetFromGeometry(symname, *fgAlignObjs[iLayer-kFirstLayer][iModule]))
410 AliErrorClass(Form("Failed to extract the alignment object for the volume (ID=%d and path=%s) !",volid,symname));
411 }
412 }
5aedd709 413
67dd5535 414}
415
416//_____________________________________________________________________________
5aedd709 417AliAlignObj* AliGeomManager::GetAlignObj(UShort_t voluid)
418{
67dd5535 419 // Returns the alignment object for given volume ID
420 //
421 Int_t modId;
422 ELayerID layerId = VolUIDToLayer(voluid,modId);
423 return GetAlignObj(layerId,modId);
424}
425
426//_____________________________________________________________________________
427AliAlignObj* AliGeomManager::GetAlignObj(ELayerID layerId, Int_t modId)
428{
429 // Returns pointer to alignment object given its layer and module ID
430 //
431 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
432 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
433 return NULL;
434 }
435 InitAlignObjFromGeometry();
436
437 return fgAlignObjs[layerId-kFirstLayer][modId];
438}
439
440//_____________________________________________________________________________
5aedd709 441const char* AliGeomManager::SymName(UShort_t voluid)
442{
67dd5535 443 // Returns the symbolic volume name for given volume ID
444 //
445 Int_t modId;
446 ELayerID layerId = VolUIDToLayer(voluid,modId);
447 return SymName(layerId,modId);
448}
449
450//_____________________________________________________________________________
451const char* AliGeomManager::SymName(ELayerID layerId, Int_t modId)
452{
453 // Returns the symbolic volume name given for a given layer
454 // and module ID
455 //
ff5970a3 456 if(!fgGeometry){
457 AliErrorClass("No geometry instance loaded yet!");
458 return NULL;
459 }
67dd5535 460 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
461 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
462 return NULL;
463 }
67dd5535 464
a8629c62 465 TGeoPNEntry* pne = fgPNEntry[layerId-kFirstLayer][modId];
466 if(!pne)
467 {
468 AliWarningClass(Form("Module %d of layer %s is not activated!",modId,LayerName(layerId)));
469 return NULL;
470 }
471 return pne->GetName();
472
67dd5535 473}
474
475//_____________________________________________________________________________
9257a1bd 476Bool_t AliGeomManager::CheckSymNamesLUT(const char* /*detsToBeChecked*/)
67dd5535 477{
0bf7aade 478 // Check the look-up table which associates the unique numerical identity of
479 // each alignable volume to the corresponding symbolic volume name.
8e5d5edf 480 // The LUT is now held inside the geometry and handled by TGeo.
0bf7aade 481 // The method is meant to be launched when loading a geometry to verify that
482 // no changes in the symbolic names have been introduced, which would prevent
483 // backward compatibility with alignment objects.
484 // To accept both complete and partial geometry, this method skips the check
485 // for TRD and TOF volumes which are missing in the partial geometry.
486 //
67dd5535 487
ff5970a3 488// TString detsString(detsToBeChecked);
489// if(detsString.Contains("ALL")) detsString="ITS TPC TOF TRD HMPID PHOS EMCAL";
490
491 // Temporary measure to face the case of reconstruction over detectors not present in the geometry
492 TString detsString = "";
493 if(fgGeometry->CheckPath("ALIC_1/ITSV_1")) detsString+="ITS ";
494 if(fgGeometry->CheckPath("ALIC_1/TPC_M_1")) detsString+="TPC ";
83364444 495
496 TString tofsm;
497 TString baseTof("ALIC_1/B077_1/BSEGMO");
498 TString middleTof("_1/BTOF");
499 TString trailTof("_1/FTOA_0");
500 Bool_t tofActive=kFALSE;
501 Bool_t tofSMs[18];
502 for(Int_t sm=0; sm<18; sm++)
503 {
504 tofSMs[sm]=kFALSE;
505 tofsm=baseTof;
506 tofsm += sm;
507 tofsm += middleTof;
508 tofsm += sm;
509 tofsm += trailTof;
510 if(fgGeometry->CheckPath(tofsm.Data()))
511 {
512 tofActive=kTRUE;
513 tofSMs[sm]=kTRUE;
514 }
515 }
516 if(tofActive) detsString+="TOF ";
517
518 TString trdsm;
519 TString baseTrd("ALIC_1/B077_1/BSEGMO");
520 TString middleTrd("_1/BTRD");
521 TString trailTrd("_1/UTR1_1");
522 Bool_t trdActive=kFALSE;
523 Bool_t trdSMs[18];
524 for(Int_t sm=0; sm<18; sm++)
525 {
526 trdSMs[sm]=kFALSE;
527 trdsm=baseTrd;
528 trdsm += sm;
529 trdsm += middleTrd;
530 trdsm += sm;
531 trdsm += trailTrd;
532 if(fgGeometry->CheckPath(trdsm.Data()))
533 {
534 trdActive=kTRUE;
535 trdSMs[sm]=kTRUE;
536 }
537 }
538 if(trdActive) detsString+="TRD ";
539
ff5970a3 540 if(fgGeometry->CheckPath("ALIC_1/Hmp0_0")) detsString+="HMPID ";
6ead0654 541
542 TString phosMod, cpvMod;
543 TString basePhos("ALIC_1/PHOS_");
544 Bool_t phosActive=kFALSE;
545 Bool_t cpvActive=kFALSE;
546 Bool_t phosMods[5];
547 for(Int_t pmod=0; pmod<5; pmod++)
548 {
549 phosMods[pmod]=kFALSE;
550 phosMod = basePhos;
551 phosMod += (pmod+1);
552 cpvMod = phosMod;
553 cpvMod += "/PCPV_1";
554 if(fgGeometry->CheckPath(phosMod.Data()))
555 {
556 phosActive=kTRUE;
557 phosMods[pmod]=kTRUE;
558 if(fgGeometry->CheckPath(cpvMod.Data())) cpvActive=kTRUE;
559 }
560 }
561 if(phosActive) detsString+="PHOS ";
562
8e5d5edf 563 // Check over the ten EMCAL full supermodules and the two EMCAL half supermodules
564 TString emcalSM;
565 TString baseEmcalSM("ALIC_1/XEN1_1/SM");
566 Bool_t emcalActive=kFALSE;
567 Bool_t emcalSMs[12] = {kFALSE};
568 for(Int_t sm=0; sm<12; sm++)
569 {
570 emcalSM=baseEmcalSM;
571 if(sm<10){
572 emcalSM += "OD_";
573 emcalSM += (sm+1);
574 }else{
575 emcalSM += "10_";
576 emcalSM += (sm-9);
577 }
578 if(fgGeometry->CheckPath(emcalSM.Data()))
579 {
580 emcalActive=kTRUE;
581 emcalSMs[sm]=kTRUE;
582 }
583 }
584 if(emcalActive) detsString+="EMCAL ";
585
ff5970a3 586
67dd5535 587 TString symname;
0bf7aade 588 const char* sname;
589 TGeoPNEntry* pne = 0x0;
590 Int_t uid; // global unique identity
591 Int_t modnum; // unique id inside layer; in the following, set it to 0 at the start of each layer
67dd5535 592
ff5970a3 593 if(detsString.Contains("ITS")){
67dd5535 594 /********************* ITS layers ***********************/
ff5970a3 595 AliDebugClass(2,"Checking consistency of symbolic names for ITS layers");
596 TString strSPD = "ITS/SPD";
597 TString strSDD = "ITS/SDD";
598 TString strSSD = "ITS/SSD";
599 TString strStave = "/Stave";
600 TString strHalfStave = "/HalfStave";
601 TString strLadder = "/Ladder";
602 TString strSector = "/Sector";
603 TString strSensor = "/Sensor";
604 TString strEntryName1;
605 TString strEntryName2;
606 TString strEntryName3;
607
608 /********************* SPD layer1 ***********************/
609 {
610 modnum = 0;
611
612 for(Int_t cSect = 0; cSect<10; cSect++){
613 strEntryName1 = strSPD;
614 strEntryName1 += 0;
615 strEntryName1 += strSector;
616 strEntryName1 += cSect;
617
618 for(Int_t cStave =0; cStave<2; cStave++){
619 strEntryName2 = strEntryName1;
620 strEntryName2 += strStave;
621 strEntryName2 += cStave;
622
623 for (Int_t cHS=0; cHS<2; cHS++) {
624 strEntryName3 = strEntryName2;
625 strEntryName3 += strHalfStave;
626 strEntryName3 += cHS;
627
628 for(Int_t cLad =0; cLad<2; cLad++){
629 symname = strEntryName3;
630 symname += strLadder;
631 symname += cLad+cHS*2;
632 uid = LayerToVolUID(kSPD1,modnum++);
633 pne = fgGeometry->GetAlignableEntryByUID(uid);
634 if(!pne)
635 {
636 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
637 return kFALSE;
638 }
639 sname = pne->GetName();
640 if(symname.CompareTo(sname))
641 {
642 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
643 "Expected was %s, found was %s!", uid, symname.Data(), sname));
644 return kFALSE;
645 }
0bf7aade 646 }
8f8273a4 647 }
67dd5535 648 }
649 }
650 }
ff5970a3 651
652 /********************* SPD layer2 ***********************/
653 {
654 modnum = 0;
655
656 for(Int_t cSect = 0; cSect<10; cSect++){
657 strEntryName1 = strSPD;
658 strEntryName1 += 1;
659 strEntryName1 += strSector;
660 strEntryName1 += cSect;
661
662 for(Int_t cStave =0; cStave<4; cStave++){
663 strEntryName2 = strEntryName1;
664 strEntryName2 += strStave;
665 strEntryName2 += cStave;
666
667 for (Int_t cHS=0; cHS<2; cHS++) {
668 strEntryName3 = strEntryName2;
669 strEntryName3 += strHalfStave;
670 strEntryName3 += cHS;
671
672 for(Int_t cLad =0; cLad<2; cLad++){
673 symname = strEntryName3;
674 symname += strLadder;
675 symname += cLad+cHS*2;
676 uid = LayerToVolUID(kSPD2,modnum++);
677 pne = fgGeometry->GetAlignableEntryByUID(uid);
678 if(!pne)
679 {
680 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
681 return kFALSE;
682 }
683 sname = pne->GetName();
684 if(symname.CompareTo(sname))
685 {
686 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
687 "Expected was %s, found was %s!", uid, symname.Data(), sname));
688 return kFALSE;
689 }
0bf7aade 690 }
8f8273a4 691 }
67dd5535 692 }
693 }
694 }
ff5970a3 695
696 /********************* SDD layer1 ***********************/
697 {
698 modnum=0;
699
700 for(Int_t c1 = 1; c1<=14; c1++){
701 strEntryName1 = strSDD;
702 strEntryName1 += 2;
703 strEntryName1 +=strLadder;
704 strEntryName1 += (c1-1);
705 for(Int_t c2 =1; c2<=6; c2++){
706 symname = strEntryName1;
707 symname += strSensor;
708 symname += (c2-1);
709 uid = LayerToVolUID(kSDD1,modnum++);
710 pne = fgGeometry->GetAlignableEntryByUID(uid);
711 if(!pne)
712 {
713 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
714 return kFALSE;
715 }
716 sname = pne->GetName();
717 if(symname.CompareTo(sname))
718 {
719 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
720 "Expected was %s, found was %s!", uid, symname.Data(), sname));
721 return kFALSE;
722 }
723 }
724 }
725 }
726
727 /********************* SDD layer2 ***********************/
728 {
729 modnum=0;
730
731 for(Int_t c1 = 1; c1<=22; c1++){
732 strEntryName1 = strSDD;
733 strEntryName1 += 3;
734 strEntryName1 +=strLadder;
735 strEntryName1 += (c1-1);
736 for(Int_t c2 = 1; c2<=8; c2++){
737 symname = strEntryName1;
738 symname += strSensor;
739 symname += (c2-1);
740 uid = LayerToVolUID(kSDD2,modnum++);
741 pne = fgGeometry->GetAlignableEntryByUID(uid);
742 if(!pne)
743 {
744 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
745 return kFALSE;
746 }
747 sname = pne->GetName();
748 if(symname.CompareTo(sname))
749 {
750 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
751 "Expected was %s, found was %s!", uid, symname.Data(), sname));
752 return kFALSE;
753 }
754 }
755 }
756 }
757
758 /********************* SSD layer1 ***********************/
759 {
760 modnum=0;
761
762 for(Int_t c1 = 1; c1<=34; c1++){
763 strEntryName1 = strSSD;
764 strEntryName1 += 4;
765 strEntryName1 +=strLadder;
766 strEntryName1 += (c1-1);
767 for(Int_t c2 = 1; c2<=22; c2++){
768 symname = strEntryName1;
769 symname += strSensor;
770 symname += (c2-1);
771 uid = LayerToVolUID(kSSD1,modnum++);
772 pne = fgGeometry->GetAlignableEntryByUID(uid);
773 if(!pne)
774 {
775 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
776 return kFALSE;
777 }
778 sname = pne->GetName();
779 if(symname.CompareTo(sname))
780 {
781 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
782 "Expected was %s, found was %s!", uid, symname.Data(), sname));
783 return kFALSE;
784 }
785 }
786 }
787 }
788
789 /********************* SSD layer2 ***********************/
790 {
791 modnum=0;
792
793 for(Int_t c1 = 1; c1<=38; c1++){
794 strEntryName1 = strSSD;
795 strEntryName1 += 5;
796 strEntryName1 +=strLadder;
797 strEntryName1 += (c1-1);
798 for(Int_t c2 = 1; c2<=25; c2++){
799 symname = strEntryName1;
800 symname += strSensor;
801 symname += (c2-1);
802 uid = LayerToVolUID(kSSD2,modnum++);
803 pne = fgGeometry->GetAlignableEntryByUID(uid);
804 if(!pne)
805 {
806 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
807 return kFALSE;
808 }
809 sname = pne->GetName();
810 if(symname.CompareTo(sname))
811 {
812 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
813 "Expected was %s, found was %s!", uid, symname.Data(), sname));
814 return kFALSE;
815 }
816 }
817 }
818 }
819
820 AliDebugClass(2,"Consistency check for ITS symbolic names finished successfully.");
67dd5535 821 }
822
ff5970a3 823 if(detsString.Contains("TPC"))
67dd5535 824 {
ff5970a3 825 /*************** TPC inner and outer layers ****************/
826
827 AliDebugClass(2,"Checking consistency of symbolic names for TPC layers");
828 TString sAsector="TPC/EndcapA/Sector";
829 TString sCsector="TPC/EndcapC/Sector";
830 TString sInner="/InnerChamber";
831 TString sOuter="/OuterChamber";
832
833 /*************** TPC inner chambers' layer ****************/
834 {
835 modnum = 0;
67dd5535 836
ff5970a3 837 for(Int_t cnt=1; cnt<=18; cnt++)
838 {
839 symname = sAsector;
840 symname += cnt;
841 symname += sInner;
842 uid = LayerToVolUID(kTPC1,modnum++);
0bf7aade 843 pne = fgGeometry->GetAlignableEntryByUID(uid);
844 if(!pne)
845 {
846 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
847 return kFALSE;
848 }
849 sname = pne->GetName();
850 if(symname.CompareTo(sname))
851 {
852 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
853 "Expected was %s, found was %s!", uid, symname.Data(), sname));
854 return kFALSE;
855 }
67dd5535 856 }
67dd5535 857
ff5970a3 858 for(Int_t cnt=1; cnt<=18; cnt++)
859 {
860 symname = sCsector;
861 symname += cnt;
862 symname += sInner;
863 uid = LayerToVolUID(kTPC1,modnum++);
0bf7aade 864 pne = fgGeometry->GetAlignableEntryByUID(uid);
865 if(!pne)
866 {
867 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
868 return kFALSE;
869 }
870 sname = pne->GetName();
871 if(symname.CompareTo(sname))
872 {
873 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
874 "Expected was %s, found was %s!", uid, symname.Data(), sname));
875 return kFALSE;
876 }
67dd5535 877 }
878 }
67dd5535 879
ff5970a3 880 /*************** TPC outer chambers' layer ****************/
881 {
882 modnum = 0;
67dd5535 883
ff5970a3 884 for(Int_t cnt=1; cnt<=18; cnt++)
885 {
886 symname = sAsector;
887 symname += cnt;
888 symname += sOuter;
889 uid = LayerToVolUID(kTPC2,modnum++);
0bf7aade 890 pne = fgGeometry->GetAlignableEntryByUID(uid);
891 if(!pne)
892 {
893 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
894 return kFALSE;
895 }
896 sname = pne->GetName();
897 if(symname.CompareTo(sname))
898 {
899 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
900 "Expected was %s, found was %s!", uid, symname.Data(), sname));
901 return kFALSE;
902 }
67dd5535 903 }
67dd5535 904
ff5970a3 905 for(Int_t cnt=1; cnt<=18; cnt++)
906 {
907 symname = sCsector;
908 symname += cnt;
909 symname += sOuter;
910 uid = LayerToVolUID(kTPC2,modnum++);
0bf7aade 911 pne = fgGeometry->GetAlignableEntryByUID(uid);
912 if(!pne)
913 {
914 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
915 return kFALSE;
916 }
917 sname = pne->GetName();
918 if(symname.CompareTo(sname))
919 {
920 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
921 "Expected was %s, found was %s!", uid, symname.Data(), sname));
922 return kFALSE;
923 }
67dd5535 924 }
925 }
67dd5535 926
ff5970a3 927 AliDebugClass(2,"Consistency check for TPC symbolic names finished successfully.");
67dd5535 928 }
929
ff5970a3 930 if(detsString.Contains("TOF"))
67dd5535 931 {
ff5970a3 932 /********************* TOF layer ***********************/
67dd5535 933
ff5970a3 934 AliDebugClass(2,"Checking consistency of symbolic names for TOF layers");
67dd5535 935 modnum=0;
ff5970a3 936
67dd5535 937 Int_t nstrA=15;
938 Int_t nstrB=19;
939 Int_t nstrC=19;
940 Int_t nSectors=18;
941 Int_t nStrips=nstrA+2*nstrB+2*nstrC;
0bf7aade 942
67dd5535 943 TString snSM = "TOF/sm";
944 TString snSTRIP = "/strip";
945
946 for (Int_t isect = 0; isect < nSectors; isect++) {
947 for (Int_t istr = 1; istr <= nStrips; istr++) {
948 symname = snSM;
949 symname += Form("%02d",isect);
950 symname += snSTRIP;
951 symname += Form("%02d",istr);
0bf7aade 952 uid = LayerToVolUID(kTOF,modnum++);
83364444 953 if(!tofSMs[isect]) continue; // taking possible missing TOF sectors (partial geometry) into account
954 AliDebugClass(2,Form("Consistency check for symnames of TOF supermodule %d.",isect));
0bf7aade 955 if ((isect==13 || isect==14 || isect==15) && (istr >= 39 && istr <= 53)) continue; //taking holes into account
956 pne = fgGeometry->GetAlignableEntryByUID(uid);
957 if(!pne)
958 {
959 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
960 return kFALSE;
961 }
962 sname = pne->GetName();
963 if(symname.CompareTo(sname))
964 {
965 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
966 "Expected was %s, found was %s!", uid, symname.Data(), sname));
967 return kFALSE;
968 }
67dd5535 969 }
970 }
ff5970a3 971
972 AliDebugClass(2,"Consistency check for TOF symbolic names finished successfully.");
67dd5535 973 }
974
ff5970a3 975 if(detsString.Contains("HMPID"))
67dd5535 976 {
ff5970a3 977 /********************* HMPID layer ***********************/
978
979 AliDebugClass(2,"Checking consistency of symbolic names for HMPID layers");
67dd5535 980 TString str = "/HMPID/Chamber";
981
982 for (modnum=0; modnum < 7; modnum++) {
983 symname = str;
984 symname += modnum;
0bf7aade 985 uid = LayerToVolUID(kHMPID,modnum);
986 pne = fgGeometry->GetAlignableEntryByUID(uid);
987 if(!pne)
988 {
989 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
990 return kFALSE;
991 }
992 sname = pne->GetName();
993 if(symname.CompareTo(sname))
994 {
995 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
996 "Expected was %s, found was %s!", uid, symname.Data(), sname));
997 return kFALSE;
998 }
67dd5535 999 }
ff5970a3 1000
1001 AliDebugClass(2,"Consistency check for HMPID symbolic names finished successfully.");
67dd5535 1002 }
1003
ff5970a3 1004 if(detsString.Contains("TRD"))
67dd5535 1005 {
ff5970a3 1006 /********************* TRD layers 1-6 *******************/
1007 //!! 6 layers with index increasing in outwards direction
1008
1009 AliDebugClass(2,"Checking consistency of symbolic names for TRD layers");
67dd5535 1010 Int_t arTRDlayId[6] = {kTRD1, kTRD2, kTRD3, kTRD4, kTRD5, kTRD6};
1011
1012 TString snStr = "TRD/sm";
1013 TString snApp1 = "/st";
1014 TString snApp2 = "/pl";
1015
1016 for(Int_t layer=0; layer<6; layer++){
1017 modnum=0;
1018 for (Int_t isect = 0; isect < 18; isect++) {
1019 for (Int_t icham = 0; icham < 5; icham++) {
1020 symname = snStr;
1021 symname += Form("%02d",isect);
1022 symname += snApp1;
1023 symname += icham;
1024 symname += snApp2;
1025 symname += layer;
0bf7aade 1026 uid = LayerToVolUID(arTRDlayId[layer],modnum++);
83364444 1027 if(!trdSMs[isect]) continue;
1028 AliDebugClass(2,Form("Consistency check for symnames of TRD supermodule %d.",isect));
0bf7aade 1029 if ((isect==13 || isect==14 || isect==15) && icham==2) continue; //keeping holes into account
1030 pne = fgGeometry->GetAlignableEntryByUID(uid);
1031 if(!pne)
1032 {
1033 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1034 return kFALSE;
1035 }
1036 sname = pne->GetName();
1037 if(symname.CompareTo(sname))
1038 {
1039 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1040 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1041 return kFALSE;
1042 }
67dd5535 1043 }
1044 }
1045 }
ff5970a3 1046
1047 AliDebugClass(2,"Consistency check for TRD symbolic names finished successfully.");
67dd5535 1048 }
df117114 1049
ff5970a3 1050 if(detsString.Contains("PHOS"))
df117114 1051 {
ff5970a3 1052 /********************* PHOS EMC layer ***********************/
df117114 1053
ff5970a3 1054 AliDebugClass(2,"Checking consistency of symbolic names for PHOS layers");
1055
ff5970a3 1056 TString str = "PHOS/Module";
1057 modnum=0;
1058
6ead0654 1059 for (Int_t iModule=0; iModule < 5; iModule++) {
1060 if(!phosMods[iModule]) continue;
ff5970a3 1061 symname = str;
6ead0654 1062 symname += (iModule+1);
1063 uid = LayerToVolUID(kPHOS1,iModule);
ff5970a3 1064 pne = fgGeometry->GetAlignableEntryByUID(uid);
1065 if(!pne)
1066 {
1067 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1068 return kFALSE;
1069 }
1070 sname = pne->GetName();
1071 if(symname.CompareTo(sname))
1072 {
1073 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1074 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1075 return kFALSE;
1076 }
6ead0654 1077 /********************* PHOS CPV layer ***********************/
1078 if(!cpvActive) continue;
ff5970a3 1079 symname += "/CPV";
6ead0654 1080 uid = LayerToVolUID(kPHOS2,iModule);
ff5970a3 1081 pne = fgGeometry->GetAlignableEntryByUID(uid);
1082 if(!pne)
1083 {
1084 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1085 return kFALSE;
1086 }
1087 sname = pne->GetName();
1088 if(symname.CompareTo(sname))
1089 {
1090 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1091 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1092 return kFALSE;
1093 }
0bf7aade 1094 }
ff5970a3 1095 AliDebugClass(2,"Consistency check for PHOS symbolic names finished successfully.");
f47b9233 1096 }
1097
ff5970a3 1098 if(detsString.Contains("EMCAL"))
3dfc15c0 1099 {
ff5970a3 1100 /********************* EMCAL layer ***********************/
1101
1102 AliDebugClass(2,"Checking consistency of symbolic names for EMCAL layers");
3dfc15c0 1103 TString str = "EMCAL/FullSupermodule";
1104 modnum=0;
1105
1106 for (Int_t iModule=1; iModule <= 12; iModule++) {
8e5d5edf 1107 if(!emcalSMs[iModule-1]) continue;
3dfc15c0 1108 symname = str;
1109 symname += iModule;
1110 if(iModule >10) {
1111 symname = "EMCAL/HalfSupermodule";
1112 symname += iModule-10;
1113 }
1114 modnum = iModule-1;
0bf7aade 1115 uid = LayerToVolUID(kEMCAL,modnum);
1116 pne = fgGeometry->GetAlignableEntryByUID(uid);
1117 if(!pne)
1118 {
1119 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1120 return kFALSE;
1121 }
1122 sname = pne->GetName();
1123 if(symname.CompareTo(sname))
1124 {
1125 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1126 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1127 return kFALSE;
1128 }
3dfc15c0 1129 }
ff5970a3 1130
1131 AliDebugClass(2,"Consistency check for EMCAL symbolic names finished successfully.");
3dfc15c0 1132 }
0bf7aade 1133
1134 return kTRUE;
f47b9233 1135
67dd5535 1136}
1137
1138//_____________________________________________________________________________
1139void AliGeomManager::InitPNEntriesLUT()
1140{
1141 // Initialize the look-up table which associates the unique
1142 // numerical identity of each alignable volume to the
1143 // corresponding TGeoPNEntry.
1144 // The LUTs are static; they are created at the creation of the
1145 // AliGeomManager instance and recreated if the geometry has changed
1146 //
36b010bf 1147 if(!fgGeometry) {
1148 AliErrorClass("Impossible to initialize PNEntries LUT without an active geometry");
1149 return;
1150 }
25fad4e5 1151
67dd5535 1152 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
3564f2da 1153 if (!fgPNEntry[iLayer]) fgPNEntry[iLayer] = new TGeoPNEntry*[fgLayerSize[iLayer]];
36b010bf 1154 for(Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++){
0bf7aade 1155 fgPNEntry[iLayer][modnum] = fgGeometry->GetAlignableEntryByUID(LayerToVolUID(iLayer+1,modnum));
36b010bf 1156 }
1157 }
1158}
1159
67dd5535 1160//______________________________________________________________________
53dd673d 1161TGeoHMatrix* AliGeomManager::GetMatrix(TGeoPNEntry * const pne)
67dd5535 1162{
5aedd709 1163 // Get the global transformation matrix for a given PNEntry
67dd5535 1164 // by quering the TGeoManager
1165
36b010bf 1166 if (!fgGeometry || !fgGeometry->IsClosed()) {
25fad4e5 1167 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1168 return NULL;
1169 }
5aedd709 1170
67dd5535 1171 TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
1172 if (pnode) return pnode->GetMatrix();
1173
1174 const char* path = pne->GetTitle();
36b010bf 1175 if (!fgGeometry->cd(path)) {
67dd5535 1176 AliErrorClass(Form("Volume path %s not valid!",path));
1177 return NULL;
1178 }
36b010bf 1179 return fgGeometry->GetCurrentMatrix();
67dd5535 1180}
1181
1182//______________________________________________________________________
1183TGeoHMatrix* AliGeomManager::GetMatrix(Int_t index)
1184{
1185 // Get the global transformation matrix for a given alignable volume
1186 // identified by its unique ID 'index' by quering the TGeoManager
1187
67dd5535 1188 TGeoPNEntry *pne = GetPNEntry(index);
1189 if (!pne) return NULL;
1190
1191 return GetMatrix(pne);
1192}
1193
1194//______________________________________________________________________
1195TGeoHMatrix* AliGeomManager::GetMatrix(const char* symname)
1196{
1197 // Get the global transformation matrix for a given alignable volume
1198 // identified by its symbolic name 'symname' by quering the TGeoManager
1199
36b010bf 1200 if (!fgGeometry || !fgGeometry->IsClosed()) {
1201 AliErrorClass("No active geometry or geometry not yet closed!");
1202 return NULL;
1203 }
1204
1205 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
67dd5535 1206 if (!pne) return NULL;
1207
1208 return GetMatrix(pne);
1209}
1210
1211//______________________________________________________________________
1212Bool_t AliGeomManager::GetTranslation(Int_t index, Double_t t[3])
1213{
1214 // Get the translation vector for a given module 'index'
1215 // by quering the TGeoManager
1216
1217 TGeoHMatrix *m = GetMatrix(index);
1218 if (!m) return kFALSE;
1219
1220 Double_t *trans = m->GetTranslation();
1221 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1222
1223 return kTRUE;
1224}
1225
1226//______________________________________________________________________
1227Bool_t AliGeomManager::GetRotation(Int_t index, Double_t r[9])
1228{
1229 // Get the rotation matrix for a given module 'index'
1230 // by quering the TGeoManager
1231
1232 TGeoHMatrix *m = GetMatrix(index);
1233 if (!m) return kFALSE;
1234
1235 Double_t *rot = m->GetRotationMatrix();
1236 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1237
1238 return kTRUE;
1239}
1240
5d534fe3 1241//_____________________________________________________________________________
1242Bool_t AliGeomManager::GetDeltaForBranch(Int_t index, TGeoHMatrix &inclusiveD)
1243{
1244 // The method sets the matrix passed as argument as the global delta
1245 // (for the volume referred by the unique index) including the displacements
1246 // of all parent volumes in the branch.
1247 //
5d534fe3 1248
1249 TGeoHMatrix go,invgo;
1250 go = *GetOrigGlobalMatrix(index);
1251 invgo = go.Inverse();
5aedd709 1252 inclusiveD = *GetMatrix(index);
5d534fe3 1253 inclusiveD.Multiply(&invgo);
1254
1255 return kTRUE;
1256}
1257
1258//_____________________________________________________________________________
1259Bool_t AliGeomManager::GetDeltaForBranch(AliAlignObj& aao, TGeoHMatrix &inclusiveD)
1260{
1261 // The method sets the matrix passed as argument as the global delta
1262 // (for the volume referred by the alignment object) including the displacements
1263 // of all parent volumes in the brach.
1264 //
1265 Int_t index = aao.GetVolUID();
1266 if(!index){
1267 AliErrorClass("Either the alignment object or its index are not valid");
1268 return kFALSE;
1269 }
1270 return GetDeltaForBranch(index, inclusiveD);
1271}
1272
36b010bf 1273//______________________________________________________________________
1274Bool_t AliGeomManager::GetOrigGlobalMatrix(const char* symname, TGeoHMatrix &m)
67dd5535 1275{
36b010bf 1276 // Get the global transformation matrix (ideal geometry) for a given alignable volume
0bf7aade 1277 // The alignable volume is identified by 'symname' which has to be either a valid symbolic
1278 // name, the query being performed after alignment, or a valid volume path if the query is
1279 // performed before alignment.
1280 //
36b010bf 1281 m.Clear();
67dd5535 1282
36b010bf 1283 if (!fgGeometry || !fgGeometry->IsClosed()) {
1284 AliErrorClass("No active geometry or geometry not yet closed!");
67dd5535 1285 return kFALSE;
1286 }
36b010bf 1287 if (!fgGeometry->GetListOfPhysicalNodes()) {
67dd5535 1288 AliWarningClass("gGeoManager doesn't contain any aligned nodes!");
36b010bf 1289 if (!fgGeometry->cd(symname)) {
67dd5535 1290 AliErrorClass(Form("Volume path %s not valid!",symname));
1291 return kFALSE;
1292 }
1293 else {
36b010bf 1294 m = *fgGeometry->GetCurrentMatrix();
67dd5535 1295 return kTRUE;
1296 }
1297 }
1298
36b010bf 1299 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
67dd5535 1300 const char* path = NULL;
67dd5535 1301 if(pne){
0bf7aade 1302 m = *pne->GetGlobalOrig();
1303 return kTRUE;
67dd5535 1304 }else{
1305 AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
1306 path=symname;
1307 }
1308
36b010bf 1309 return GetOrigGlobalMatrixFromPath(path,m);
1310}
1311
1312//_____________________________________________________________________________
1313Bool_t AliGeomManager::GetOrigGlobalMatrixFromPath(const char *path, TGeoHMatrix &m)
1314{
5aedd709 1315 // The method returns the global matrix for the volume identified by
1316 // 'path' in the ideal detector geometry.
1317 // The output global matrix is stored in 'm'.
1318 // Returns kFALSE in case TGeo has not been initialized or the volume
1319 // path is not valid.
36b010bf 1320 //
1321 m.Clear();
1322
1323 if (!fgGeometry || !fgGeometry->IsClosed()) {
1324 AliErrorClass("Can't get the original global matrix! gGeoManager doesn't exist or it is still opened!");
67dd5535 1325 return kFALSE;
1326 }
1327
36b010bf 1328 if (!fgGeometry->CheckPath(path)) {
1329 AliErrorClass(Form("Volume path %s not valid!",path));
1330 return kFALSE;
1331 }
67dd5535 1332
36b010bf 1333 TIter next(fgGeometry->GetListOfPhysicalNodes());
1334 fgGeometry->cd(path);
67dd5535 1335
36b010bf 1336 while(fgGeometry->GetLevel()){
67dd5535 1337
1338 TGeoPhysicalNode *physNode = NULL;
1339 next.Reset();
36b010bf 1340 TGeoNode *node = fgGeometry->GetCurrentNode();
67dd5535 1341 while ((physNode=(TGeoPhysicalNode*)next()))
1342 if (physNode->GetNode() == node) break;
1343
1344 TGeoMatrix *lm = NULL;
1345 if (physNode) {
5aedd709 1346 lm = physNode->GetOriginalMatrix();
1347 if (!lm) lm = node->GetMatrix();
67dd5535 1348 } else
1349 lm = node->GetMatrix();
1350
1351 m.MultiplyLeft(lm);
1352
36b010bf 1353 fgGeometry->CdUp();
67dd5535 1354 }
1355
1356 return kTRUE;
1357}
1358
36b010bf 1359//_____________________________________________________________________________
53dd673d 1360TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(TGeoPNEntry * const pne)
36b010bf 1361{
1362 // The method returns global matrix for the ideal detector geometry
1363 // using the corresponding TGeoPNEntry as an input.
5aedd709 1364 // The returned pointer should be copied by the user, since its content could
1365 // be overwritten by a following call to the method.
1366 // In case of missing TGeoManager the method returns NULL.
1367 //
36b010bf 1368 if (!fgGeometry || !fgGeometry->IsClosed()) {
1369 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1370 return NULL;
1371 }
1372
0bf7aade 1373 return pne->GetGlobalOrig();
36b010bf 1374}
1375
67dd5535 1376//______________________________________________________________________
36b010bf 1377TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(Int_t index)
67dd5535 1378{
5aedd709 1379 // The method returns global matrix from the ideal detector geometry
1380 // for the volume identified by its index.
1381 // The returned pointer should be copied by the user, since its content could
1382 // be overwritten by a following call to the method.
1383 // In case of missing TGeoManager the method returns NULL.
1384 // If possible, the method uses the LUT of original ideal matrices
1385 // for fast access. The LUT is reset in case a
36b010bf 1386 // new geometry is loaded.
5aedd709 1387 //
0bf7aade 1388 TGeoPNEntry* pne = GetPNEntry(index);
1389 return pne->GetGlobalOrig();
67dd5535 1390}
1391
1392//______________________________________________________________________
1393Bool_t AliGeomManager::GetOrigTranslation(Int_t index, Double_t t[3])
1394{
1395 // Get the original translation vector (ideal geometry)
1396 // for a given module 'index' by quering the TGeoManager
1397
36b010bf 1398 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1399 if (!m) return kFALSE;
67dd5535 1400
36b010bf 1401 Double_t *trans = m->GetTranslation();
67dd5535 1402 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1403
1404 return kTRUE;
1405}
1406
1407//______________________________________________________________________
1408Bool_t AliGeomManager::GetOrigRotation(Int_t index, Double_t r[9])
1409{
1410 // Get the original rotation matrix (ideal geometry)
1411 // for a given module 'index' by quering the TGeoManager
1412
36b010bf 1413 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1414 if (!m) return kFALSE;
67dd5535 1415
36b010bf 1416 Double_t *rot = m->GetRotationMatrix();
67dd5535 1417 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1418
1419 return kTRUE;
1420}
1421
1422//______________________________________________________________________
1423const TGeoHMatrix* AliGeomManager::GetTracking2LocalMatrix(Int_t index)
1424{
25fad4e5 1425 // Get the matrix which transforms from the tracking to the local RS
67dd5535 1426 // The method queries directly the TGeoPNEntry
1427
67dd5535 1428 TGeoPNEntry *pne = GetPNEntry(index);
1429 if (!pne) return NULL;
1430
1431 const TGeoHMatrix *m = pne->GetMatrix();
1432 if (!m)
5aedd709 1433 AliErrorClass(Form("TGeoPNEntry (%s) contains no tracking-to-local matrix !",pne->GetName()));
67dd5535 1434
1435 return m;
1436}
1437
1438//______________________________________________________________________
1439Bool_t AliGeomManager::GetTrackingMatrix(Int_t index, TGeoHMatrix &m)
1440{
1441 // Get the matrix which transforms from the tracking r.s. to
1442 // the global one.
1443 // Returns kFALSE in case of error.
1444
1445 m.Clear();
1446
1447 TGeoHMatrix *m1 = GetMatrix(index);
1448 if (!m1) return kFALSE;
1449
1450 const TGeoHMatrix *m2 = GetTracking2LocalMatrix(index);
1451 if (!m2) return kFALSE;
1452
1453 m = *m1;
1454 m.Multiply(m2);
1455
1456 return kTRUE;
1457}
1458
1459//_____________________________________________________________________________
1460TGeoPNEntry* AliGeomManager::GetPNEntry(Int_t voluid) {
1461 // Returns the TGeoPNEntry for the given global volume ID "voluid"
1462 //
1463 Int_t modId;
1464 ELayerID layerId = VolUIDToLayer(voluid,modId);
1465 return GetPNEntry(layerId,modId);
1466}
1467
1468//_____________________________________________________________________________
67dd5535 1469TGeoPNEntry* AliGeomManager::GetPNEntry(ELayerID layerId, Int_t modId)
1470{
1471 // Returns the TGeoPNEntry for a given layer
1472 // and module ID
1473 //
25fad4e5 1474
67dd5535 1475 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
1476 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
1477 return NULL;
1478 }
1479
1480 return fgPNEntry[layerId-kFirstLayer][modId];
1481}
1482
1483//_____________________________________________________________________________
5590c6c3 1484void AliGeomManager::CheckOverlapsOverPNs(Double_t threshold)
1485{
1486 // Check for overlaps/extrusions on physical nodes only;
1487 // this overlap-checker is meant to be used to check overlaps/extrusions
1488 // originated by the application of alignment objects.
1489 //
1490
1491 TObjArray* ovexlist = new TObjArray(64);
1492
1493 AliInfoClass("********* Checking overlaps/extrusions over physical nodes only *********");
1494 TObjArray* pnList = gGeoManager->GetListOfPhysicalNodes();
0cd61c1d 1495 TGeoVolume* mvol = 0;
5590c6c3 1496 TGeoPhysicalNode* pn;
1497 TObjArray* overlaps = new TObjArray(64);
1498 overlaps->SetOwner();
1499
1500 TStopwatch timer2;
1501 timer2.Start();
1502 for(Int_t pni=0; pni<pnList->GetEntriesFast(); pni++){
1503 pn = (TGeoPhysicalNode*) pnList->UncheckedAt(pni);
1504 // checking the volume of the mother (go upper in the tree in case it is an assembly)
1505 Int_t levup=1;
1506 while(((TGeoVolume*)pn->GetVolume(pn->GetLevel()-levup))->IsAssembly()) levup++;
1507 //Printf("Going to upper level");
1508 mvol = pn->GetVolume(pn->GetLevel()-levup);
1509 if(!mvol->IsSelected()){
1510 AliInfoClass(Form("Checking overlaps for volume %s",mvol->GetName()));
1511 mvol->CheckOverlaps(threshold);
1512 ovexlist = gGeoManager->GetListOfOverlaps();
1513 TIter next(ovexlist);
1514 TGeoOverlap *ov;
1515 while ((ov=(TGeoOverlap*)next())) overlaps->Add(ov->Clone());
1516 mvol->SelectVolume();
1517 }
1518 }
1519 mvol->SelectVolume(kTRUE); // clears the list of selected volumes
1520
1521 AliInfoClass(Form("Number of overlapping/extruding PNs: %d",overlaps->GetEntriesFast()));
1522 timer2.Stop();
1523 timer2.Print();
1524
1525 TIter nextN(overlaps);
1526 TGeoOverlap *ovlp;
1527 while ((ovlp=(TGeoOverlap*)nextN())) ovlp->PrintInfo();
1528
1529 overlaps->Delete();
1530 delete overlaps;
1531}
1532
1533//_____________________________________________________________________________
4fbb8e9d 1534Int_t AliGeomManager::GetNalignable(const char* module)
8cb26cdf 1535{
4fbb8e9d 1536 // Get number of declared alignable volumes for given detector in current geometry
8cb26cdf 1537 //
1538
4fbb8e9d 1539 // return the detector index corresponding to detector
1540 Int_t index = -1 ;
1541 for (index = 0; index < fgkNDetectors ; index++) {
1542 if ( strcmp(module, fgkDetectorName[index]) == 0 )
1543 break ;
1544 }
1545 return fgNalignable[index];
8cb26cdf 1546}
4fbb8e9d 1547
1548//_____________________________________________________________________________
1549void AliGeomManager::InitNalignable()
1550{
1551 // Set number of declared alignable volumes for given detector in current geometry
1552 // by looping on the list of PNEntries
1553 //
1554
1555 Int_t nAlE = gGeoManager->GetNAlignable(); // total number of alignable entries
1556 TGeoPNEntry *pne = 0;
4fbb8e9d 1557 const char* detName;
1558
1559 for (Int_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1560 detName = fgkDetectorName[iDet];
1561 Int_t nAlDet = 0;
1562
1563 for(Int_t iE = 0; iE < nAlE; iE++)
1564 {
1565 pne = gGeoManager->GetAlignableEntry(iE);
3564f2da 1566 TString pneName = pne->GetName();
1567 if(pneName.Contains(detName)) nAlDet++;
1568 if(!strcmp(detName,"GRP")) if(pneName.Contains("ABSO") || pneName.Contains("DIPO") ||
1569 pneName.Contains("FRAME") || pneName.Contains("PIPE") ||
1570 pneName.Contains("SHIL")) nAlDet++;
4fbb8e9d 1571 }
1572 fgNalignable[iDet] = nAlDet;
1573 }
8cb26cdf 1574
4fbb8e9d 1575}
1576
8cb26cdf 1577//_____________________________________________________________________________
67dd5535 1578Bool_t AliGeomManager::ApplyAlignObjsFromCDB(const char* AlignDetsList)
1579{
1580 // Calls AddAlignObjsFromCDBSingleDet for the detectors appearing in
1581 // the list passed as argument (called by AliSimulation and
1582 // AliReconstruction)
1583 // Read the alignment objects from CDB.
1584 // Each detector is supposed to have the
1585 // alignment objects in DET/Align/Data CDB path.
1586 // All the detector objects are then collected,
1587 // sorted by geometry level (starting from ALIC) and
1588 // then applied to the TGeo geometry.
1589 // Finally an overlaps check is performed.
1590 //
1591
36b010bf 1592 TObjArray alignObjArray;
1593 alignObjArray.Clear();
1594 alignObjArray.SetOwner(0);
67dd5535 1595
1596 TString alObjsNotLoaded="";
1597 TString alObjsLoaded="";
1598
1599 TString AlignDetsString(AlignDetsList);
1600 TObjArray *detsarr = AlignDetsString.Tokenize(' ');
1601 TIter iter(detsarr);
1602 TObjString *str = 0;
1603
1604 while((str = (TObjString*) iter.Next())){
1605 TString det(str->String());
2912a163 1606 AliDebugClass(5,Form("Loading alignment objs for %s",det.Data()));
36b010bf 1607 if(!LoadAlignObjsFromCDBSingleDet(det.Data(),alignObjArray)){
67dd5535 1608 alObjsNotLoaded += det.Data();
1609 alObjsNotLoaded += " ";
1610 } else {
1611 alObjsLoaded += det.Data();
1612 alObjsLoaded += " ";
1613 }
1614 }
b80b98e1 1615 detsarr->Delete();
1616 delete detsarr;
67dd5535 1617
36b010bf 1618 if(!alObjsLoaded.IsNull()) AliInfoClass(Form("Alignment objects loaded for: %s",
1619 alObjsLoaded.Data()));
451cbb1d 1620 if(!alObjsNotLoaded.IsNull())
1621 AliFatalClass(Form("Could not load alignment objects from OCDB for: %s",
36b010bf 1622 alObjsNotLoaded.Data()));
67dd5535 1623
9cb4fe0b 1624 return ApplyAlignObjsToGeom(alignObjArray);
67dd5535 1625}
1626
1627//_____________________________________________________________________________
36b010bf 1628Bool_t AliGeomManager::LoadAlignObjsFromCDBSingleDet(const char* detName, TObjArray& alignObjArray)
67dd5535 1629{
1630 // Adds the alignable objects found in the CDBEntry for the detector
1631 // passed as argument to the array of all alignment objects to be applyed
1632 // to geometry
1633 //
1634 // Fills array of single detector's alignable objects from CDB
1635
36b010bf 1636 AliDebugClass(2, Form("Loading alignment objs for detector: %s",detName));
67dd5535 1637
1638 AliCDBEntry *entry;
1639
1640 AliCDBPath path(detName,"Align","Data");
1641
1642 entry=AliCDBManager::Instance()->Get(path.GetPath());
1643 if(!entry){
36b010bf 1644 AliDebugClass(2,Form("Couldn't load alignment data for detector %s",detName));
67dd5535 1645 return kFALSE;
1646 }
1647 entry->SetOwner(1);
1648 TClonesArray *alignArray = (TClonesArray*) entry->GetObject();
1649 alignArray->SetOwner(0);
4fbb8e9d 1650 Int_t nAlObjs = alignArray->GetEntries();
1651 AliDebugClass(2,Form("Found %d alignment objects for %s",nAlObjs,detName));
1652 Int_t nAlVols = GetNalignable(detName);
1653 if(nAlObjs!=nAlVols) AliWarningClass(Form("%d alignment objects loaded for %s, which has %d alignable volumes",nAlObjs,detName,GetNalignable(detName)));
67dd5535 1654
1655 AliAlignObj *alignObj=0;
1656 TIter iter(alignArray);
1657
1658 // loop over align objects in detector
1659 while( ( alignObj=(AliAlignObj *) iter.Next() ) ){
36b010bf 1660 alignObjArray.Add(alignObj);
67dd5535 1661 }
1662 // delete entry --- Don't delete, it is cached!
1663
36b010bf 1664 AliDebugClass(2, Form("fAlignObjArray entries: %d",alignObjArray.GetEntries() ));
67dd5535 1665 return kTRUE;
1666
1667}
1668
1669//_____________________________________________________________________________
5590c6c3 1670Bool_t AliGeomManager::ApplyAlignObjsToGeom(TObjArray& alignObjArray, Bool_t ovlpcheck)
67dd5535 1671{
c8687cb5 1672 // Read collection of alignment objects (AliAlignObj derived) saved
1673 // in the TClonesArray alObjArray and apply them to gGeoManager
1674 //
1675 alignObjArray.Sort();
1676 Int_t nvols = alignObjArray.GetEntriesFast();
67dd5535 1677
c8687cb5 1678 Bool_t flag = kTRUE;
67dd5535 1679
c8687cb5 1680 for(Int_t j=0; j<nvols; j++)
67dd5535 1681 {
c8687cb5 1682 AliAlignObj* alobj = (AliAlignObj*) alignObjArray.UncheckedAt(j);
1683 if(!alobj->ApplyToGeometry(ovlpcheck))
1684 {
1685 flag = kFALSE;
1686 AliDebugClass(5,Form("Error applying alignment object for volume %s !",alobj->GetSymName()));
1687 }else{
1688 AliDebugClass(5,Form("Alignment object for volume %s applied successfully",alobj->GetSymName()));
1689 }
67dd5535 1690
c8687cb5 1691 }
bb1970d8 1692
c8687cb5 1693 if (AliDebugLevelClass() > 5) {
1694 fgGeometry->CheckOverlaps(0.001);
1695 TObjArray* ovexlist = fgGeometry->GetListOfOverlaps();
1696 if(ovexlist->GetEntriesFast()){
1697 AliErrorClass("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
1698 fgGeometry->PrintOverlaps();
1699 }
1700 }
67dd5535 1701
c8687cb5 1702 // Update the TGeoPhysicalNodes
1703 fgGeometry->RefreshPhysicalNodes();
36b010bf 1704
c8687cb5 1705 return flag;
67dd5535 1706
1707}
1708
1709//_____________________________________________________________________________
1710Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* fileName, const char* clArrayName)
1711{
1712 // read collection of alignment objects (AliAlignObj derived) saved
1713 // in the TClonesArray ClArrayName in the file fileName and apply
1714 // them to the geometry
1715 //
1716
1717 TFile* inFile = TFile::Open(fileName,"READ");
1718 if (!inFile || !inFile->IsOpen()) {
1719 AliErrorClass(Form("Could not open file %s !",fileName));
1720 return kFALSE;
1721 }
1722
36b010bf 1723 TClonesArray* alignObjArray = ((TClonesArray*) inFile->Get(clArrayName));
67dd5535 1724 inFile->Close();
36b010bf 1725 if (!alignObjArray) {
67dd5535 1726 AliErrorClass(Form("Could not get array (%s) from file (%s) !",clArrayName,fileName));
1727 return kFALSE;
1728 }
1729
36b010bf 1730 return ApplyAlignObjsToGeom(*alignObjArray);
67dd5535 1731
1732}
1733
1734//_____________________________________________________________________________
1735Bool_t AliGeomManager::ApplyAlignObjsToGeom(AliCDBParam* param, AliCDBId& Id)
1736{
1737 // read collection of alignment objects (AliAlignObj derived) saved
1738 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1739 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1740 // to the geometry
1741 //
1742
1743 AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage(param);
1744 AliCDBEntry* entry = storage->Get(Id);
36b010bf 1745 TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
67dd5535 1746
36b010bf 1747 return ApplyAlignObjsToGeom(*alignObjArray);
67dd5535 1748
1749}
1750
1751//_____________________________________________________________________________
1752Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* uri, const char* path, Int_t runnum, Int_t version, Int_t sversion)
1753{
1754 // read collection of alignment objects (AliAlignObj derived) saved
1755 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1756 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1757 // to the geometry
1758 //
1759
1760 AliCDBParam* param = AliCDBManager::Instance()->CreateParameter(uri);
1761 AliCDBId id(path, runnum, runnum, version, sversion);
1762
1763 return ApplyAlignObjsToGeom(param, id);
1764
1765}
1766
1767//_____________________________________________________________________________
1768Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* detName, Int_t runnum, Int_t version, Int_t sversion)
1769{
1770 // read collection of alignment objects (AliAlignObj derived) saved
1771 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1772 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1773 // to the geometry
1774 //
1775
1776 AliCDBPath path(detName,"Align","Data");
1777 AliCDBEntry* entry = AliCDBManager::Instance()->Get(path.GetPath(),runnum,version,sversion);
1778
1779 if(!entry) return kFALSE;
36b010bf 1780 TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
25fad4e5 1781
36b010bf 1782 return ApplyAlignObjsToGeom(*alignObjArray);
67dd5535 1783}
171c4ef9 1784
3564f2da 1785//_____________________________________________________________________________
1786void AliGeomManager::ResetPNEntriesLUT()
1787{
1788 // cleans static arrays containing the information on currently loaded geometry
1789 //
1790 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
1791 if (!fgPNEntry[iLayer]) continue;
1792 for (Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++) fgPNEntry[iLayer][modnum] = 0;
1793 }
1794 //
1795}
1796