]>
Commit | Line | Data |
---|---|---|
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 | // $Id$ | |
17 | ||
18 | //----------------------------------------------------------------------------- | |
19 | // Class AliMUONVGeometryBuilder | |
20 | // ----------------------------- | |
21 | // Abstract base class for geometry construction per geometry module(s). | |
22 | // Author: Ivana Hrivnacova, IPN Orsay | |
23 | // 23/01/2004 | |
24 | //----------------------------------------------------------------------------- | |
25 | ||
26 | #include "AliMUONVGeometryBuilder.h" | |
27 | #include "AliMUONGeometryModule.h" | |
28 | #include "AliMUONGeometryDetElement.h" | |
29 | #include "AliMUONGeometryEnvelopeStore.h" | |
30 | #include "AliMUONGeometryEnvelope.h" | |
31 | #include "AliMUONGeometryConstituent.h" | |
32 | #include "AliMUONGeometryBuilder.h" | |
33 | #include "AliMUONStringIntMap.h" | |
34 | ||
35 | #include "AliMpDEManager.h" | |
36 | #include "AliMpExMap.h" | |
37 | ||
38 | #include "AliLog.h" | |
39 | ||
40 | #include <Riostream.h> | |
41 | #include <TObjArray.h> | |
42 | #include <TSystem.h> | |
43 | #include <TGeoMatrix.h> | |
44 | #include <TVirtualMC.h> | |
45 | ||
46 | /// \cond CLASSIMP | |
47 | ClassImp(AliMUONVGeometryBuilder) | |
48 | /// \endcond | |
49 | ||
50 | //______________________________________________________________________________ | |
51 | AliMUONVGeometryBuilder::AliMUONVGeometryBuilder( | |
52 | Int_t firstModuleId, | |
53 | Int_t nofModules) | |
54 | : TObject(), | |
55 | fGeometryModules(0), | |
56 | fReferenceFrame() | |
57 | { | |
58 | /// Standard constructor | |
59 | ||
60 | // Create the module geometries array | |
61 | fGeometryModules = new TObjArray(); | |
62 | fGeometryModules->SetOwner(kFALSE); | |
63 | ||
64 | for (Int_t i=0; i<nofModules; i++ ) | |
65 | fGeometryModules->Add(new AliMUONGeometryModule(firstModuleId++)); | |
66 | } | |
67 | ||
68 | //______________________________________________________________________________ | |
69 | AliMUONVGeometryBuilder::AliMUONVGeometryBuilder() | |
70 | : TObject(), | |
71 | fGeometryModules(0), | |
72 | fReferenceFrame() | |
73 | { | |
74 | /// Default constructor | |
75 | } | |
76 | ||
77 | //______________________________________________________________________________ | |
78 | AliMUONVGeometryBuilder::~AliMUONVGeometryBuilder() | |
79 | { | |
80 | /// Destructor | |
81 | ||
82 | if (fGeometryModules) { | |
83 | fGeometryModules->Clear(); // Sets pointers to 0 since it is not the owner | |
84 | delete fGeometryModules; | |
85 | } | |
86 | } | |
87 | ||
88 | // | |
89 | // private methods | |
90 | // | |
91 | ||
92 | //______________________________________________________________________________ | |
93 | TGeoHMatrix | |
94 | AliMUONVGeometryBuilder::ConvertTransform(const TGeoHMatrix& transform) const | |
95 | { | |
96 | /// Convert transformation into the reference frame | |
97 | ||
98 | if ( fReferenceFrame.IsIdentity() ) | |
99 | return transform; | |
100 | else { | |
101 | return AliMUONGeometryBuilder::Multiply( fReferenceFrame, | |
102 | transform, | |
103 | fReferenceFrame.Inverse() ); | |
104 | } | |
105 | } | |
106 | ||
107 | //______________________________________________________________________________ | |
108 | TGeoHMatrix | |
109 | AliMUONVGeometryBuilder::ConvertDETransform(const TGeoHMatrix& transform) const | |
110 | { | |
111 | /// Convert DE transformation into the reference frame | |
112 | ||
113 | if ( fReferenceFrame.IsIdentity() ) | |
114 | return transform; | |
115 | else { | |
116 | return AliMUONGeometryBuilder::Multiply( fReferenceFrame, | |
117 | transform ); | |
118 | } | |
119 | } | |
120 | ||
121 | //______________________________________________________________________________ | |
122 | TString AliMUONVGeometryBuilder::ComposePath(const TString& volName, | |
123 | Int_t copyNo) const | |
124 | { | |
125 | /// Compose path from given volName and copyNo | |
126 | ||
127 | TString path = "/"; | |
128 | path += volName; | |
129 | path += '_'; | |
130 | path += copyNo; | |
131 | ||
132 | return path; | |
133 | } | |
134 | ||
135 | //______________________________________________________________________________ | |
136 | void AliMUONVGeometryBuilder::MapSV(const TString& path0, | |
137 | const TString& volName, Int_t detElemId) const | |
138 | { | |
139 | /// Update the path with all daughters volumes recursively | |
140 | /// and map it to the detection element Id if it is a sensitive volume | |
141 | ||
142 | // Get module sensitive volumes map | |
143 | Int_t moduleId = AliMpDEManager::GetGeomModuleId(detElemId); | |
144 | AliMUONStringIntMap* svMap = GetSVMap(moduleId); | |
145 | ||
146 | Int_t nofDaughters = gMC->NofVolDaughters(volName); | |
147 | if (nofDaughters == 0) { | |
148 | ||
149 | // Get the name of the last volume in the path | |
150 | Ssiz_t npos1 = path0.Last('/')+1; | |
151 | Ssiz_t npos2 = path0.Last('_'); | |
152 | TString volName0(path0(npos1, npos2-npos1)); | |
153 | ||
154 | // Check if it is sensitive volume | |
155 | AliMUONGeometryModule* geometry = GetGeometry(moduleId); | |
156 | if ( geometry->IsSensitiveVolume(volName0) && | |
157 | ! svMap->Get(path0) ) { | |
158 | //cout << ".. adding to the map " | |
159 | // << path0 << " " << detElemId << endl; | |
160 | ||
161 | // Map the sensitive volume to detection element | |
162 | svMap->Add(path0, detElemId); | |
163 | } | |
164 | return; | |
165 | } | |
166 | ||
167 | for (Int_t i=0; i<nofDaughters; i++) { | |
168 | Int_t copyNo = gMC->VolDaughterCopyNo(volName, i); | |
169 | TString newName = gMC->VolDaughterName(volName, i); | |
170 | ||
171 | TString path = path0; | |
172 | path += ComposePath(newName, copyNo); | |
173 | ||
174 | MapSV(path, newName, detElemId); | |
175 | } | |
176 | } | |
177 | ||
178 | // | |
179 | // protected methods | |
180 | // | |
181 | ||
182 | //______________________________________________________________________________ | |
183 | AliMUONGeometryModule* | |
184 | AliMUONVGeometryBuilder::GetGeometry(Int_t moduleId) const | |
185 | { | |
186 | /// Return the module geometry specified by moduleId | |
187 | ||
188 | for (Int_t i=0; i<fGeometryModules->GetEntriesFast(); i++) { | |
189 | ||
190 | AliMUONGeometryModule* geometry | |
191 | = (AliMUONGeometryModule*)fGeometryModules->At(i); | |
192 | ||
193 | if ( geometry->GetModuleId() == moduleId) return geometry; | |
194 | } | |
195 | ||
196 | return 0; | |
197 | } | |
198 | ||
199 | //______________________________________________________________________________ | |
200 | AliMUONGeometryEnvelopeStore* | |
201 | AliMUONVGeometryBuilder::GetEnvelopes(Int_t moduleId) const | |
202 | { | |
203 | /// Return the envelope store of the module geometry specified by moduleId | |
204 | ||
205 | AliMUONGeometryModule* geometry = GetGeometry(moduleId); | |
206 | ||
207 | if (!geometry) { | |
208 | AliFatal(Form("Module geometry %d is not defined", moduleId)); | |
209 | return 0; | |
210 | } | |
211 | ||
212 | return geometry->GetEnvelopeStore(); | |
213 | } | |
214 | ||
215 | //______________________________________________________________________________ | |
216 | AliMUONStringIntMap* | |
217 | AliMUONVGeometryBuilder::GetSVMap(Int_t moduleId) const | |
218 | { | |
219 | /// Return the transformation store of the module geometry specified by moduleId | |
220 | ||
221 | AliMUONGeometryModule* geometry = GetGeometry(moduleId); | |
222 | ||
223 | if (!geometry) { | |
224 | AliFatal(Form("Geometry %d is not defined", moduleId)); | |
225 | return 0; | |
226 | } | |
227 | ||
228 | return geometry->GetSVMap(); | |
229 | } | |
230 | ||
231 | //______________________________________________________________________________ | |
232 | Int_t | |
233 | AliMUONVGeometryBuilder::GetModuleId(const TString& envName) const | |
234 | { | |
235 | /// Return module Id which has the envelope with given name | |
236 | ||
237 | for (Int_t i=0; i<fGeometryModules->GetEntriesFast(); i++) { | |
238 | ||
239 | AliMUONGeometryModule* geometry | |
240 | = (AliMUONGeometryModule*)fGeometryModules->At(i); | |
241 | ||
242 | if ( geometry->GetEnvelopeStore()->FindEnvelope(envName) ) | |
243 | return geometry->GetModuleId(); | |
244 | } | |
245 | ||
246 | return -1; | |
247 | } | |
248 | ||
249 | ||
250 | //______________________________________________________________________________ | |
251 | void AliMUONVGeometryBuilder::SetTranslation(Int_t moduleId, | |
252 | const TGeoTranslation& translation) | |
253 | { | |
254 | /// Set the translation to the geometry module given by moduleId, | |
255 | /// apply reference frame transformation | |
256 | ||
257 | AliMUONGeometryModule* geometry = GetGeometry(moduleId); | |
258 | ||
259 | if (!geometry) { | |
260 | AliFatal(Form("Geometry %d is not defined", moduleId)); | |
261 | return; | |
262 | } | |
263 | ||
264 | // Apply frame transform | |
265 | TGeoHMatrix newTransform = ConvertTransform(translation); | |
266 | ||
267 | // Set new transformation | |
268 | geometry->SetTransformation(newTransform); | |
269 | } | |
270 | ||
271 | ||
272 | //______________________________________________________________________________ | |
273 | void AliMUONVGeometryBuilder::SetTransformation(Int_t moduleId, | |
274 | const TGeoTranslation& translation, | |
275 | const TGeoRotation& rotation) | |
276 | { | |
277 | /// Set the transformation to the geometry module given by moduleId, | |
278 | /// apply reference frame transformation | |
279 | ||
280 | AliMUONGeometryModule* geometry = GetGeometry(moduleId); | |
281 | ||
282 | if (!geometry) { | |
283 | AliFatal(Form("Geometry %d is not defined", moduleId)); | |
284 | return; | |
285 | } | |
286 | ||
287 | TGeoCombiTrans transformation | |
288 | = TGeoCombiTrans(translation, rotation); | |
289 | ||
290 | // Apply frame transform | |
291 | TGeoHMatrix newTransform = ConvertTransform(transformation); | |
292 | ||
293 | // Set new transformation | |
294 | geometry->SetTransformation(newTransform); | |
295 | } | |
296 | ||
297 | //______________________________________________________________________________ | |
298 | void AliMUONVGeometryBuilder::SetVolume(Int_t moduleId, | |
299 | const TString& volumeName, | |
300 | Bool_t isVirtual) | |
301 | { | |
302 | /// Set volume name, virtuality | |
303 | ||
304 | TString path = GetGeometry(moduleId)->GetVolumePath(); | |
305 | // cout << "in AliMUONVGeometryBuilder::SetVolume " << path.Data() << endl; | |
306 | ||
307 | if ( path == "" ) path = "/ALIC_1"; | |
308 | path += ComposePath(volumeName, 1); | |
309 | ||
310 | GetGeometry(moduleId)->SetVolumePath(path); | |
311 | GetGeometry(moduleId)->SetIsVirtual(isVirtual); | |
312 | // cout << "... set " << path.Data() << endl; | |
313 | } | |
314 | ||
315 | //______________________________________________________________________________ | |
316 | void AliMUONVGeometryBuilder::SetMotherVolume(Int_t moduleId, | |
317 | const TString& volumeName) | |
318 | { | |
319 | /// Set mother volume name | |
320 | ||
321 | TString motherVolumeName = ComposePath(volumeName, 1); | |
322 | ||
323 | TString path = GetGeometry(moduleId)->GetVolumePath(); | |
324 | if ( path == "" ) path = "/ALIC_1"; | |
325 | path.Insert(7, motherVolumeName); | |
326 | ||
327 | GetGeometry(moduleId)->SetVolumePath(path); | |
328 | } | |
329 | ||
330 | // | |
331 | // public functions | |
332 | // | |
333 | ||
334 | //______________________________________________________________________________ | |
335 | void AliMUONVGeometryBuilder::SetReferenceFrame( | |
336 | const TGeoCombiTrans& referenceFrame) | |
337 | { | |
338 | /// Set reference frame to builder and to all associated geometry | |
339 | /// modules | |
340 | ||
341 | fReferenceFrame = referenceFrame; | |
342 | ||
343 | for (Int_t i=0; i<fGeometryModules->GetEntriesFast(); i++) { | |
344 | AliMUONGeometryModule* geometry | |
345 | = (AliMUONGeometryModule*)fGeometryModules->At(i); | |
346 | AliMUONGeometryEnvelopeStore* envelopeStore | |
347 | = geometry->GetEnvelopeStore(); | |
348 | ||
349 | envelopeStore->SetReferenceFrame(referenceFrame); | |
350 | } | |
351 | } | |
352 | ||
353 | //______________________________________________________________________________ | |
354 | void AliMUONVGeometryBuilder::UpdateDetElements(Bool_t create) const | |
355 | { | |
356 | /// Create or update detection elements: | |
357 | /// - if parameter create is true: detection elements are | |
358 | /// created and their global and local transformations are filled from geometry. | |
359 | /// - otherwise: only the volume path is passed from geometry | |
360 | /// to detection elements | |
361 | ||
362 | for (Int_t i=0; i<fGeometryModules->GetEntriesFast(); i++) { | |
363 | AliMUONGeometryModule* geometry | |
364 | = (AliMUONGeometryModule*)fGeometryModules->At(i); | |
365 | ||
366 | const TObjArray* envelopes | |
367 | = geometry->GetEnvelopeStore()->GetEnvelopes(); | |
368 | ||
369 | AliMpExMap* detElements | |
370 | = geometry->GetTransformer()->GetDetElementStore(); | |
371 | ||
372 | for (Int_t j=0; j<envelopes->GetEntriesFast(); j++) { | |
373 | AliMUONGeometryEnvelope* envelope | |
374 | = (AliMUONGeometryEnvelope*)envelopes->At(j); | |
375 | ||
376 | // skip envelope not corresponding to detection element | |
377 | if ( envelope->GetUniqueID() == 0) continue; | |
378 | ||
379 | // Get envelope data | |
380 | Int_t detElemId = envelope->GetUniqueID(); | |
381 | ||
382 | // Compose full volume path | |
383 | TString volPath = geometry->GetVolumePath(); | |
384 | volPath += ComposePath(envelope->GetName(), envelope->GetCopyNo()); | |
385 | ||
386 | if ( create ) { | |
387 | // Create detection element | |
388 | AliMUONGeometryDetElement* detElement | |
389 | = new AliMUONGeometryDetElement(detElemId, volPath); | |
390 | detElements->Add(detElemId, detElement); | |
391 | ||
392 | // Compose local transformation | |
393 | const TGeoCombiTrans* transform = envelope->GetTransformation(); | |
394 | // Apply frame transform | |
395 | TGeoHMatrix localTransform = ConvertDETransform(*transform); | |
396 | detElement->SetLocalTransformation(localTransform); | |
397 | ||
398 | // Compose global transformation | |
399 | TGeoHMatrix globalTransform | |
400 | = AliMUONGeometryBuilder::Multiply( | |
401 | (*geometry->GetTransformer()->GetTransformation()), | |
402 | localTransform ); | |
403 | ; | |
404 | // Set the global transformation to detection element | |
405 | detElement->SetGlobalTransformation(globalTransform); | |
406 | } | |
407 | else { | |
408 | // Get existing det elements | |
409 | AliMUONGeometryDetElement* detElement | |
410 | = (AliMUONGeometryDetElement*)detElements->GetValue(detElemId); | |
411 | ||
412 | // Set volume path | |
413 | detElement->SetVolumePath(volPath); | |
414 | } | |
415 | } | |
416 | } | |
417 | } | |
418 | ||
419 | //_____ _________________________________________________________________________ | |
420 | void AliMUONVGeometryBuilder::RebuildSVMaps(Bool_t withEnvelopes) const | |
421 | { | |
422 | /// Clear the SV maps in memory and fill them from defined geometry. | |
423 | ||
424 | for (Int_t i=0; i<fGeometryModules->GetEntriesFast(); i++) { | |
425 | AliMUONGeometryModule* geometry | |
426 | = (AliMUONGeometryModule*)fGeometryModules->At(i); | |
427 | ||
428 | // Clear the map | |
429 | geometry->GetSVMap()->Clear(); | |
430 | ||
431 | // Fill the map from geometry | |
432 | const TObjArray* envelopes | |
433 | = geometry->GetEnvelopeStore()->GetEnvelopes(); | |
434 | ||
435 | for (Int_t j=0; j<envelopes->GetEntriesFast(); j++) { | |
436 | AliMUONGeometryEnvelope* envelope | |
437 | = (AliMUONGeometryEnvelope*)envelopes->At(j); | |
438 | ||
439 | // skip envelope not corresponding to detection element | |
440 | if ( envelope->GetUniqueID() == 0 ) continue; | |
441 | ||
442 | // Get volume path of detection element | |
443 | AliMUONGeometryDetElement* detElement | |
444 | = geometry->GetTransformer()->GetDetElement(envelope->GetUniqueID()); | |
445 | std::string path0 = detElement->GetVolumePath().Data(); | |
446 | ||
447 | if ( ! withEnvelopes && geometry->IsVirtual() ) { | |
448 | std::string vName = geometry->GetTransformer()->GetVolumeName().Data(); | |
449 | std::string vPath = ComposePath(vName, 1).Data(); | |
450 | std::string::size_type vPathPos = path0.find(vPath); | |
451 | if ( vPathPos != std::string::npos ) | |
452 | path0.erase(vPathPos, vPath.size()); | |
453 | } | |
454 | ||
455 | if ( ! withEnvelopes && envelope->IsVirtual()) { | |
456 | std::string eName = envelope->GetName(); | |
457 | std::string ePath = ComposePath(eName, envelope->GetCopyNo()).Data(); | |
458 | std::string::size_type ePathPos = path0.find(ePath); | |
459 | if ( ePathPos != std::string::npos ) | |
460 | path0.erase(ePathPos, ePath.size()); | |
461 | } | |
462 | ||
463 | if ( ! envelope->IsVirtual() ) | |
464 | MapSV(path0, envelope->GetName(), envelope->GetUniqueID()); | |
465 | else { | |
466 | for (Int_t k=0; k<envelope->GetConstituents()->GetEntriesFast(); k++) { | |
467 | AliMUONGeometryConstituent* constituent | |
468 | = (AliMUONGeometryConstituent*)envelope->GetConstituents()->At(k); | |
469 | TString path = path0; | |
470 | path += ComposePath(constituent->GetName(), constituent->GetCopyNo()); | |
471 | MapSV(path, constituent->GetName(), envelope->GetUniqueID()); | |
472 | } | |
473 | } | |
474 | } | |
475 | } | |
476 | } | |
477 |