MUON/AliMUONGeometryTransformer.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 AliMUONGeometryTransformer
  20 // ----------------------------
  21 // Top container class for geometry transformations
  22 // Author: Ivana Hrivnacova, IPN Orsay
  23
  24 #include "AliMUONGeometryTransformer.h"
  25 #include "AliMUONGeometryModuleTransformer.h"
  26 #include "AliMUONGeometryDetElement.h"
  27 #include "AliMUONGeometryBuilder.h"
  28
  29 #include "AliMpDEManager.h"
  30 #include "AliMpExMap.h"
  31
  32 #include "AliLog.h"
  33 #include "AliAlignObjMatrix.h"
  34 #include "AliAlignObj.h"
  35
  36 #include <Riostream.h>
  37 #include <TSystem.h>
  38 #include <TClonesArray.h>
  39 #include <TGeoManager.h>
  40 #include <TGeoPhysicalNode.h>
  41 #include <TFile.h>
  42
  43 #include <sstream>
  44
  45 /// \cond CLASSIMP
  46 ClassImp(AliMUONGeometryTransformer)
  47 /// \endcond
  48
  49 //______________________________________________________________________________
  50 AliMUONGeometryTransformer::AliMUONGeometryTransformer(Bool_t isOwner,
  51                                           const TString& detectorName)
  52
  53   : TObject(),
  54     fDetectorName(detectorName),
  55     fModuleTransformers(0),
  56     fMisAlignArray(0)
  57 {
  58 /// Standard constructor
  59
  60   // Create array for geometry modules
  61   fModuleTransformers = new TObjArray(100);
  62   fModuleTransformers->SetOwner(isOwner);
  63 }
  64
  65 //______________________________________________________________________________
  66 AliMUONGeometryTransformer::AliMUONGeometryTransformer()
  67   : TObject(),
  68     fDetectorName(),
  69     fModuleTransformers(0),
  70     fMisAlignArray(0)
  71 {
  72 /// Default constructor
  73 }
  74
  75 //______________________________________________________________________________
  76 AliMUONGeometryTransformer::~AliMUONGeometryTransformer()
  77 {
  78 /// Destructor
  79
  80   delete fModuleTransformers;
  81   delete fMisAlignArray;
  82 }
  83
  84 //
  85 // private methods
  86 //
  87
  88 //_____________________________________________________________________________
  89 AliMUONGeometryModuleTransformer*
  90 AliMUONGeometryTransformer::GetModuleTransformerNonConst(
  91                                           Int_t index, Bool_t warn) const
  92 {
  93 /// Return the geometry module specified by index
  94
  95   if (index < 0 || index >= fModuleTransformers->GetEntriesFast()) {
  96     if (warn) {
  97       AliWarningStream()
  98         << "Index: " << index << " outside limits" << std::endl;
  99     }
 100     return 0;
 101   }
 102
 103   return (AliMUONGeometryModuleTransformer*) fModuleTransformers->At(index);
 104 }
 105
 106 //______________________________________________________________________________
 107 TGeoHMatrix AliMUONGeometryTransformer::GetTransform(
 108                   Double_t x, Double_t y, Double_t z,
 109                   Double_t a1, Double_t a2, Double_t a3,
 110                   Double_t a4, Double_t a5, Double_t a6) const
 111 {
 112 /// Build the transformation from the given parameters
 113
 114   // Compose transform
 115   return TGeoCombiTrans(TGeoTranslation(x, y, z),
 116                         TGeoRotation("rot", a1, a2, a3, a4, a5, a6));
 117 }
 118
 119
 120 //______________________________________________________________________________
 121 void AliMUONGeometryTransformer::FillModuleVolPath(Int_t moduleId,
 122                                            const TString& volPath)
 123 {
 124 /// Create module with the given moduleId and volPath
 125
 126   // Get/Create geometry module transformer
 127   AliMUONGeometryModuleTransformer* moduleTransformer
 128     = GetModuleTransformerNonConst(moduleId, false);
 129
 130   if ( !moduleTransformer ) {
 131     moduleTransformer = new AliMUONGeometryModuleTransformer(moduleId);
 132     AddModuleTransformer(moduleTransformer);
 133   }
 134   moduleTransformer->SetVolumePath(volPath);
 135 }
 136
 137 //______________________________________________________________________________
 138 void AliMUONGeometryTransformer::FillDetElemVolPath(Int_t detElemId,
 139                                            const TString& volPath)
 140 {
 141 /// Create detection element with the given detElemId and volPath
 142
 143   // Module Id
 144   Int_t moduleId = AliMpDEManager::GetGeomModuleId(detElemId);
 145
 146   // Get detection element store
 147   AliMpExMap* detElements =
 148     GetModuleTransformer(moduleId)->GetDetElementStore();
 149
 150   // Add detection element
 151   AliMUONGeometryDetElement* detElement
 152     = new AliMUONGeometryDetElement(detElemId, volPath);
 153   detElements->Add(detElemId, detElement);
 154 }
 155
 156
 157 //______________________________________________________________________________
 158 void AliMUONGeometryTransformer::FillModuleTransform(Int_t moduleId,
 159                   Double_t x, Double_t y, Double_t z,
 160                   Double_t a1, Double_t a2, Double_t a3,
 161                   Double_t a4, Double_t a5, Double_t a6)
 162 {
 163 /// Fill the transformation of the module.
 164
 165   AliMUONGeometryModuleTransformer* moduleTransformer
 166     = GetModuleTransformerNonConst(moduleId, false);
 167
 168   if ( !moduleTransformer) {
 169     AliErrorStream()
 170       << "Module " << moduleId << " has not volume path defined." << endl;
 171   }
 172
 173   // Build the transformation from the parameters
 174   TGeoHMatrix transform
 175     = GetTransform(x, y, z, a1, a2, a3, a4, a5, a6);
 176
 177   moduleTransformer->SetTransformation(transform);
 178 }
 179
 180 //______________________________________________________________________________
 181 void AliMUONGeometryTransformer::FillDetElemTransform(
 182                   Int_t detElemId,
 183                   Double_t x, Double_t y, Double_t z,
 184                   Double_t a1, Double_t a2, Double_t a3,
 185                   Double_t a4, Double_t a5, Double_t a6)
 186 {
 187 /// Fill the transformation of the detection element.
 188
 189   // Module Id
 190   Int_t moduleId = AliMpDEManager::GetGeomModuleId(detElemId);
 191
 192   // Get module transformer
 193   const AliMUONGeometryModuleTransformer* kModuleTransformer
 194     = GetModuleTransformer(moduleId);
 195
 196   if ( ! kModuleTransformer ) {
 197     AliFatal(Form("Module transformer not defined, detElemId: %d", detElemId));
 198     return;
 199   }
 200
 201   // Get detection element
 202   AliMUONGeometryDetElement* detElement
 203     = kModuleTransformer->GetDetElement(detElemId);
 204
 205   if ( ! detElement ) {
 206     AliFatal(Form("Det element %d has not volume path defined", detElemId));
 207     return;
 208   }
 209
 210   // Build the transformation from the parameters
 211   TGeoHMatrix localTransform
 212     = GetTransform(x, y, z, a1, a2, a3, a4, a5, a6);
 213   detElement->SetLocalTransformation(localTransform);
 214
 215   // Compute global transformation
 216   TGeoHMatrix globalTransform
 217     = AliMUONGeometryBuilder::Multiply(
 218                                   *kModuleTransformer->GetTransformation(),
 219                                   localTransform );
 220   detElement->SetGlobalTransformation(globalTransform);
 221 }
 222
 223 //______________________________________________________________________________
 224 Bool_t
 225 AliMUONGeometryTransformer::ReadVolPaths(ifstream& in)
 226 {
 227 /// Read modules and detection element volume paths from stream
 228
 229   Int_t id;
 230   TString key, volumePath;
 231   in >> key;
 232
 233   while ( !in.eof() ) {
 234
 235     in >> id >> volumePath;
 236
 237     // cout << "id="     << id << "  "
 238     //   << "volPath= " << volumePath
 239     //   << endl;
 240
 241     if ( key == AliMUONGeometryModuleTransformer::GetModuleNamePrefix() )
 242       FillModuleVolPath(id, volumePath);
 243
 244     else if ( key == AliMUONGeometryDetElement::GetDENamePrefix() )
 245       FillDetElemVolPath(id, volumePath);
 246
 247     else {
 248       AliFatal(Form("%s key not recognized",  key.Data()));
 249       return false;
 250     }
 251     in >> key;
 252   }
 253
 254   return true;
 255 }
 256
 257 //______________________________________________________________________________
 258 TString  AliMUONGeometryTransformer::ReadModuleTransforms(ifstream& in)
 259 {
 260 /// Read and fill modules transformations from the stream.
 261 /// Return true, if reading finished correctly.
 262
 263   TString key(AliMUONGeometryModuleTransformer::GetModuleNamePrefix());
 264   while ( key == AliMUONGeometryModuleTransformer::GetModuleNamePrefix() ) {
 265     Int_t id;
 266     Double_t  x, y, z;
 267     Double_t  a1, a2, a3, a4, a5, a6;
 268     TString dummy;
 269
 270     in >> id;
 271     in >> dummy;
 272     in >> x;
 273     in >> y;
 274     in >> z;
 275     in >> dummy;
 276     in >> a1;
 277     in >> a2;
 278     in >> a3;
 279     in >> a4;
 280     in >> a5;
 281     in >> a6;
 282
 283     //cout << "moduleId="     << id << "  "
 284     //   << "position= " << x << ", " << y << ", " << z << "  "
 285     //   << "rotation= " << a1 << ", " << a2 << ", " << a3  << ", "
 286     //                   << a4 << ", " << a5 << ", " << a6
 287     //   << endl;
 288
 289     // Fill data
 290     FillModuleTransform(id, x, y, z, a1, a2, a3, a4, a5, a6);
 291
 292     // Go to next line
 293     in >> key;
 294   }
 295
 296   return key;
 297 }
 298
 299 //______________________________________________________________________________
 300 TString  AliMUONGeometryTransformer::ReadDetElemTransforms(ifstream& in)
 301 {
 302 /// Read detection elements transformations from the stream.
 303 /// Return true, if reading finished correctly.
 304
 305   TString key(AliMUONGeometryDetElement::GetDENamePrefix());
 306   while ( key == AliMUONGeometryDetElement::GetDENamePrefix() ) {
 307
 308     // Input data
 309     Int_t detElemId;
 310     Double_t  x, y, z;
 311     Double_t  a1, a2, a3, a4, a5, a6;
 312     TString dummy;
 313
 314     in >> detElemId;
 315     in >> dummy;
 316     in >> x;
 317     in >> y;
 318     in >> z;
 319     in >> dummy;
 320     in >> a1;
 321     in >> a2;
 322     in >> a3;
 323     in >> a4;
 324     in >> a5;
 325     in >> a6;
 326
 327     //cout << "detElemId=" << detElemId << "  "
 328     //     << "position= " << x << ", " << y << ", " << z << "  "
 329     //     << "rotation= " << a1 << ", " << a2 << ", " << a3  << ", "
 330     //                     << a4 << ", " << a5 << ", " << a6
 331     //     << endl;
 332
 333     // Fill data
 334     FillDetElemTransform(detElemId, x, y, z, a1, a2, a3, a4, a5, a6);
 335
 336     // Go to next line
 337     in >> key;
 338   }
 339
 340   return key;
 341 }
 342
 343 //______________________________________________________________________________
 344 Bool_t
 345 AliMUONGeometryTransformer::LoadTransforms(TGeoManager* tgeoManager)
 346 {
 347 /// Load transformations for defined modules and detection elements
 348 /// from the root file
 349
 350   if ( !tgeoManager) {
 351     AliFatal("No TGeoManager defined.");
 352     return false;
 353   }
 354
 355   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
 356     AliMUONGeometryModuleTransformer* moduleTransformer
 357       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
 358
 359     // Module path
 360     TString path = moduleTransformer->GetVolumePath();
 361
 362     // Make physical node
 363     TGeoPhysicalNode* moduleNode = tgeoManager->MakePhysicalNode(path);
 364     if ( ! moduleNode ) {
 365       AliErrorStream()
 366         << "Module id: " << moduleTransformer->GetModuleId()
 367         << " volume path: " << path << " not found in geometry." << endl;
 368         return false;
 369     }
 370
 371     // Set matrix from physical node
 372     TGeoHMatrix matrix = *moduleNode->GetMatrix();
 373     moduleTransformer->SetTransformation(matrix);
 374
 375     // Loop over detection elements
 376     AliMpExMap* detElements = moduleTransformer->GetDetElementStore();
 377
 378     for (Int_t j=0; j<detElements->GetSize(); j++) {
 379       AliMUONGeometryDetElement* detElement
 380         = (AliMUONGeometryDetElement*)detElements->GetObject(j);
 381
 382       // Det element path
 383       TString dePath = detElement->GetVolumePath();
 384
 385       // Make physical node
 386       TGeoPhysicalNode* deNode = tgeoManager->MakePhysicalNode(dePath);
 387       if ( ! deNode ) {
 388         AliErrorStream()
 389           << "Det element id: " << detElement->GetId()
 390           << " volume path: " << path << " not found in geometry." << endl;
 391           return false;
 392       }
 393
 394       // Set global matrix from physical node
 395       TGeoHMatrix globalMatrix = *deNode->GetMatrix();
 396       detElement->SetGlobalTransformation(globalMatrix);
 397
 398       // Set local matrix
 399       TGeoHMatrix localMatrix =
 400         AliMUONGeometryBuilder::Multiply(
 401            matrix.Inverse(), globalMatrix );
 402       detElement->SetLocalTransformation(localMatrix);
 403     }
 404   }
 405   return true;
 406 }
 407
 408 //______________________________________________________________________________
 409 Bool_t
 410 AliMUONGeometryTransformer::ReadVolPaths(const TString& fileName)
 411 {
 412 /// Read detection element volume paths from a file.
 413 /// Return true, if reading finished correctly.
 414
 415   // File path
 416   TString filePath = gSystem->Getenv("ALICE_ROOT");
 417   filePath += "/MUON/data/";
 418   filePath += fileName;
 419
 420   // Open input file
 421   ifstream in(filePath, ios::in);
 422   if (!in) {
 423     cerr << filePath << endl;
 424     AliFatal("File not found.");
 425     return false;
 426   }
 427
 428   ReadVolPaths(in);
 429   return true;
 430 }
 431
 432 //______________________________________________________________________________
 433 Bool_t
 434 AliMUONGeometryTransformer::ReadTransformations(const TString& fileName)
 435 {
 436 /// Read transformations from a file.
 437 /// Return true, if reading finished correctly.
 438
 439   // File path
 440   TString filePath = gSystem->Getenv("ALICE_ROOT");
 441   filePath += "/MUON/data/";
 442   filePath += fileName;
 443
 444   // Open input file
 445   ifstream in(filePath, ios::in);
 446   if (!in) {
 447     cerr << filePath << endl;
 448     AliFatal("File not found.");
 449     return false;
 450   }
 451
 452   TString key;
 453   in >> key;
 454   while ( !in.eof() ) {
 455     if ( key == AliMUONGeometryModuleTransformer::GetModuleNamePrefix() )
 456       key = ReadModuleTransforms(in);
 457     else if ( key == AliMUONGeometryDetElement::GetDENamePrefix() )
 458       key = ReadDetElemTransforms(in);
 459     else {
 460       AliFatal(Form("%s key not recognized",  key.Data()));
 461       return false;
 462     }
 463   }
 464
 465   return true;
 466 }
 467
 468 //______________________________________________________________________________
 469 Bool_t
 470 AliMUONGeometryTransformer::ReadTransformations2(const TString& fileName)
 471 {
 472 /// Read transformations from root geometry file.
 473 /// Return true, if reading finished correctly.
 474
 475   // File path
 476   TString filePath = gSystem->Getenv("ALICE_ROOT");
 477   filePath += "/MUON/data/";
 478   filePath += fileName;
 479
 480   // Load root geometry
 481   TGeoManager* tgeoManager = gGeoManager;
 482   if (!tgeoManager)
 483     tgeoManager = TGeoManager::Import(fileName);
 484
 485   // Retrieve matrices
 486   LoadTransforms(tgeoManager);
 487
 488   return true;
 489 }
 490
 491 //______________________________________________________________________________
 492 void AliMUONGeometryTransformer::WriteTransform(ofstream& out,
 493                                    const TGeoMatrix* transform) const
 494 {
 495 /// Write given transformation
 496
 497   out << "   pos: ";
 498   const Double_t* xyz = transform->GetTranslation();
 499   out << setw(10) << setprecision(4) << xyz[0] << "  "
 500       << setw(10) << setprecision(4) << xyz[1] << "  "
 501       << setw(10) << setprecision(4) << xyz[2];
 502
 503   out << "   rot: ";
 504   const Double_t* rm = transform->GetRotationMatrix();
 505   TGeoRotation rotation;
 506   rotation.SetMatrix(const_cast<Double_t*>(rm));
 507   Double_t a1, a2, a3, a4, a5, a6;
 508   rotation.GetAngles(a1, a2, a3, a4, a5, a6);
 509
 510   out << setw(8) << setprecision(4) << a1 << "  "
 511       << setw(8) << setprecision(4) << a2 << "  "
 512       << setw(8) << setprecision(4) << a3 << "  "
 513       << setw(8) << setprecision(4) << a4 << "  "
 514       << setw(8) << setprecision(4) << a5 << "  "
 515       << setw(8) << setprecision(4) << a6 << "  " << endl;
 516 }
 517
 518 //______________________________________________________________________________
 519 void AliMUONGeometryTransformer::WriteModuleVolPaths(ofstream& out) const
 520 {
 521 /// Write module volume paths for all module transformers
 522
 523   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
 524     AliMUONGeometryModuleTransformer* moduleTransformer
 525       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
 526
 527     // Write data on out
 528     out << AliMUONGeometryModuleTransformer::GetModuleNamePrefix() << " "
 529         << setw(4) << moduleTransformer->GetModuleId() << "    "
 530         << moduleTransformer->GetVolumePath() << endl;
 531   }
 532   out << endl;
 533 }
 534
 535 //______________________________________________________________________________
 536 void AliMUONGeometryTransformer::WriteDetElemVolPaths(ofstream& out) const
 537 {
 538 /// Write detection element volume paths for all detection elements in all
 539 /// module transformers
 540
 541   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
 542     AliMUONGeometryModuleTransformer* moduleTransformer
 543       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
 544     AliMpExMap* detElements = moduleTransformer->GetDetElementStore();
 545
 546     for (Int_t j=0; j<detElements->GetSize(); j++) {
 547       AliMUONGeometryDetElement* detElement
 548         = (AliMUONGeometryDetElement*)detElements->GetObject(j);
 549
 550       // Write data on out
 551       out << AliMUONGeometryDetElement::GetDENamePrefix() << " "
 552           << setw(4) << detElement->GetId() << "    "
 553           << detElement->GetVolumePath() << endl;
 554     }
 555     out << endl;
 556   }
 557 }
 558
 559 //______________________________________________________________________________
 560 void AliMUONGeometryTransformer::WriteModuleTransforms(ofstream& out) const
 561 {
 562 /// Write module transformations for all module transformers
 563
 564   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
 565     AliMUONGeometryModuleTransformer* moduleTransformer
 566       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
 567     const TGeoMatrix* transform
 568       = moduleTransformer->GetTransformation();
 569
 570     // Write data on out
 571     out << AliMUONGeometryModuleTransformer::GetModuleNamePrefix() << " "
 572         << setw(4) << moduleTransformer->GetModuleId();
 573
 574     WriteTransform(out, transform);
 575   }
 576   out << endl;
 577 }
 578
 579 //______________________________________________________________________________
 580 void AliMUONGeometryTransformer::WriteDetElemTransforms(ofstream& out) const
 581 {
 582 /// Write detection element transformations for all detection elements in all
 583 /// module transformers
 584
 585   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
 586     AliMUONGeometryModuleTransformer* moduleTransformer
 587       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
 588     AliMpExMap* detElements = moduleTransformer->GetDetElementStore();
 589
 590     for (Int_t j=0; j<detElements->GetSize(); j++) {
 591       AliMUONGeometryDetElement* detElement
 592         = (AliMUONGeometryDetElement*)detElements->GetObject(j);
 593       const TGeoMatrix* transform
 594         = detElement->GetLocalTransformation();
 595
 596       // Write data on out
 597       out << AliMUONGeometryDetElement::GetDENamePrefix() << " "
 598           << setw(4) << detElement->GetId();
 599
 600       WriteTransform(out, transform);
 601     }
 602     out << endl;
 603   }
 604 }
 605
 606 //______________________________________________________________________________
 607 TString AliMUONGeometryTransformer::GetModuleSymName(Int_t moduleId) const
 608 {
 609 /// Return the module symbolic name (use for alignment)
 610
 611   const AliMUONGeometryModuleTransformer* kTransformer
 612     = GetModuleTransformer(moduleId);
 613   if ( ! kTransformer ) {
 614     AliErrorStream() << "Module " << moduleId << " not found." << endl;
 615     return "";
 616   }
 617
 618   return "/" + fDetectorName + "/" + kTransformer->GetModuleName();
 619 }
 620
 621 //______________________________________________________________________________
 622 TString AliMUONGeometryTransformer::GetDESymName(Int_t detElemId) const
 623 {
 624 /// Return the detection element symbolic name (used for alignment)
 625
 626   const AliMUONGeometryDetElement* kDetElement
 627     = GetDetElement(detElemId);
 628   if ( ! kDetElement ) {
 629     AliErrorStream() << "Det element " << detElemId << " not found." << endl;
 630     return "";
 631   }
 632
 633   // Module Id
 634   Int_t moduleId = AliMpDEManager::GetGeomModuleId(detElemId);
 635
 636   return GetModuleSymName(moduleId) + "/" + kDetElement->GetDEName();
 637 }
 638
 639 //
 640 // public functions
 641 //
 642
 643 //______________________________________________________________________________
 644 Bool_t
 645 AliMUONGeometryTransformer::ReadGeometryData(
 646                                 const TString& volPathFileName,
 647                                 const TString& transformFileName)
 648 {
 649 /// Read geometry data from given files;
 650 /// if transformFileName has ".root" extension, the transformations
 651 /// are loaded from root geometry file, otherwise ASCII file
 652 /// format is supposed
 653
 654   Bool_t result1 = ReadVolPaths(volPathFileName);
 655
 656   // Get file extension
 657   std::string fileName = transformFileName.Data();
 658   std::string rootExt = fileName.substr(fileName.size()-5, fileName.size());
 659   Bool_t result2;
 660   if ( rootExt != ".root" )
 661     result2 = ReadTransformations(transformFileName);
 662   else
 663     result2 = ReadTransformations2(transformFileName);
 664
 665   return result1 && result2;
 666 }
 667
 668 //______________________________________________________________________________
 669 Bool_t
 670 AliMUONGeometryTransformer::ReadGeometryData(
 671                                 const TString& volPathFileName,
 672                                 TGeoManager* tgeoManager)
 673 {
 674 /// Load geometry data from root geometry using defined
 675 /// volume paths from file
 676
 677   Bool_t result1 = ReadVolPaths(volPathFileName);
 678
 679   Bool_t result2 = LoadTransforms(tgeoManager);
 680
 681   return result1 && result2;
 682 }
 683
 684 //______________________________________________________________________________
 685 Bool_t
 686 AliMUONGeometryTransformer::WriteGeometryData(
 687                                  const TString& volPathFileName,
 688                                  const TString& transformFileName,
 689                                  const TString& misalignFileName) const
 690 {
 691 /// Write geometry data into given files
 692
 693   Bool_t result1 = WriteVolumePaths(volPathFileName);
 694   Bool_t result2 = WriteTransformations(transformFileName);
 695
 696   Bool_t result3 = true;
 697   if ( misalignFileName != "" )
 698     result3 = WriteMisAlignmentData(misalignFileName);
 699
 700   return result1 && result2 && result3;
 701 }
 702
 703 //______________________________________________________________________________
 704 Bool_t
 705 AliMUONGeometryTransformer::WriteVolumePaths(const TString& fileName) const
 706 {
 707 /// Write volume paths for modules and detection element volumes into a file.
 708 /// Return true, if writing finished correctly.
 709
 710   // No writing
 711   // if builder is not associated with any geometry module
 712   if (fModuleTransformers->GetEntriesFast() == 0) return false;
 713
 714   // File path
 715   TString filePath = gSystem->Getenv("ALICE_ROOT");
 716   filePath += "/MUON/data/";
 717   filePath += fileName;
 718
 719   // Open output file
 720   ofstream out(filePath, ios::out);
 721   if (!out) {
 722     cerr << filePath << endl;
 723     AliError("File not found.");
 724     return false;
 725   }
 726 #if !defined (__DECCXX)
 727   out.setf(std::ios::fixed);
 728 #endif
 729   WriteModuleVolPaths(out);
 730   WriteDetElemVolPaths(out);
 731
 732   return true;
 733 }
 734
 735 //______________________________________________________________________________
 736 Bool_t
 737 AliMUONGeometryTransformer::WriteTransformations(const TString& fileName) const
 738 {
 739 /// Write transformations into a file.
 740 /// Return true, if writing finished correctly.
 741
 742   // No writing
 743   // if builder is not associated with any geometry module
 744   if (fModuleTransformers->GetEntriesFast() == 0) return false;
 745
 746   // File path
 747   TString filePath = gSystem->Getenv("ALICE_ROOT");
 748   filePath += "/MUON/data/";
 749   filePath += fileName;
 750
 751   // Open output file
 752   ofstream out(filePath, ios::out);
 753   if (!out) {
 754     cerr << filePath << endl;
 755     AliError("File not found.");
 756     return false;
 757   }
 758 #if !defined (__DECCXX)
 759   out.setf(std::ios::fixed);
 760 #endif
 761   WriteModuleTransforms(out);
 762   WriteDetElemTransforms(out);
 763
 764   return true;
 765 }
 766
 767 //______________________________________________________________________________
 768 Bool_t
 769 AliMUONGeometryTransformer::WriteMisAlignmentData(const TString& fileName) const
 770 {
 771 /// Write misalignment data into a file
 772 /// Return true, if writing finished correctly.
 773
 774   // No writing
 775   // if builder is not associated with any geometry module
 776   if ( fModuleTransformers->GetEntriesFast() == 0 ) {
 777     AliWarningStream() << "No geometry modules defined." << endl;
 778     return false;
 779   }
 780
 781   // No writing
 782   // if builder has no mis-alignment data
 783   if ( ! fMisAlignArray ) {
 784     AliWarningStream() << "No mis-alignment data defined." << endl;
 785     return false;
 786   }
 787
 788   // File path
 789   TString filePath = gSystem->Getenv("ALICE_ROOT");
 790   filePath += "/MUON/data/";
 791   filePath += fileName;
 792
 793   // Write mis-alignment data in the root file
 794   TFile file(fileName.Data(), "RECREATE");
 795   fMisAlignArray->Write();
 796   file.Close();
 797
 798   return true;
 799 }
 800
 801 //_____________________________________________________________________________
 802 void AliMUONGeometryTransformer::AddModuleTransformer(
 803                           AliMUONGeometryModuleTransformer* moduleTransformer)
 804 {
 805 /// Add the module transformer to the array
 806
 807   // Expand the size if not sufficient
 808   Int_t moduleId = moduleTransformer->GetModuleId();
 809   if (  moduleId >= fModuleTransformers->GetSize() )
 810     fModuleTransformers->Expand(moduleId+1);
 811
 812   fModuleTransformers->AddAt(moduleTransformer, moduleId);
 813 }
 814
 815 //_____________________________________________________________________________
 816 void  AliMUONGeometryTransformer::AddMisAlignModule(Int_t moduleId,
 817                                               const TGeoHMatrix& matrix)
 818 {
 819 /// Build AliAlignObjMatrix with module ID, its volumePath
 820 /// and the given delta transformation matrix
 821
 822   if ( ! fMisAlignArray )
 823     fMisAlignArray = new TClonesArray("AliAlignObjMatrix", 200);
 824
 825   const AliMUONGeometryModuleTransformer* kTransformer
 826     = GetModuleTransformer(moduleId);
 827   if ( ! kTransformer ) {
 828     AliErrorStream() << "Module " << moduleId << " not found." << endl;
 829     return;
 830   }
 831
 832   // Get unique align object ID
 833   Int_t volId = AliAlignObj::LayerToVolUID(AliAlignObj::kMUON, moduleId);
 834
 835   // Create mis align matrix
 836   TClonesArray& refArray =*fMisAlignArray;
 837   Int_t pos = fMisAlignArray->GetEntriesFast();
 838   new (refArray[pos]) AliAlignObjMatrix(GetModuleSymName(moduleId), volId,
 839                                         const_cast<TGeoHMatrix&>(matrix),kTRUE);
 840 }
 841
 842 //_____________________________________________________________________________
 843 void  AliMUONGeometryTransformer::AddMisAlignDetElement(Int_t detElemId,
 844                                               const TGeoHMatrix& matrix)
 845 {
 846 /// Build AliAlignObjMatrix with detection element ID, its volumePath
 847 /// and the given delta transformation matrix
 848
 849   if ( ! fMisAlignArray )
 850     fMisAlignArray = new TClonesArray("AliAlignObjMatrix", 200);
 851
 852   const AliMUONGeometryDetElement* kDetElement
 853     = GetDetElement(detElemId);
 854
 855   if ( ! kDetElement ) {
 856     AliErrorStream() << "Det element " << detElemId << " not found." << endl;
 857     return;
 858   }
 859
 860   // Get unique align object ID
 861   Int_t volId = AliAlignObj::LayerToVolUID(AliAlignObj::kMUON, detElemId);
 862
 863   // Create mis align matrix
 864   TClonesArray& refArray =*fMisAlignArray;
 865   Int_t pos = fMisAlignArray->GetEntriesFast();
 866   new(refArray[pos]) AliAlignObjMatrix(GetDESymName(detElemId), volId,
 867                                        const_cast<TGeoHMatrix&>(matrix),kTRUE);
 868 }
 869
 870 //_____________________________________________________________________________
 871 void AliMUONGeometryTransformer::AddAlignableVolumes() const
 872 {
 873 /// Set symbolic names to alignable objects to TGeo
 874
 875   if ( ! gGeoManager ) {
 876     AliWarning("TGeoManager not defined.");
 877     return;
 878   }
 879
 880   // Modules
 881   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
 882     AliMUONGeometryModuleTransformer* module
 883       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
 884
 885     // Set module symbolic name
 886     gGeoManager->SetAlignableEntry(GetModuleSymName(module->GetModuleId()),
 887                                    module->GetVolumePath());
 888     //cout << "Module sym name: " << GetModuleSymName(module->GetModuleId())
 889     //     << "  volPath: " << module->GetVolumePath() << endl;
 890
 891     // Detection elements
 892     AliMpExMap* detElements = module->GetDetElementStore();
 893
 894     for (Int_t j=0; j<detElements->GetSize(); j++) {
 895       AliMUONGeometryDetElement* detElement
 896         = (AliMUONGeometryDetElement*)detElements->GetObject(j);
 897
 898       // Set detection element symbolic name
 899       gGeoManager->SetAlignableEntry(GetDESymName(detElement->GetId()),
 900                                      detElement->GetVolumePath());
 901       //cout << "DE name: " << GetDESymName(detElement->GetId())
 902       //     << "  volPath: " << detElement->GetVolumePath() << endl;
 903     }
 904   }
 905 }
 906
 907 //_____________________________________________________________________________
 908 TClonesArray* AliMUONGeometryTransformer::CreateZeroAlignmentData() const
 909 {
 910 /// Create array with zero alignment data
 911
 912   // Create array for zero-alignment objects
 913   TClonesArray* array = new TClonesArray("AliAlignObjMatrix", 200);
 914   TClonesArray& refArray =*array;
 915   array->SetOwner(true);
 916
 917   // Identity matrix
 918   TGeoHMatrix matrix;
 919
 920   // Modules
 921   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
 922     AliMUONGeometryModuleTransformer* module
 923       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
 924
 925     Int_t moduleId = module->GetModuleId();
 926
 927     // Align object ID
 928     Int_t volId = AliAlignObj::LayerToVolUID(AliAlignObj::kMUON, moduleId);
 929
 930     // Create mis align matrix
 931     Int_t pos = array->GetEntriesFast();
 932     new (refArray[pos]) AliAlignObjMatrix(GetModuleSymName(moduleId), volId, matrix, kTRUE);
 933   }
 934
 935   // Detection elements
 936   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
 937     AliMUONGeometryModuleTransformer* moduleTransformer
 938       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
 939     AliMpExMap* detElements = moduleTransformer->GetDetElementStore();
 940
 941     for (Int_t j=0; j<detElements->GetSize(); j++) {
 942       AliMUONGeometryDetElement* detElement
 943         = (AliMUONGeometryDetElement*)detElements->GetObject(j);
 944
 945       Int_t detElemId = detElement->GetId();
 946
 947       // Align object ID
 948       Int_t volId = AliAlignObj::LayerToVolUID(AliAlignObj::kMUON, detElemId);
 949
 950       // Create mis align matrix
 951       Int_t pos = array->GetEntriesFast();
 952       new (refArray[pos]) AliAlignObjMatrix(GetDESymName(detElemId), volId, matrix, kTRUE);
 953     }
 954   }
 955
 956   return array;
 957 }
 958
 959 //_____________________________________________________________________________
 960 void AliMUONGeometryTransformer::Global2Local(Int_t detElemId,
 961                  Float_t xg, Float_t yg, Float_t zg,
 962                  Float_t& xl, Float_t& yl, Float_t& zl) const
 963 {
 964 /// Transform point from the global reference frame (ALIC)
 965 /// to the local reference frame of the detection element specified
 966 /// by detElemId.
 967
 968   const AliMUONGeometryModuleTransformer* kTransformer
 969     = GetModuleTransformerByDEId(detElemId);
 970
 971   if (kTransformer)
 972     kTransformer->Global2Local(detElemId, xg, yg, zg, xl, yl, zl);
 973 }
 974
 975 //_____________________________________________________________________________
 976 void AliMUONGeometryTransformer::Global2Local(Int_t detElemId,
 977                  Double_t xg, Double_t yg, Double_t zg,
 978                  Double_t& xl, Double_t& yl, Double_t& zl) const
 979 {
 980 /// Transform point from the global reference frame (ALIC)
 981 /// to the local reference frame of the detection element specified
 982 /// by detElemId.
 983
 984   const AliMUONGeometryModuleTransformer* kTransformer
 985     = GetModuleTransformerByDEId(detElemId);
 986
 987   if (kTransformer)
 988     kTransformer->Global2Local(detElemId, xg, yg, zg, xl, yl, zl);
 989 }
 990
 991 //_____________________________________________________________________________
 992 void AliMUONGeometryTransformer::Local2Global(Int_t detElemId,
 993                  Float_t xl, Float_t yl, Float_t zl,
 994                  Float_t& xg, Float_t& yg, Float_t& zg) const
 995 {
 996 /// Transform point from the local reference frame of the detection element
 997 /// specified by detElemId to the global reference frame (ALIC).
 998
 999   const AliMUONGeometryModuleTransformer* kTransformer
1000     = GetModuleTransformerByDEId(detElemId);
1001
1002   if (kTransformer)
1003     kTransformer->Local2Global(detElemId, xl, yl, zl, xg, yg, zg);
1004 }
1005
1006 //_____________________________________________________________________________
1007 void AliMUONGeometryTransformer::Local2Global(Int_t detElemId,
1008                  Double_t xl, Double_t yl, Double_t zl,
1009                  Double_t& xg, Double_t& yg, Double_t& zg) const
1010 {
1011 /// Transform point from the local reference frame of the detection element
1012 /// specified by detElemId to the global reference frame (ALIC).
1013
1014   const AliMUONGeometryModuleTransformer* kTransformer
1015     = GetModuleTransformerByDEId(detElemId);
1016
1017   if (kTransformer)
1018     kTransformer->Local2Global(detElemId, xl, yl, zl, xg, yg, zg);
1019 }
1020
1021 //_____________________________________________________________________________
1022 const AliMUONGeometryModuleTransformer*
1023 AliMUONGeometryTransformer::GetModuleTransformer(Int_t index, Bool_t warn) const
1024 {
1025 /// Return the geometry module transformer specified by index
1026
1027   return GetModuleTransformerNonConst(index, warn);
1028 }
1029
1030 //_____________________________________________________________________________
1031 const AliMUONGeometryModuleTransformer*
1032 AliMUONGeometryTransformer::GetModuleTransformerByDEId(Int_t detElemId,
1033                                                        Bool_t warn) const
1034 {
1035 /// Return the geometry module transformer specified by detection element ID
1036
1037   // Get module index
1038   Int_t index = AliMpDEManager::GetGeomModuleId(detElemId);
1039
1040   return GetModuleTransformer(index, warn);
1041 }
1042
1043 //_____________________________________________________________________________
1044 const AliMUONGeometryDetElement*
1045 AliMUONGeometryTransformer::GetDetElement(Int_t detElemId, Bool_t warn) const
1046 {
1047 /// Return detection element with given detElemId
1048
1049   const AliMUONGeometryModuleTransformer* kTransformer
1050     = GetModuleTransformerByDEId(detElemId, warn);
1051
1052   if (!kTransformer) return 0;
1053
1054   return kTransformer->GetDetElement(detElemId, warn);
1055 }
1056
1057 //_____________________________________________________________________________
1058 Bool_t  AliMUONGeometryTransformer::HasDE(Int_t detElemId) const
1059 {
1060 /// Return true if detection element with given detElemId is defined
1061
1062   const AliMUONGeometryModuleTransformer* kTransformer
1063     = GetModuleTransformerByDEId(detElemId, false);
1064
1065   if (!kTransformer) return false;
1066
1067   return ( kTransformer->GetDetElement(detElemId, false) != 0 );
1068 }
1069
1070