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