ALIROOT-5559 Fix for memory jump in CPass0 (LHC10 processing). A custom streamer...
[u/mrichter/AliRoot.git] / STEER / 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 ??
8cc543cb 56 22 // EMCAL and DCAL
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
c1c44db3 101const char* AliGeomManager::fgkDetectorName[AliGeomManager::fgkNDetectors] =
102{"GRP","ITS","TPC","TRD","TOF","PHOS","HMPID","EMCAL","MUON","FMD","ZDC","PMD","T0","VZERO","ACORDE","AD","MFT","FIT"};
38e7ce48 103Int_t AliGeomManager::fgNalignable[fgkNDetectors] = {0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
4fbb8e9d 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\"",
63484d8d 137 AliCDBManager::Instance()->GetURI("GRP/Geometry/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;
8cc543cb 565 TString baseEmcalSM("ALIC_1/XEN1_1/");
8e5d5edf 566 Bool_t emcalActive=kFALSE;
8cc543cb 567 Bool_t emcalSMs[22] = {kFALSE};
568 for(Int_t sm=0; sm<22; sm++)
8e5d5edf 569 {
570 emcalSM=baseEmcalSM;
571 if(sm<10){
8cc543cb 572 emcalSM += "SMOD_";
573 emcalSM += (sm+1);
574 }else if(sm/2 == 5){
575 emcalSM += "SM10_";
576 emcalSM += (sm-9);
577 }else if(sm > 11){
578 emcalSM += "DCSM_";
579 emcalSM += (sm-11);
8e5d5edf 580 }
581 if(fgGeometry->CheckPath(emcalSM.Data()))
582 {
583 emcalActive=kTRUE;
584 emcalSMs[sm]=kTRUE;
585 }
586 }
587 if(emcalActive) detsString+="EMCAL ";
588
ff5970a3 589
67dd5535 590 TString symname;
0bf7aade 591 const char* sname;
592 TGeoPNEntry* pne = 0x0;
593 Int_t uid; // global unique identity
594 Int_t modnum; // unique id inside layer; in the following, set it to 0 at the start of each layer
67dd5535 595
ff5970a3 596 if(detsString.Contains("ITS")){
67dd5535 597 /********************* ITS layers ***********************/
ff5970a3 598 AliDebugClass(2,"Checking consistency of symbolic names for ITS layers");
599 TString strSPD = "ITS/SPD";
600 TString strSDD = "ITS/SDD";
601 TString strSSD = "ITS/SSD";
602 TString strStave = "/Stave";
603 TString strHalfStave = "/HalfStave";
604 TString strLadder = "/Ladder";
605 TString strSector = "/Sector";
606 TString strSensor = "/Sensor";
607 TString strEntryName1;
608 TString strEntryName2;
609 TString strEntryName3;
610
611 /********************* SPD layer1 ***********************/
612 {
613 modnum = 0;
614
615 for(Int_t cSect = 0; cSect<10; cSect++){
616 strEntryName1 = strSPD;
617 strEntryName1 += 0;
618 strEntryName1 += strSector;
619 strEntryName1 += cSect;
620
621 for(Int_t cStave =0; cStave<2; cStave++){
622 strEntryName2 = strEntryName1;
623 strEntryName2 += strStave;
624 strEntryName2 += cStave;
625
626 for (Int_t cHS=0; cHS<2; cHS++) {
627 strEntryName3 = strEntryName2;
628 strEntryName3 += strHalfStave;
629 strEntryName3 += cHS;
630
631 for(Int_t cLad =0; cLad<2; cLad++){
632 symname = strEntryName3;
633 symname += strLadder;
634 symname += cLad+cHS*2;
635 uid = LayerToVolUID(kSPD1,modnum++);
636 pne = fgGeometry->GetAlignableEntryByUID(uid);
637 if(!pne)
638 {
639 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
640 return kFALSE;
641 }
642 sname = pne->GetName();
643 if(symname.CompareTo(sname))
644 {
645 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
646 "Expected was %s, found was %s!", uid, symname.Data(), sname));
647 return kFALSE;
648 }
0bf7aade 649 }
8f8273a4 650 }
67dd5535 651 }
652 }
653 }
ff5970a3 654
655 /********************* SPD layer2 ***********************/
656 {
657 modnum = 0;
658
659 for(Int_t cSect = 0; cSect<10; cSect++){
660 strEntryName1 = strSPD;
661 strEntryName1 += 1;
662 strEntryName1 += strSector;
663 strEntryName1 += cSect;
664
665 for(Int_t cStave =0; cStave<4; cStave++){
666 strEntryName2 = strEntryName1;
667 strEntryName2 += strStave;
668 strEntryName2 += cStave;
669
670 for (Int_t cHS=0; cHS<2; cHS++) {
671 strEntryName3 = strEntryName2;
672 strEntryName3 += strHalfStave;
673 strEntryName3 += cHS;
674
675 for(Int_t cLad =0; cLad<2; cLad++){
676 symname = strEntryName3;
677 symname += strLadder;
678 symname += cLad+cHS*2;
679 uid = LayerToVolUID(kSPD2,modnum++);
680 pne = fgGeometry->GetAlignableEntryByUID(uid);
681 if(!pne)
682 {
683 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
684 return kFALSE;
685 }
686 sname = pne->GetName();
687 if(symname.CompareTo(sname))
688 {
689 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
690 "Expected was %s, found was %s!", uid, symname.Data(), sname));
691 return kFALSE;
692 }
0bf7aade 693 }
8f8273a4 694 }
67dd5535 695 }
696 }
697 }
ff5970a3 698
699 /********************* SDD layer1 ***********************/
700 {
701 modnum=0;
702
703 for(Int_t c1 = 1; c1<=14; c1++){
704 strEntryName1 = strSDD;
705 strEntryName1 += 2;
706 strEntryName1 +=strLadder;
707 strEntryName1 += (c1-1);
708 for(Int_t c2 =1; c2<=6; c2++){
709 symname = strEntryName1;
710 symname += strSensor;
711 symname += (c2-1);
712 uid = LayerToVolUID(kSDD1,modnum++);
713 pne = fgGeometry->GetAlignableEntryByUID(uid);
714 if(!pne)
715 {
716 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
717 return kFALSE;
718 }
719 sname = pne->GetName();
720 if(symname.CompareTo(sname))
721 {
722 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
723 "Expected was %s, found was %s!", uid, symname.Data(), sname));
724 return kFALSE;
725 }
726 }
727 }
728 }
729
730 /********************* SDD layer2 ***********************/
731 {
732 modnum=0;
733
734 for(Int_t c1 = 1; c1<=22; c1++){
735 strEntryName1 = strSDD;
736 strEntryName1 += 3;
737 strEntryName1 +=strLadder;
738 strEntryName1 += (c1-1);
739 for(Int_t c2 = 1; c2<=8; c2++){
740 symname = strEntryName1;
741 symname += strSensor;
742 symname += (c2-1);
743 uid = LayerToVolUID(kSDD2,modnum++);
744 pne = fgGeometry->GetAlignableEntryByUID(uid);
745 if(!pne)
746 {
747 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
748 return kFALSE;
749 }
750 sname = pne->GetName();
751 if(symname.CompareTo(sname))
752 {
753 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
754 "Expected was %s, found was %s!", uid, symname.Data(), sname));
755 return kFALSE;
756 }
757 }
758 }
759 }
760
761 /********************* SSD layer1 ***********************/
762 {
763 modnum=0;
764
765 for(Int_t c1 = 1; c1<=34; c1++){
766 strEntryName1 = strSSD;
767 strEntryName1 += 4;
768 strEntryName1 +=strLadder;
769 strEntryName1 += (c1-1);
770 for(Int_t c2 = 1; c2<=22; c2++){
771 symname = strEntryName1;
772 symname += strSensor;
773 symname += (c2-1);
774 uid = LayerToVolUID(kSSD1,modnum++);
775 pne = fgGeometry->GetAlignableEntryByUID(uid);
776 if(!pne)
777 {
778 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
779 return kFALSE;
780 }
781 sname = pne->GetName();
782 if(symname.CompareTo(sname))
783 {
784 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
785 "Expected was %s, found was %s!", uid, symname.Data(), sname));
786 return kFALSE;
787 }
788 }
789 }
790 }
791
792 /********************* SSD layer2 ***********************/
793 {
794 modnum=0;
795
796 for(Int_t c1 = 1; c1<=38; c1++){
797 strEntryName1 = strSSD;
798 strEntryName1 += 5;
799 strEntryName1 +=strLadder;
800 strEntryName1 += (c1-1);
801 for(Int_t c2 = 1; c2<=25; c2++){
802 symname = strEntryName1;
803 symname += strSensor;
804 symname += (c2-1);
805 uid = LayerToVolUID(kSSD2,modnum++);
806 pne = fgGeometry->GetAlignableEntryByUID(uid);
807 if(!pne)
808 {
809 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
810 return kFALSE;
811 }
812 sname = pne->GetName();
813 if(symname.CompareTo(sname))
814 {
815 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
816 "Expected was %s, found was %s!", uid, symname.Data(), sname));
817 return kFALSE;
818 }
819 }
820 }
821 }
822
823 AliDebugClass(2,"Consistency check for ITS symbolic names finished successfully.");
67dd5535 824 }
825
ff5970a3 826 if(detsString.Contains("TPC"))
67dd5535 827 {
ff5970a3 828 /*************** TPC inner and outer layers ****************/
829
830 AliDebugClass(2,"Checking consistency of symbolic names for TPC layers");
831 TString sAsector="TPC/EndcapA/Sector";
832 TString sCsector="TPC/EndcapC/Sector";
833 TString sInner="/InnerChamber";
834 TString sOuter="/OuterChamber";
835
836 /*************** TPC inner chambers' layer ****************/
837 {
838 modnum = 0;
67dd5535 839
ff5970a3 840 for(Int_t cnt=1; cnt<=18; cnt++)
841 {
842 symname = sAsector;
843 symname += cnt;
844 symname += sInner;
845 uid = LayerToVolUID(kTPC1,modnum++);
0bf7aade 846 pne = fgGeometry->GetAlignableEntryByUID(uid);
847 if(!pne)
848 {
849 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
850 return kFALSE;
851 }
852 sname = pne->GetName();
853 if(symname.CompareTo(sname))
854 {
855 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
856 "Expected was %s, found was %s!", uid, symname.Data(), sname));
857 return kFALSE;
858 }
67dd5535 859 }
67dd5535 860
ff5970a3 861 for(Int_t cnt=1; cnt<=18; cnt++)
862 {
863 symname = sCsector;
864 symname += cnt;
865 symname += sInner;
866 uid = LayerToVolUID(kTPC1,modnum++);
0bf7aade 867 pne = fgGeometry->GetAlignableEntryByUID(uid);
868 if(!pne)
869 {
870 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
871 return kFALSE;
872 }
873 sname = pne->GetName();
874 if(symname.CompareTo(sname))
875 {
876 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
877 "Expected was %s, found was %s!", uid, symname.Data(), sname));
878 return kFALSE;
879 }
67dd5535 880 }
881 }
67dd5535 882
ff5970a3 883 /*************** TPC outer chambers' layer ****************/
884 {
885 modnum = 0;
67dd5535 886
ff5970a3 887 for(Int_t cnt=1; cnt<=18; cnt++)
888 {
889 symname = sAsector;
890 symname += cnt;
891 symname += sOuter;
892 uid = LayerToVolUID(kTPC2,modnum++);
0bf7aade 893 pne = fgGeometry->GetAlignableEntryByUID(uid);
894 if(!pne)
895 {
896 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
897 return kFALSE;
898 }
899 sname = pne->GetName();
900 if(symname.CompareTo(sname))
901 {
902 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
903 "Expected was %s, found was %s!", uid, symname.Data(), sname));
904 return kFALSE;
905 }
67dd5535 906 }
67dd5535 907
ff5970a3 908 for(Int_t cnt=1; cnt<=18; cnt++)
909 {
910 symname = sCsector;
911 symname += cnt;
912 symname += sOuter;
913 uid = LayerToVolUID(kTPC2,modnum++);
0bf7aade 914 pne = fgGeometry->GetAlignableEntryByUID(uid);
915 if(!pne)
916 {
917 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
918 return kFALSE;
919 }
920 sname = pne->GetName();
921 if(symname.CompareTo(sname))
922 {
923 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
924 "Expected was %s, found was %s!", uid, symname.Data(), sname));
925 return kFALSE;
926 }
67dd5535 927 }
928 }
67dd5535 929
ff5970a3 930 AliDebugClass(2,"Consistency check for TPC symbolic names finished successfully.");
67dd5535 931 }
932
ff5970a3 933 if(detsString.Contains("TOF"))
67dd5535 934 {
ff5970a3 935 /********************* TOF layer ***********************/
67dd5535 936
ff5970a3 937 AliDebugClass(2,"Checking consistency of symbolic names for TOF layers");
67dd5535 938 modnum=0;
ff5970a3 939
67dd5535 940 Int_t nstrA=15;
941 Int_t nstrB=19;
942 Int_t nstrC=19;
943 Int_t nSectors=18;
944 Int_t nStrips=nstrA+2*nstrB+2*nstrC;
0bf7aade 945
67dd5535 946 TString snSM = "TOF/sm";
947 TString snSTRIP = "/strip";
948
949 for (Int_t isect = 0; isect < nSectors; isect++) {
a55c71ed 950 if(tofSMs[isect]) AliDebugClass(3,Form("Consistency check for symnames of TOF supermodule %d.",isect));
67dd5535 951 for (Int_t istr = 1; istr <= nStrips; istr++) {
952 symname = snSM;
953 symname += Form("%02d",isect);
954 symname += snSTRIP;
955 symname += Form("%02d",istr);
0bf7aade 956 uid = LayerToVolUID(kTOF,modnum++);
83364444 957 if(!tofSMs[isect]) continue; // taking possible missing TOF sectors (partial geometry) into account
0bf7aade 958 if ((isect==13 || isect==14 || isect==15) && (istr >= 39 && istr <= 53)) continue; //taking holes into account
959 pne = fgGeometry->GetAlignableEntryByUID(uid);
960 if(!pne)
961 {
962 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
963 return kFALSE;
964 }
965 sname = pne->GetName();
966 if(symname.CompareTo(sname))
967 {
968 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
969 "Expected was %s, found was %s!", uid, symname.Data(), sname));
970 return kFALSE;
971 }
67dd5535 972 }
973 }
ff5970a3 974
975 AliDebugClass(2,"Consistency check for TOF symbolic names finished successfully.");
67dd5535 976 }
977
ff5970a3 978 if(detsString.Contains("HMPID"))
67dd5535 979 {
ff5970a3 980 /********************* HMPID layer ***********************/
981
982 AliDebugClass(2,"Checking consistency of symbolic names for HMPID layers");
67dd5535 983 TString str = "/HMPID/Chamber";
984
985 for (modnum=0; modnum < 7; modnum++) {
986 symname = str;
987 symname += modnum;
0bf7aade 988 uid = LayerToVolUID(kHMPID,modnum);
989 pne = fgGeometry->GetAlignableEntryByUID(uid);
990 if(!pne)
991 {
992 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
993 return kFALSE;
994 }
995 sname = pne->GetName();
996 if(symname.CompareTo(sname))
997 {
998 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
999 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1000 return kFALSE;
1001 }
67dd5535 1002 }
ff5970a3 1003
1004 AliDebugClass(2,"Consistency check for HMPID symbolic names finished successfully.");
67dd5535 1005 }
1006
ff5970a3 1007 if(detsString.Contains("TRD"))
67dd5535 1008 {
ff5970a3 1009 /********************* TRD layers 1-6 *******************/
1010 //!! 6 layers with index increasing in outwards direction
1011
1012 AliDebugClass(2,"Checking consistency of symbolic names for TRD layers");
67dd5535 1013 Int_t arTRDlayId[6] = {kTRD1, kTRD2, kTRD3, kTRD4, kTRD5, kTRD6};
1014
1015 TString snStr = "TRD/sm";
1016 TString snApp1 = "/st";
1017 TString snApp2 = "/pl";
1018
1019 for(Int_t layer=0; layer<6; layer++){
1020 modnum=0;
a55c71ed 1021 AliDebugClass(3,Form("Consistency check for symnames of TRD layer %d.",layer));
67dd5535 1022 for (Int_t isect = 0; isect < 18; isect++) {
1023 for (Int_t icham = 0; icham < 5; icham++) {
1024 symname = snStr;
1025 symname += Form("%02d",isect);
1026 symname += snApp1;
1027 symname += icham;
1028 symname += snApp2;
1029 symname += layer;
0bf7aade 1030 uid = LayerToVolUID(arTRDlayId[layer],modnum++);
83364444 1031 if(!trdSMs[isect]) continue;
0bf7aade 1032 if ((isect==13 || isect==14 || isect==15) && icham==2) continue; //keeping holes into account
1033 pne = fgGeometry->GetAlignableEntryByUID(uid);
1034 if(!pne)
1035 {
1036 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1037 return kFALSE;
1038 }
1039 sname = pne->GetName();
1040 if(symname.CompareTo(sname))
1041 {
1042 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1043 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1044 return kFALSE;
1045 }
67dd5535 1046 }
1047 }
1048 }
ff5970a3 1049
1050 AliDebugClass(2,"Consistency check for TRD symbolic names finished successfully.");
67dd5535 1051 }
df117114 1052
ff5970a3 1053 if(detsString.Contains("PHOS"))
df117114 1054 {
ff5970a3 1055 /********************* PHOS EMC layer ***********************/
df117114 1056
ff5970a3 1057 AliDebugClass(2,"Checking consistency of symbolic names for PHOS layers");
1058
ff5970a3 1059 TString str = "PHOS/Module";
1060 modnum=0;
1061
6ead0654 1062 for (Int_t iModule=0; iModule < 5; iModule++) {
1063 if(!phosMods[iModule]) continue;
ff5970a3 1064 symname = str;
6ead0654 1065 symname += (iModule+1);
1066 uid = LayerToVolUID(kPHOS1,iModule);
ff5970a3 1067 pne = fgGeometry->GetAlignableEntryByUID(uid);
1068 if(!pne)
1069 {
1070 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1071 return kFALSE;
1072 }
1073 sname = pne->GetName();
1074 if(symname.CompareTo(sname))
1075 {
1076 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1077 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1078 return kFALSE;
1079 }
6ead0654 1080 /********************* PHOS CPV layer ***********************/
1081 if(!cpvActive) continue;
ff5970a3 1082 symname += "/CPV";
6ead0654 1083 uid = LayerToVolUID(kPHOS2,iModule);
ff5970a3 1084 pne = fgGeometry->GetAlignableEntryByUID(uid);
1085 if(!pne)
1086 {
1087 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1088 return kFALSE;
1089 }
1090 sname = pne->GetName();
1091 if(symname.CompareTo(sname))
1092 {
1093 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1094 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1095 return kFALSE;
1096 }
0bf7aade 1097 }
ff5970a3 1098 AliDebugClass(2,"Consistency check for PHOS symbolic names finished successfully.");
f47b9233 1099 }
1100
ff5970a3 1101 if(detsString.Contains("EMCAL"))
3dfc15c0 1102 {
ff5970a3 1103 /********************* EMCAL layer ***********************/
1104
1105 AliDebugClass(2,"Checking consistency of symbolic names for EMCAL layers");
3dfc15c0 1106 TString str = "EMCAL/FullSupermodule";
1107 modnum=0;
1108
8cc543cb 1109 for (Int_t iModule=0; iModule < 22; iModule++) {
1110 if(!emcalSMs[iModule]) continue;
3dfc15c0 1111 symname = str;
8cc543cb 1112 symname += iModule+1;
1113 if(iModule/2 == 5) {// 10,11
3dfc15c0 1114 symname = "EMCAL/HalfSupermodule";
8cc543cb 1115 symname += iModule-9;
1116 }else if(iModule > 11) {// 12 ~ 21
1117 symname = "EMCAL/DCALSupermodule";
1118 symname += iModule-11;
3dfc15c0 1119 }
8cc543cb 1120 modnum = iModule;
0bf7aade 1121 uid = LayerToVolUID(kEMCAL,modnum);
1122 pne = fgGeometry->GetAlignableEntryByUID(uid);
1123 if(!pne)
1124 {
1125 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1126 return kFALSE;
1127 }
1128 sname = pne->GetName();
1129 if(symname.CompareTo(sname))
1130 {
1131 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1132 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1133 return kFALSE;
1134 }
3dfc15c0 1135 }
ff5970a3 1136
1137 AliDebugClass(2,"Consistency check for EMCAL symbolic names finished successfully.");
3dfc15c0 1138 }
0bf7aade 1139
1140 return kTRUE;
f47b9233 1141
67dd5535 1142}
1143
1144//_____________________________________________________________________________
1145void AliGeomManager::InitPNEntriesLUT()
1146{
1147 // Initialize the look-up table which associates the unique
1148 // numerical identity of each alignable volume to the
1149 // corresponding TGeoPNEntry.
1150 // The LUTs are static; they are created at the creation of the
1151 // AliGeomManager instance and recreated if the geometry has changed
1152 //
36b010bf 1153 if(!fgGeometry) {
1154 AliErrorClass("Impossible to initialize PNEntries LUT without an active geometry");
1155 return;
1156 }
25fad4e5 1157
67dd5535 1158 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
3564f2da 1159 if (!fgPNEntry[iLayer]) fgPNEntry[iLayer] = new TGeoPNEntry*[fgLayerSize[iLayer]];
36b010bf 1160 for(Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++){
0bf7aade 1161 fgPNEntry[iLayer][modnum] = fgGeometry->GetAlignableEntryByUID(LayerToVolUID(iLayer+1,modnum));
36b010bf 1162 }
1163 }
1164}
1165
67dd5535 1166//______________________________________________________________________
53dd673d 1167TGeoHMatrix* AliGeomManager::GetMatrix(TGeoPNEntry * const pne)
67dd5535 1168{
5aedd709 1169 // Get the global transformation matrix for a given PNEntry
67dd5535 1170 // by quering the TGeoManager
1171
36b010bf 1172 if (!fgGeometry || !fgGeometry->IsClosed()) {
25fad4e5 1173 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1174 return NULL;
1175 }
5aedd709 1176
67dd5535 1177 TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
1178 if (pnode) return pnode->GetMatrix();
1179
1180 const char* path = pne->GetTitle();
36b010bf 1181 if (!fgGeometry->cd(path)) {
67dd5535 1182 AliErrorClass(Form("Volume path %s not valid!",path));
1183 return NULL;
1184 }
36b010bf 1185 return fgGeometry->GetCurrentMatrix();
67dd5535 1186}
1187
1188//______________________________________________________________________
1189TGeoHMatrix* AliGeomManager::GetMatrix(Int_t index)
1190{
1191 // Get the global transformation matrix for a given alignable volume
1192 // identified by its unique ID 'index' by quering the TGeoManager
1193
67dd5535 1194 TGeoPNEntry *pne = GetPNEntry(index);
1195 if (!pne) return NULL;
1196
1197 return GetMatrix(pne);
1198}
1199
1200//______________________________________________________________________
1201TGeoHMatrix* AliGeomManager::GetMatrix(const char* symname)
1202{
1203 // Get the global transformation matrix for a given alignable volume
1204 // identified by its symbolic name 'symname' by quering the TGeoManager
1205
36b010bf 1206 if (!fgGeometry || !fgGeometry->IsClosed()) {
1207 AliErrorClass("No active geometry or geometry not yet closed!");
1208 return NULL;
1209 }
1210
1211 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
67dd5535 1212 if (!pne) return NULL;
1213
1214 return GetMatrix(pne);
1215}
1216
1217//______________________________________________________________________
1218Bool_t AliGeomManager::GetTranslation(Int_t index, Double_t t[3])
1219{
1220 // Get the translation vector for a given module 'index'
1221 // by quering the TGeoManager
1222
1223 TGeoHMatrix *m = GetMatrix(index);
1224 if (!m) return kFALSE;
1225
1226 Double_t *trans = m->GetTranslation();
1227 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1228
1229 return kTRUE;
1230}
1231
1232//______________________________________________________________________
1233Bool_t AliGeomManager::GetRotation(Int_t index, Double_t r[9])
1234{
1235 // Get the rotation matrix for a given module 'index'
1236 // by quering the TGeoManager
1237
1238 TGeoHMatrix *m = GetMatrix(index);
1239 if (!m) return kFALSE;
1240
1241 Double_t *rot = m->GetRotationMatrix();
1242 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1243
1244 return kTRUE;
1245}
1246
5d534fe3 1247//_____________________________________________________________________________
1248Bool_t AliGeomManager::GetDeltaForBranch(Int_t index, TGeoHMatrix &inclusiveD)
1249{
1250 // The method sets the matrix passed as argument as the global delta
1251 // (for the volume referred by the unique index) including the displacements
1252 // of all parent volumes in the branch.
1253 //
5d534fe3 1254
1255 TGeoHMatrix go,invgo;
1256 go = *GetOrigGlobalMatrix(index);
1257 invgo = go.Inverse();
5aedd709 1258 inclusiveD = *GetMatrix(index);
5d534fe3 1259 inclusiveD.Multiply(&invgo);
1260
1261 return kTRUE;
1262}
1263
1264//_____________________________________________________________________________
1265Bool_t AliGeomManager::GetDeltaForBranch(AliAlignObj& aao, TGeoHMatrix &inclusiveD)
1266{
1267 // The method sets the matrix passed as argument as the global delta
1268 // (for the volume referred by the alignment object) including the displacements
1269 // of all parent volumes in the brach.
1270 //
1271 Int_t index = aao.GetVolUID();
1272 if(!index){
1273 AliErrorClass("Either the alignment object or its index are not valid");
1274 return kFALSE;
1275 }
1276 return GetDeltaForBranch(index, inclusiveD);
1277}
1278
36b010bf 1279//______________________________________________________________________
1280Bool_t AliGeomManager::GetOrigGlobalMatrix(const char* symname, TGeoHMatrix &m)
67dd5535 1281{
36b010bf 1282 // Get the global transformation matrix (ideal geometry) for a given alignable volume
0bf7aade 1283 // The alignable volume is identified by 'symname' which has to be either a valid symbolic
1284 // name, the query being performed after alignment, or a valid volume path if the query is
1285 // performed before alignment.
1286 //
36b010bf 1287 m.Clear();
67dd5535 1288
36b010bf 1289 if (!fgGeometry || !fgGeometry->IsClosed()) {
1290 AliErrorClass("No active geometry or geometry not yet closed!");
67dd5535 1291 return kFALSE;
1292 }
36b010bf 1293 if (!fgGeometry->GetListOfPhysicalNodes()) {
67dd5535 1294 AliWarningClass("gGeoManager doesn't contain any aligned nodes!");
36b010bf 1295 if (!fgGeometry->cd(symname)) {
67dd5535 1296 AliErrorClass(Form("Volume path %s not valid!",symname));
1297 return kFALSE;
1298 }
1299 else {
36b010bf 1300 m = *fgGeometry->GetCurrentMatrix();
67dd5535 1301 return kTRUE;
1302 }
1303 }
1304
36b010bf 1305 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
67dd5535 1306 const char* path = NULL;
67dd5535 1307 if(pne){
0bf7aade 1308 m = *pne->GetGlobalOrig();
1309 return kTRUE;
67dd5535 1310 }else{
1311 AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
1312 path=symname;
1313 }
1314
36b010bf 1315 return GetOrigGlobalMatrixFromPath(path,m);
1316}
1317
1318//_____________________________________________________________________________
1319Bool_t AliGeomManager::GetOrigGlobalMatrixFromPath(const char *path, TGeoHMatrix &m)
1320{
5aedd709 1321 // The method returns the global matrix for the volume identified by
1322 // 'path' in the ideal detector geometry.
1323 // The output global matrix is stored in 'm'.
1324 // Returns kFALSE in case TGeo has not been initialized or the volume
1325 // path is not valid.
36b010bf 1326 //
1327 m.Clear();
1328
1329 if (!fgGeometry || !fgGeometry->IsClosed()) {
1330 AliErrorClass("Can't get the original global matrix! gGeoManager doesn't exist or it is still opened!");
67dd5535 1331 return kFALSE;
1332 }
1333
36b010bf 1334 if (!fgGeometry->CheckPath(path)) {
1335 AliErrorClass(Form("Volume path %s not valid!",path));
1336 return kFALSE;
1337 }
67dd5535 1338
36b010bf 1339 TIter next(fgGeometry->GetListOfPhysicalNodes());
1340 fgGeometry->cd(path);
67dd5535 1341
36b010bf 1342 while(fgGeometry->GetLevel()){
67dd5535 1343
1344 TGeoPhysicalNode *physNode = NULL;
1345 next.Reset();
36b010bf 1346 TGeoNode *node = fgGeometry->GetCurrentNode();
67dd5535 1347 while ((physNode=(TGeoPhysicalNode*)next()))
1348 if (physNode->GetNode() == node) break;
1349
1350 TGeoMatrix *lm = NULL;
1351 if (physNode) {
5aedd709 1352 lm = physNode->GetOriginalMatrix();
1353 if (!lm) lm = node->GetMatrix();
67dd5535 1354 } else
1355 lm = node->GetMatrix();
1356
1357 m.MultiplyLeft(lm);
1358
36b010bf 1359 fgGeometry->CdUp();
67dd5535 1360 }
1361
1362 return kTRUE;
1363}
1364
36b010bf 1365//_____________________________________________________________________________
53dd673d 1366TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(TGeoPNEntry * const pne)
36b010bf 1367{
1368 // The method returns global matrix for the ideal detector geometry
1369 // using the corresponding TGeoPNEntry as an input.
5aedd709 1370 // The returned pointer should be copied by the user, since its content could
1371 // be overwritten by a following call to the method.
1372 // In case of missing TGeoManager the method returns NULL.
1373 //
36b010bf 1374 if (!fgGeometry || !fgGeometry->IsClosed()) {
1375 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1376 return NULL;
1377 }
1378
0bf7aade 1379 return pne->GetGlobalOrig();
36b010bf 1380}
1381
67dd5535 1382//______________________________________________________________________
36b010bf 1383TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(Int_t index)
67dd5535 1384{
5aedd709 1385 // The method returns global matrix from the ideal detector geometry
1386 // for the volume identified by its index.
1387 // The returned pointer should be copied by the user, since its content could
1388 // be overwritten by a following call to the method.
1389 // In case of missing TGeoManager the method returns NULL.
1390 // If possible, the method uses the LUT of original ideal matrices
1391 // for fast access. The LUT is reset in case a
36b010bf 1392 // new geometry is loaded.
5aedd709 1393 //
0bf7aade 1394 TGeoPNEntry* pne = GetPNEntry(index);
1395 return pne->GetGlobalOrig();
67dd5535 1396}
1397
1398//______________________________________________________________________
1399Bool_t AliGeomManager::GetOrigTranslation(Int_t index, Double_t t[3])
1400{
1401 // Get the original translation vector (ideal geometry)
1402 // for a given module 'index' by quering the TGeoManager
1403
36b010bf 1404 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1405 if (!m) return kFALSE;
67dd5535 1406
36b010bf 1407 Double_t *trans = m->GetTranslation();
67dd5535 1408 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1409
1410 return kTRUE;
1411}
1412
1413//______________________________________________________________________
1414Bool_t AliGeomManager::GetOrigRotation(Int_t index, Double_t r[9])
1415{
1416 // Get the original rotation matrix (ideal geometry)
1417 // for a given module 'index' by quering the TGeoManager
1418
36b010bf 1419 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1420 if (!m) return kFALSE;
67dd5535 1421
36b010bf 1422 Double_t *rot = m->GetRotationMatrix();
67dd5535 1423 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1424
1425 return kTRUE;
1426}
1427
1428//______________________________________________________________________
1429const TGeoHMatrix* AliGeomManager::GetTracking2LocalMatrix(Int_t index)
1430{
25fad4e5 1431 // Get the matrix which transforms from the tracking to the local RS
67dd5535 1432 // The method queries directly the TGeoPNEntry
1433
67dd5535 1434 TGeoPNEntry *pne = GetPNEntry(index);
1435 if (!pne) return NULL;
1436
1437 const TGeoHMatrix *m = pne->GetMatrix();
1438 if (!m)
5aedd709 1439 AliErrorClass(Form("TGeoPNEntry (%s) contains no tracking-to-local matrix !",pne->GetName()));
67dd5535 1440
1441 return m;
1442}
1443
1444//______________________________________________________________________
1445Bool_t AliGeomManager::GetTrackingMatrix(Int_t index, TGeoHMatrix &m)
1446{
1447 // Get the matrix which transforms from the tracking r.s. to
1448 // the global one.
1449 // Returns kFALSE in case of error.
1450
1451 m.Clear();
1452
1453 TGeoHMatrix *m1 = GetMatrix(index);
1454 if (!m1) return kFALSE;
1455
1456 const TGeoHMatrix *m2 = GetTracking2LocalMatrix(index);
1457 if (!m2) return kFALSE;
1458
1459 m = *m1;
1460 m.Multiply(m2);
1461
1462 return kTRUE;
1463}
1464
1465//_____________________________________________________________________________
1466TGeoPNEntry* AliGeomManager::GetPNEntry(Int_t voluid) {
1467 // Returns the TGeoPNEntry for the given global volume ID "voluid"
1468 //
1469 Int_t modId;
1470 ELayerID layerId = VolUIDToLayer(voluid,modId);
1471 return GetPNEntry(layerId,modId);
1472}
1473
1474//_____________________________________________________________________________
67dd5535 1475TGeoPNEntry* AliGeomManager::GetPNEntry(ELayerID layerId, Int_t modId)
1476{
1477 // Returns the TGeoPNEntry for a given layer
1478 // and module ID
1479 //
25fad4e5 1480
67dd5535 1481 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
1482 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
1483 return NULL;
1484 }
1485
1486 return fgPNEntry[layerId-kFirstLayer][modId];
1487}
1488
1489//_____________________________________________________________________________
5590c6c3 1490void AliGeomManager::CheckOverlapsOverPNs(Double_t threshold)
1491{
1492 // Check for overlaps/extrusions on physical nodes only;
1493 // this overlap-checker is meant to be used to check overlaps/extrusions
1494 // originated by the application of alignment objects.
1495 //
1496
1c00c47a 1497 TObjArray* ovexlist = 0x0;
5590c6c3 1498
1499 AliInfoClass("********* Checking overlaps/extrusions over physical nodes only *********");
1500 TObjArray* pnList = gGeoManager->GetListOfPhysicalNodes();
0cd61c1d 1501 TGeoVolume* mvol = 0;
5590c6c3 1502 TGeoPhysicalNode* pn;
1503 TObjArray* overlaps = new TObjArray(64);
1504 overlaps->SetOwner();
1505
1506 TStopwatch timer2;
1507 timer2.Start();
1508 for(Int_t pni=0; pni<pnList->GetEntriesFast(); pni++){
1509 pn = (TGeoPhysicalNode*) pnList->UncheckedAt(pni);
1510 // checking the volume of the mother (go upper in the tree in case it is an assembly)
1511 Int_t levup=1;
1512 while(((TGeoVolume*)pn->GetVolume(pn->GetLevel()-levup))->IsAssembly()) levup++;
1513 //Printf("Going to upper level");
1514 mvol = pn->GetVolume(pn->GetLevel()-levup);
1515 if(!mvol->IsSelected()){
1516 AliInfoClass(Form("Checking overlaps for volume %s",mvol->GetName()));
1517 mvol->CheckOverlaps(threshold);
1518 ovexlist = gGeoManager->GetListOfOverlaps();
1519 TIter next(ovexlist);
1520 TGeoOverlap *ov;
1521 while ((ov=(TGeoOverlap*)next())) overlaps->Add(ov->Clone());
1522 mvol->SelectVolume();
1523 }
1524 }
1525 mvol->SelectVolume(kTRUE); // clears the list of selected volumes
1526
1527 AliInfoClass(Form("Number of overlapping/extruding PNs: %d",overlaps->GetEntriesFast()));
1528 timer2.Stop();
1529 timer2.Print();
1530
1531 TIter nextN(overlaps);
1532 TGeoOverlap *ovlp;
1533 while ((ovlp=(TGeoOverlap*)nextN())) ovlp->PrintInfo();
1534
1535 overlaps->Delete();
1536 delete overlaps;
1537}
1538
1539//_____________________________________________________________________________
4fbb8e9d 1540Int_t AliGeomManager::GetNalignable(const char* module)
8cb26cdf 1541{
a1ecbc97 1542 // Get number of declared alignable volumes in current geometry
1543 // for the given detector "module" passed as a vaild detector name
1544 // if the detector name is invalid return -1
8cb26cdf 1545
4fbb8e9d 1546 // return the detector index corresponding to detector
1547 Int_t index = -1 ;
1548 for (index = 0; index < fgkNDetectors ; index++) {
1549 if ( strcmp(module, fgkDetectorName[index]) == 0 )
1550 break ;
1551 }
a1ecbc97 1552 if(index==fgkNDetectors) return -1;
4fbb8e9d 1553 return fgNalignable[index];
8cb26cdf 1554}
4fbb8e9d 1555
1556//_____________________________________________________________________________
1557void AliGeomManager::InitNalignable()
1558{
1559 // Set number of declared alignable volumes for given detector in current geometry
1560 // by looping on the list of PNEntries
1561 //
1562
1563 Int_t nAlE = gGeoManager->GetNAlignable(); // total number of alignable entries
1564 TGeoPNEntry *pne = 0;
4fbb8e9d 1565 const char* detName;
1566
1567 for (Int_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1568 detName = fgkDetectorName[iDet];
1569 Int_t nAlDet = 0;
1570
1571 for(Int_t iE = 0; iE < nAlE; iE++)
1572 {
1573 pne = gGeoManager->GetAlignableEntry(iE);
3564f2da 1574 TString pneName = pne->GetName();
1575 if(pneName.Contains(detName)) nAlDet++;
1576 if(!strcmp(detName,"GRP")) if(pneName.Contains("ABSO") || pneName.Contains("DIPO") ||
1577 pneName.Contains("FRAME") || pneName.Contains("PIPE") ||
1578 pneName.Contains("SHIL")) nAlDet++;
4fbb8e9d 1579 }
1580 fgNalignable[iDet] = nAlDet;
1581 }
8cb26cdf 1582
4fbb8e9d 1583}
1584
8cb26cdf 1585//_____________________________________________________________________________
67dd5535 1586Bool_t AliGeomManager::ApplyAlignObjsFromCDB(const char* AlignDetsList)
1587{
1588 // Calls AddAlignObjsFromCDBSingleDet for the detectors appearing in
1589 // the list passed as argument (called by AliSimulation and
1590 // AliReconstruction)
1591 // Read the alignment objects from CDB.
1592 // Each detector is supposed to have the
1593 // alignment objects in DET/Align/Data CDB path.
1594 // All the detector objects are then collected,
1595 // sorted by geometry level (starting from ALIC) and
1596 // then applied to the TGeo geometry.
1597 // Finally an overlaps check is performed.
1598 //
1599
36b010bf 1600 TObjArray alignObjArray;
1601 alignObjArray.Clear();
1602 alignObjArray.SetOwner(0);
67dd5535 1603
1604 TString alObjsNotLoaded="";
1605 TString alObjsLoaded="";
1606
1607 TString AlignDetsString(AlignDetsList);
1608 TObjArray *detsarr = AlignDetsString.Tokenize(' ');
1609 TIter iter(detsarr);
1610 TObjString *str = 0;
1611
1612 while((str = (TObjString*) iter.Next())){
1613 TString det(str->String());
2912a163 1614 AliDebugClass(5,Form("Loading alignment objs for %s",det.Data()));
36b010bf 1615 if(!LoadAlignObjsFromCDBSingleDet(det.Data(),alignObjArray)){
67dd5535 1616 alObjsNotLoaded += det.Data();
1617 alObjsNotLoaded += " ";
1618 } else {
1619 alObjsLoaded += det.Data();
1620 alObjsLoaded += " ";
1621 }
1622 }
b80b98e1 1623 detsarr->Delete();
1624 delete detsarr;
67dd5535 1625
36b010bf 1626 if(!alObjsLoaded.IsNull()) AliInfoClass(Form("Alignment objects loaded for: %s",
1627 alObjsLoaded.Data()));
451cbb1d 1628 if(!alObjsNotLoaded.IsNull())
1629 AliFatalClass(Form("Could not load alignment objects from OCDB for: %s",
36b010bf 1630 alObjsNotLoaded.Data()));
67dd5535 1631
9cb4fe0b 1632 return ApplyAlignObjsToGeom(alignObjArray);
67dd5535 1633}
1634
1635//_____________________________________________________________________________
36b010bf 1636Bool_t AliGeomManager::LoadAlignObjsFromCDBSingleDet(const char* detName, TObjArray& alignObjArray)
67dd5535 1637{
1638 // Adds the alignable objects found in the CDBEntry for the detector
1639 // passed as argument to the array of all alignment objects to be applyed
1640 // to geometry
1641 //
1642 // Fills array of single detector's alignable objects from CDB
1643
36b010bf 1644 AliDebugClass(2, Form("Loading alignment objs for detector: %s",detName));
67dd5535 1645
1646 AliCDBEntry *entry;
1647
1648 AliCDBPath path(detName,"Align","Data");
1649
1650 entry=AliCDBManager::Instance()->Get(path.GetPath());
1651 if(!entry){
36b010bf 1652 AliDebugClass(2,Form("Couldn't load alignment data for detector %s",detName));
67dd5535 1653 return kFALSE;
1654 }
1655 entry->SetOwner(1);
1656 TClonesArray *alignArray = (TClonesArray*) entry->GetObject();
1657 alignArray->SetOwner(0);
4fbb8e9d 1658 Int_t nAlObjs = alignArray->GetEntries();
1659 AliDebugClass(2,Form("Found %d alignment objects for %s",nAlObjs,detName));
1660 Int_t nAlVols = GetNalignable(detName);
1661 if(nAlObjs!=nAlVols) AliWarningClass(Form("%d alignment objects loaded for %s, which has %d alignable volumes",nAlObjs,detName,GetNalignable(detName)));
67dd5535 1662
1663 AliAlignObj *alignObj=0;
1664 TIter iter(alignArray);
1665
1666 // loop over align objects in detector
1667 while( ( alignObj=(AliAlignObj *) iter.Next() ) ){
36b010bf 1668 alignObjArray.Add(alignObj);
67dd5535 1669 }
1670 // delete entry --- Don't delete, it is cached!
1671
36b010bf 1672 AliDebugClass(2, Form("fAlignObjArray entries: %d",alignObjArray.GetEntries() ));
67dd5535 1673 return kTRUE;
1674
1675}
1676
1677//_____________________________________________________________________________
5590c6c3 1678Bool_t AliGeomManager::ApplyAlignObjsToGeom(TObjArray& alignObjArray, Bool_t ovlpcheck)
67dd5535 1679{
c8687cb5 1680 // Read collection of alignment objects (AliAlignObj derived) saved
1681 // in the TClonesArray alObjArray and apply them to gGeoManager
1682 //
1683 alignObjArray.Sort();
1684 Int_t nvols = alignObjArray.GetEntriesFast();
67dd5535 1685
c8687cb5 1686 Bool_t flag = kTRUE;
67dd5535 1687
c8687cb5 1688 for(Int_t j=0; j<nvols; j++)
67dd5535 1689 {
c8687cb5 1690 AliAlignObj* alobj = (AliAlignObj*) alignObjArray.UncheckedAt(j);
1691 if(!alobj->ApplyToGeometry(ovlpcheck))
1692 {
1693 flag = kFALSE;
1694 AliDebugClass(5,Form("Error applying alignment object for volume %s !",alobj->GetSymName()));
1695 }else{
1696 AliDebugClass(5,Form("Alignment object for volume %s applied successfully",alobj->GetSymName()));
1697 }
67dd5535 1698
c8687cb5 1699 }
bb1970d8 1700
c8687cb5 1701 if (AliDebugLevelClass() > 5) {
1702 fgGeometry->CheckOverlaps(0.001);
1703 TObjArray* ovexlist = fgGeometry->GetListOfOverlaps();
1704 if(ovexlist->GetEntriesFast()){
1705 AliErrorClass("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
1706 fgGeometry->PrintOverlaps();
1707 }
1708 }
67dd5535 1709
c8687cb5 1710 // Update the TGeoPhysicalNodes
1711 fgGeometry->RefreshPhysicalNodes();
36b010bf 1712
c8687cb5 1713 return flag;
67dd5535 1714
1715}
1716
1717//_____________________________________________________________________________
1718Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* fileName, const char* clArrayName)
1719{
1720 // read collection of alignment objects (AliAlignObj derived) saved
1721 // in the TClonesArray ClArrayName in the file fileName and apply
1722 // them to the geometry
1723 //
1724
1725 TFile* inFile = TFile::Open(fileName,"READ");
1726 if (!inFile || !inFile->IsOpen()) {
1727 AliErrorClass(Form("Could not open file %s !",fileName));
1728 return kFALSE;
1729 }
1730
36b010bf 1731 TClonesArray* alignObjArray = ((TClonesArray*) inFile->Get(clArrayName));
67dd5535 1732 inFile->Close();
36b010bf 1733 if (!alignObjArray) {
67dd5535 1734 AliErrorClass(Form("Could not get array (%s) from file (%s) !",clArrayName,fileName));
1735 return kFALSE;
1736 }
1737
36b010bf 1738 return ApplyAlignObjsToGeom(*alignObjArray);
67dd5535 1739
1740}
1741
1742//_____________________________________________________________________________
67dd5535 1743Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* uri, const char* path, Int_t runnum, Int_t version, Int_t sversion)
1744{
1745 // read collection of alignment objects (AliAlignObj derived) saved
1746 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1747 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1748 // to the geometry
1749 //
1750
5078a13f 1751 AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage(uri);
67dd5535 1752 AliCDBId id(path, runnum, runnum, version, sversion);
5078a13f 1753 AliCDBEntry* entry = storage->Get(id);
1754 TClonesArray* alignObjArray = dynamic_cast<TClonesArray*>(entry->GetObject());
67dd5535 1755
5078a13f 1756 return ApplyAlignObjsToGeom(*alignObjArray);
67dd5535 1757
1758}
1759
1760//_____________________________________________________________________________
1761Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* detName, Int_t runnum, Int_t version, Int_t sversion)
1762{
1763 // read collection of alignment objects (AliAlignObj derived) saved
1764 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1765 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1766 // to the geometry
1767 //
1768
1769 AliCDBPath path(detName,"Align","Data");
1770 AliCDBEntry* entry = AliCDBManager::Instance()->Get(path.GetPath(),runnum,version,sversion);
1771
1772 if(!entry) return kFALSE;
36b010bf 1773 TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
25fad4e5 1774
36b010bf 1775 return ApplyAlignObjsToGeom(*alignObjArray);
67dd5535 1776}
171c4ef9 1777
3564f2da 1778//_____________________________________________________________________________
1779void AliGeomManager::ResetPNEntriesLUT()
1780{
1781 // cleans static arrays containing the information on currently loaded geometry
1782 //
1783 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
1784 if (!fgPNEntry[iLayer]) continue;
1785 for (Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++) fgPNEntry[iLayer][modnum] = 0;
1786 }
1787 //
1788}
1789