- Disentangle masks effect from trigger chamber efficiency estimation.
[u/mrichter/AliRoot.git] / MUON / AliMUONGeometryBuilder.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *      SigmaEffect_thetadegrees                                                                  *
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 purpeateose. It is      *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 // $Id$
17
18 //-----------------------------------------------------------------------------
19 // Class AliMUONGeometryBuilder
20 // ----------------------------
21 // Manager class for geometry construction via geometry builders.
22 // Author: Ivana Hrivnacova, IPN Orsay
23 //-----------------------------------------------------------------------------
24
25 #include "AliMUONGeometryBuilder.h"
26 #include "AliMUONVGeometryBuilder.h"    
27 #include "AliMUONGeometry.h"
28 #include "AliMUONGeometryTransformer.h"
29 #include "AliMUONGeometryModule.h"      
30 #include "AliMUONGeometryModuleTransformer.h"   
31 #include "AliMUONGeometryEnvelope.h"    
32 #include "AliMUONGeometryEnvelopeStore.h"
33 #include "AliMUONGeometryDetElement.h"
34 #include "AliMUONGeometryConstituent.h"
35
36 #include "AliMpDEManager.h"
37
38 #include "AliModule.h"
39 #include "AliSimulation.h"
40 #include "AliLog.h"
41 #include "AliRun.h"
42
43 #include <TObjArray.h>
44 #include <TVirtualMC.h>
45 #include <TGeoManager.h>
46
47 /// \cond CLASSIMP
48 ClassImp(AliMUONGeometryBuilder)
49 /// \endcond
50
51 //
52 // static functions
53 //
54
55 //______________________________________________________________________________
56 const TString& AliMUONGeometryBuilder::GetDefaultTransformFileName()
57 {
58   ///< default transformations file name                                     
59   static const TString kDefaultTransformFileName = "transform.dat";   
60   return kDefaultTransformFileName;
61 }    
62
63 //______________________________________________________________________________
64 const TString& AliMUONGeometryBuilder::GetDefaultSVMapFileName() 
65 {
66   ///< default svmaps file name                                      
67   static const TString kDefaultSVMapFileName = "svmap.dat";    
68   return kDefaultSVMapFileName;
69 }    
70
71 //______________________________________________________________________________
72 const TString& AliMUONGeometryBuilder::GetOutFileNameExtension()
73 {
74   ///< default output file name extension                                    
75   static const TString kOutFileNameExtension = ".out";    
76   return kOutFileNameExtension;
77 }    
78
79
80 //______________________________________________________________________________
81 TGeoHMatrix AliMUONGeometryBuilder::Multiply(const TGeoMatrix& m1, 
82                                              const TGeoMatrix& m2)
83 {
84 /// Temporary fix for problem with matrix multiplication in Root 5.02/00
85
86   if (m1.IsIdentity() && m2.IsIdentity()) return TGeoHMatrix();
87   
88   if (m1.IsIdentity()) return m2;
89   
90   if (m2.IsIdentity()) return m1;
91   
92   return m1 * m2;
93 }
94
95 //______________________________________________________________________________
96 TGeoHMatrix AliMUONGeometryBuilder::Multiply(const TGeoMatrix& m1, 
97                                              const TGeoMatrix& m2,
98                                              const TGeoMatrix& m3)
99 {                                            
100 /// Temporary fix for problem with matrix multiplication in Root 5.02/00
101
102   if (m1.IsIdentity() && m2.IsIdentity() & m3.IsIdentity())  
103     return TGeoHMatrix();
104   
105   if (m1.IsIdentity()) return Multiply(m2, m3);
106   
107   if (m2.IsIdentity()) return Multiply(m1, m3);
108   
109   if (m3.IsIdentity()) return Multiply(m1, m2);
110   
111   return m1 * m2 * m3;
112 }
113
114 //______________________________________________________________________________
115 TGeoHMatrix AliMUONGeometryBuilder::Multiply(const TGeoMatrix& m1, 
116                                              const TGeoMatrix& m2,
117                                              const TGeoMatrix& m3,
118                                              const TGeoMatrix& m4)
119 {                                            
120 /// Temporary fix for problem with matrix multiplication in Root 5.02/00
121
122   if (m1.IsIdentity() && m2.IsIdentity() & m3.IsIdentity() & m4.IsIdentity())  
123     return TGeoHMatrix();
124   
125   if (m1.IsIdentity()) return Multiply(m2, m3, m4);
126   
127   if (m2.IsIdentity()) return Multiply(m1, m3, m4);
128   
129   if (m3.IsIdentity()) return Multiply(m1, m2, m4);
130   
131   if (m4.IsIdentity()) return Multiply(m1, m2, m3);
132   
133   return m1 * m2 * m3 * m4;
134 }
135
136 //
137 // ctors, dtor
138 //
139
140 //______________________________________________________________________________
141 AliMUONGeometryBuilder::AliMUONGeometryBuilder(AliModule* module)
142   : TObject(),
143     fModule(module),
144     fAlign(false),
145     fTransformFileName(GetDefaultTransformFileName()),
146     fSVMapFileName(GetDefaultSVMapFileName()),
147     fGlobalTransformation(), 
148     fGeometryBuilders(0),
149     fGeometry(0)
150 {
151 /// Standard constructor
152
153   fGeometryBuilders = new TObjArray();
154   fGeometryBuilders->SetOwner(true);
155   
156   fGeometry = new AliMUONGeometry(true);
157
158   // Define the global transformation:
159   // Transformation from the old ALICE coordinate system to a new one:
160   // x->-x, z->-z 
161   TGeoRotation* rotGlobal 
162     = new TGeoRotation("rotGlobal", 90., 180., 90., 90., 180., 0.);
163   fGlobalTransformation = TGeoCombiTrans(0., 0., 0., rotGlobal);
164 }
165
166 //______________________________________________________________________________
167 AliMUONGeometryBuilder::AliMUONGeometryBuilder() 
168   : TObject(),
169     fModule(0),
170     fAlign(false),
171     fTransformFileName(),
172     fSVMapFileName(),
173     fGlobalTransformation(),
174     fGeometryBuilders(0),
175     fGeometry(0)
176 {
177 /// Default constructor
178
179
180 //______________________________________________________________________________
181 AliMUONGeometryBuilder::~AliMUONGeometryBuilder()
182 {
183 /// Destructor
184   
185   delete fGeometryBuilders;
186   delete fGeometry;
187 }
188
189 //
190 // private functions
191 //
192
193 //______________________________________________________________________________
194 void AliMUONGeometryBuilder::PlaceVolume(const TString& name, const TString& mName, 
195                             Int_t copyNo, const TGeoHMatrix& matrix, 
196                             Int_t npar, Double_t* param, const char* only,
197                             Bool_t makeAssembly) const
198 {
199 /// Place the volume specified by name with the given transformation matrix
200
201   if (makeAssembly)
202     gGeoManager->MakeVolumeAssembly(name.Data());
203
204   TGeoHMatrix transform(matrix);
205   // Do not apply global transformation 
206   // if mother volume was already placed in 
207   // the new system of coordinates (that is MUON in negative Z)
208   // (as it is applied on the mother volume)
209   if (mName == TString("DDIP"))
210     transform = fGlobalTransformation.Inverse() * transform;
211      
212   // Decompose transformation
213   const Double_t* xyz = transform.GetTranslation();
214   const Double_t* rm = transform.GetRotationMatrix();
215         
216   //cout << "Got translation: "
217   //     << xyz[0] << " " << xyz[1] << " " << xyz[2] << endl;
218         
219   //cout << "Got rotation: "
220   //     << rm[0] << " " << rm[1] << " " << rm[2] << endl
221   //     << rm[3] << " " << rm[4] << " " << rm[5] << endl
222   //     << rm[6] << " " << rm[7] << " " << rm[8] << endl;
223
224   // Check for presence of rotation
225   // (will be nice to be available in TGeo)
226   const Double_t kTolerance = 1e-04;
227   Bool_t isRotation = true; 
228   if (TMath::Abs(rm[0] - 1.) < kTolerance &&
229       TMath::Abs(rm[1] - 0.) < kTolerance &&
230       TMath::Abs(rm[2] - 0.) < kTolerance &&
231       TMath::Abs(rm[3] - 0.) < kTolerance &&
232       TMath::Abs(rm[4] - 1.) < kTolerance &&
233       TMath::Abs(rm[5] - 0.) < kTolerance &&
234       TMath::Abs(rm[6] - 0.) < kTolerance &&
235       TMath::Abs(rm[7] - 0.) < kTolerance &&
236       TMath::Abs(rm[8] - 1.) < kTolerance) isRotation = false; 
237
238   Int_t krot = 0;
239   if (isRotation) {
240     TGeoRotation rot;
241     rot.SetMatrix(const_cast<Double_t*>(transform.GetRotationMatrix()));
242     Double_t theta1, phi1, theta2, phi2, theta3, phi3;
243     rot.GetAngles(theta1, phi1, theta2, phi2, theta3, phi3);
244         
245     //cout << "angles: " 
246     //     << theta1 << " " << phi1 << " "
247     //     << theta2 << " " << phi2 << " "
248     //     << theta3 << " " << phi3 << endl;
249         
250     fModule->AliMatrix(krot, theta1, phi1, theta2, phi2, theta3, phi3);
251   }     
252         
253   // Place the volume
254   if (npar == 0)
255     gMC->Gspos(name, copyNo, mName, xyz[0], xyz[1], xyz[2] , krot, only);
256   else 
257     gMC->Gsposp(name, copyNo, mName, xyz[0], xyz[1], xyz[2] , krot, only,
258                 param, npar);
259
260
261 //______________________________________________________________________________
262 void AliMUONGeometryBuilder::CreateGeometryWithTGeo()
263 {
264 /// Construct geometry using geometry builders.
265 /// Virtual modules/envelopes are placed as TGeoVolume assembly
266
267   if (fAlign) {
268     // Read transformations from ASCII data file  
269     fGeometry->GetTransformer()
270       ->LoadGeometryData(fTransformFileName);
271   }    
272  
273   for (Int_t i=0; i<fGeometryBuilders->GetEntriesFast(); i++) {
274
275     // Get the builder
276     AliMUONVGeometryBuilder* builder
277       = (AliMUONVGeometryBuilder*)fGeometryBuilders->At(i);
278
279     // Create geometry + envelopes
280     //
281     builder->CreateGeometry();
282     builder->SetVolumes();
283     if (!fAlign) builder->SetTransformations();
284     
285     // Place module volumes and envelopes
286     //
287     for (Int_t j=0; j<builder->NofGeometries(); j++) {
288
289       AliMUONGeometryModule* geometry = builder->Geometry(j);
290       AliMUONGeometryModuleTransformer* transformer= geometry->GetTransformer();
291       const TGeoHMatrix* kModuleTransform = transformer->GetTransformation();
292       TString volName       = transformer->GetVolumeName(); 
293       TString motherVolName = transformer->GetMotherVolumeName(); 
294       
295       // Place the module volume
296       PlaceVolume(volName, motherVolName, 
297                   1, *kModuleTransform, 0, 0, "ONLY", geometry->IsVirtual());
298   
299       TGeoCombiTrans appliedGlobalTransform;
300       if (builder->ApplyGlobalTransformation())
301         appliedGlobalTransform = fGlobalTransformation;
302
303       // Loop over envelopes
304       const TObjArray* kEnvelopes 
305         = geometry->GetEnvelopeStore()->GetEnvelopes();
306       for (Int_t k=0; k<kEnvelopes->GetEntriesFast(); k++) {
307
308         // Get envelope
309         AliMUONGeometryEnvelope* env 
310           = (AliMUONGeometryEnvelope*)kEnvelopes->At(k);
311           
312         // Check consistency of detElemId and module Id
313         if ( env->GetUniqueID() > 0 && 
314              AliMpDEManager::GetGeomModuleId(env->GetUniqueID()) 
315              != geometry->GetModuleId() ) {
316              
317           AliErrorStream() 
318             << "Detection element " << env->GetUniqueID() 
319             << " is being placed in geometry module " << geometry->GetModuleId()
320             << " but should go in " 
321             << AliMpDEManager::GetGeomModuleId(env->GetUniqueID())
322             <<  endl;
323           AliFatal("Inconsistent IDs");
324         }          
325           
326         const TGeoCombiTrans* kEnvTrans = env->GetTransformation();
327         const char* only = "ONLY";
328         if (env->IsMANY()) only = "MANY";
329
330         if (env->IsVirtual() && env->GetConstituents()->GetEntriesFast() == 0 ) {
331           // virtual envelope + nof constituents = 0 
332           //         => not allowed;
333           //            empty virtual envelope has no sense 
334           AliFatal("Virtual envelope must have constituents.");
335           return;
336         }
337
338         if (!env->IsVirtual() && env->GetConstituents()->GetEntriesFast() > 0 ) {
339           // non virtual envelope + nof constituents > 0 
340           //        => not allowed;
341           //           use VMC to place constituents
342           AliFatal("Non virtual envelope cannot have constituents.");
343           return;
344         }
345
346         // Place envelope in geometry module by composed transformation:
347         // [Tglobal] * Tenv
348         TGeoHMatrix total 
349           = Multiply( appliedGlobalTransform, 
350                      (*kEnvTrans) );
351         PlaceVolume(env->GetName(), volName,
352                     env->GetCopyNo(), total, 0, 0, only, env->IsVirtual());
353         
354         if ( env->IsVirtual() )  {
355           //  Place constituents in the envelope
356           for  (Int_t l=0; l<env->GetConstituents()->GetEntriesFast(); l++) {
357             AliMUONGeometryConstituent* constituent
358               = (AliMUONGeometryConstituent*)env->GetConstituents()->At(l);
359  
360             PlaceVolume(constituent->GetName(), env->GetName(),
361                         constituent->GetCopyNo(),
362                         *constituent->GetTransformation() ,
363                         constituent->GetNpar(), constituent->GetParam(), only);
364           }
365         }
366       } // end of loop over envelopes
367     } // end of loop over builder geometries
368   } // end of loop over builders
369 }
370
371 //______________________________________________________________________________
372 void AliMUONGeometryBuilder::CreateGeometryWithoutTGeo()
373 {
374 /// Construct geometry using geometry builders.
375 /// Virtual modules/envelopes are not placed
376
377   if (fAlign) {
378     // Read transformations from ASCII data file  
379     fGeometry->GetTransformer()->LoadGeometryData(fTransformFileName);
380   }     
381
382   for (Int_t i=0; i<fGeometryBuilders->GetEntriesFast(); i++) {
383
384     // Get the builder
385     AliMUONVGeometryBuilder* builder
386       = (AliMUONVGeometryBuilder*)fGeometryBuilders->At(i);
387
388     // Create geometry + envelopes
389     //
390     builder->CreateGeometry();
391     if (!fAlign) builder->SetTransformations();
392     
393     // Place module volumes and envelopes
394     //
395     for (Int_t j=0; j<builder->NofGeometries(); j++) {
396
397       AliMUONGeometryModule* geometry = builder->Geometry(j);
398       AliMUONGeometryModuleTransformer* transformer= geometry->GetTransformer();
399       const TGeoHMatrix* kModuleTransform = transformer->GetTransformation();
400       TString volName       = transformer->GetVolumeName(); 
401       TString motherVolName = transformer->GetMotherVolumeName(); 
402       
403       // Place the module volume
404       if ( !geometry->IsVirtual() ) {
405           PlaceVolume(volName, motherVolName, 
406                       1, *kModuleTransform, 0, 0, "ONLY");
407       }               
408   
409       TGeoCombiTrans appliedGlobalTransform;
410       if (builder->ApplyGlobalTransformation())
411         appliedGlobalTransform = fGlobalTransformation;
412
413       // Loop over envelopes
414       const TObjArray* kEnvelopes 
415         = geometry->GetEnvelopeStore()->GetEnvelopes();
416       for (Int_t k=0; k<kEnvelopes->GetEntriesFast(); k++) {
417
418         // Get envelope
419         AliMUONGeometryEnvelope* env 
420           = (AliMUONGeometryEnvelope*)kEnvelopes->At(k);
421           
422         // Check consistency of detElemId and module Id
423         if ( env->GetUniqueID() > 0 && 
424              AliMpDEManager::GetGeomModuleId(env->GetUniqueID()) 
425              != geometry->GetModuleId() ) {
426              
427           AliErrorStream() 
428             << "Detection element " << env->GetUniqueID() 
429             << " is being placed in geometry module " << geometry->GetModuleId()
430             << " but should go in " 
431             << AliMpDEManager::GetGeomModuleId(env->GetUniqueID())
432             <<  endl;
433           AliFatal("Inconsistent IDs");
434         }          
435           
436         const TGeoCombiTrans* kEnvTrans = env->GetTransformation();
437         const char* only = "ONLY";
438         if (env->IsMANY()) only = "MANY";
439
440         if (env->IsVirtual() && env->GetConstituents()->GetEntriesFast() == 0 ) {
441           // virtual envelope + nof constituents = 0 
442           //         => not allowed;
443           //            empty virtual envelope has no sense 
444           AliFatal("Virtual envelope must have constituents.");
445           return;
446         }
447
448         if (!env->IsVirtual() && env->GetConstituents()->GetEntriesFast() > 0 ) {
449           // non virtual envelope + nof constituents > 0 
450           //        => not allowed;
451           //           use VMC to place constituents
452           AliFatal("Non virtual envelope cannot have constituents.");
453           return;
454         }
455
456         if (!env->IsVirtual() && env->GetConstituents()->GetEntriesFast() == 0 ) {
457           // non virtual envelope + nof constituents = 0 
458           //        => place envelope by composed transformation:
459           //           Tch * [Tglobal] * Tenv
460
461           // Compound chamber transformation with the envelope one
462           if (geometry->IsVirtual()) {
463              TGeoHMatrix total 
464                = Multiply( (*kModuleTransform), 
465                             appliedGlobalTransform, 
466                            (*kEnvTrans) );
467              PlaceVolume(env->GetName(), motherVolName,
468                          env->GetCopyNo(), total, 0, 0, only);
469           }
470           else {
471              TGeoHMatrix total 
472                = Multiply( appliedGlobalTransform, 
473                            (*kEnvTrans) );
474              PlaceVolume(env->GetName(), volName,
475                          env->GetCopyNo(), total, 0, 0, only);
476           }                      
477         }
478
479         if (env->IsVirtual() && env->GetConstituents()->GetEntriesFast() > 0 ) {
480           // virtual envelope + nof constituents > 0 
481           //         => do not place envelope and place constituents
482           //            by composed transformation:
483           //            Tch * [Tglobal] * Tenv * Tconst   
484
485           for  (Int_t l=0; l<env->GetConstituents()->GetEntriesFast(); l++) {
486             AliMUONGeometryConstituent* constituent
487               = (AliMUONGeometryConstituent*)env->GetConstituents()->At(l);
488  
489             // Compound chamber transformation with the envelope one + the constituent one
490             if (geometry->IsVirtual()) {
491               TGeoHMatrix total 
492                 = Multiply ( (*kModuleTransform),
493                              appliedGlobalTransform, 
494                              (*kEnvTrans), 
495                              (*constituent->GetTransformation()) );
496
497               PlaceVolume(constituent->GetName(), motherVolName,
498                           constituent->GetCopyNo(), total,
499                           constituent->GetNpar(), constituent->GetParam(), only);
500             }
501             else {                        
502               TGeoHMatrix total 
503                 = Multiply ( appliedGlobalTransform, 
504                              (*kEnvTrans),
505                              (*constituent->GetTransformation()) );
506
507               PlaceVolume(constituent->GetName(), volName,
508                           constituent->GetCopyNo(), total,
509                           constituent->GetNpar(), constituent->GetParam(), only);
510             }                     
511           }
512         }
513       } // end of loop over envelopes
514     } // end of loop over builder geometries
515   } // end of loop over builders
516 }
517
518 //_____________________________________________________________________________
519 void AliMUONGeometryBuilder::SetAlignToBuilder(AliMUONVGeometryBuilder* builder) const
520 {
521 /// Set align option to all geometry modules associated with the builder
522
523   for (Int_t j=0; j<builder->NofGeometries(); j++) {
524
525     AliMUONGeometryModule* geometry = builder->Geometry(j);
526   
527     geometry->SetAlign(fAlign);
528   }       
529 }            
530
531 //
532 // public functions
533 //
534
535 //_____________________________________________________________________________
536 void AliMUONGeometryBuilder::AddBuilder(AliMUONVGeometryBuilder* geomBuilder)
537 {
538 /// Add the geometry builder to the list
539
540   fGeometryBuilders->Add(geomBuilder);
541   
542   // Pass geometry modules created in the to the geometry parametrisation
543   for (Int_t i=0; i<geomBuilder->NofGeometries(); i++) {
544     fGeometry->AddModule(geomBuilder->Geometry(i));
545   }  
546   
547   if (geomBuilder->ApplyGlobalTransformation())
548     geomBuilder->SetReferenceFrame(fGlobalTransformation);
549   
550   SetAlignToBuilder(geomBuilder);
551 }
552
553 //______________________________________________________________________________
554 void AliMUONGeometryBuilder::CreateGeometry()
555 {
556 /// Construct geometry using geometry builders.
557
558   if ( gMC->IsRootGeometrySupported() ) {
559        
560    CreateGeometryWithTGeo();
561   } 
562   else
563    CreateGeometryWithoutTGeo();
564
565   for (Int_t i=0; i<fGeometryBuilders->GetEntriesFast(); i++) {
566
567     // Get the builder
568     AliMUONVGeometryBuilder* builder
569       = (AliMUONVGeometryBuilder*)fGeometryBuilders->At(i);
570  
571     // Update detection elements from built geometry
572     Bool_t create = ! fAlign;
573     builder->UpdateDetElements(create);
574   }
575 }
576
577 //_____________________________________________________________________________
578 void AliMUONGeometryBuilder::CreateMaterials()
579 {
580 /// Construct materials specific to modules via builders
581   
582   for (Int_t i=0; i<fGeometryBuilders->GetEntriesFast(); i++) {
583
584     // Get the builder
585     AliMUONVGeometryBuilder* builder
586       = (AliMUONVGeometryBuilder*)fGeometryBuilders->At(i);
587
588     // Create materials with each builder
589     if (builder) builder->CreateMaterials();
590   }
591 }
592
593 //______________________________________________________________________________
594 void AliMUONGeometryBuilder::InitGeometry(const TString& svmapFileName)
595 {
596 /// Initialize geometry
597
598   // Load alignement data from geometry if geometry is read from Root file
599   if ( AliSimulation::Instance()->IsGeometryFromFile() ) {
600     fAlign = true;
601     fGeometry->GetTransformer()->LoadGeometryData();
602  }    
603
604   // Read sensitive volume map from a file
605   fGeometry->ReadSVMap(svmapFileName);
606
607   // Set the chamber (sensitive region) GEANT identifier
608   //
609   for (Int_t i=0; i<fGeometryBuilders->GetEntriesFast(); i++) {
610
611     // Get the builder
612     AliMUONVGeometryBuilder* builder
613       = (AliMUONVGeometryBuilder*)fGeometryBuilders->At(i);
614
615     // Set sensitive volumes with each builder
616     builder->SetSensitiveVolumes();
617   }  
618 }
619
620 //________________________________________________________________
621 void AliMUONGeometryBuilder::UpdateInternalGeometry()
622 {
623 /// Update geometry after applying mis-alignment:
624 /// reload transformations in geometry builder.
625
626   fGeometry->GetTransformer()->LoadTransformations();
627 }
628
629 //______________________________________________________________________________
630 void AliMUONGeometryBuilder::WriteSVMaps(const TString& fileName, 
631                                          Bool_t rebuild, Bool_t writeEnvelopes)
632 {
633 /// Write sensitive volume maps into files per builder
634
635   // Rebuild sv maps
636   //
637   if (rebuild) 
638     for (Int_t i=0; i<fGeometryBuilders->GetEntriesFast(); i++) {
639
640       AliMUONVGeometryBuilder* builder
641         = (AliMUONVGeometryBuilder*)fGeometryBuilders->At(i);
642
643       builder->RebuildSVMaps(writeEnvelopes);
644     }  
645     
646   // Write maps in file
647   fGeometry->WriteSVMap(fileName);
648 }
649
650 //_____________________________________________________________________________
651 void AliMUONGeometryBuilder::SetAlign(Bool_t align)
652
653 /// Set the option for alignement
654
655   fAlign = align; 
656
657   for (Int_t i=0; i<fGeometryBuilders->GetEntriesFast(); i++) {
658
659     AliMUONVGeometryBuilder* builder
660       = (AliMUONVGeometryBuilder*)fGeometryBuilders->At(i);
661     
662     SetAlignToBuilder(builder); 
663   }   
664 }
665
666 //_____________________________________________________________________________
667 void AliMUONGeometryBuilder::SetAlign(const TString& fileName, Bool_t align)
668
669 /// Set the option for alignement and the transformations file name
670
671   fTransformFileName = fileName;
672   fAlign = align; 
673
674   for (Int_t i=0; i<fGeometryBuilders->GetEntriesFast(); i++) {
675
676     AliMUONVGeometryBuilder* builder
677       = (AliMUONVGeometryBuilder*)fGeometryBuilders->At(i);
678     
679     SetAlignToBuilder(builder); 
680   }   
681 }