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