**************************************************************************/
// $Id$
-//
-// ----------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMUONGeometryTransformer
// ----------------------------
// Top container class for geometry transformations
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONGeometryTransformer.h"
#include "AliMUONGeometryModuleTransformer.h"
#include "AliMUONGeometryDetElement.h"
-#include "AliMUONGeometryStore.h"
#include "AliMUONGeometryBuilder.h"
+#include "AliMpDEManager.h"
+#include "AliMpConstants.h"
+#include "AliMpExMap.h"
+#include "AliMpCDB.h"
+#include "AliMpArea.h"
+#include <float.h>
+#include "AliMpVPadIterator.h"
+#include "AliMpPad.h"
+#include "AliMpDEIterator.h"
+#include <TVector2.h>
+#include "AliMpVSegmentation.h"
+#include "AliMpSegmentation.h"
+#include "AliMpExMapIterator.h"
#include "AliLog.h"
#include "AliAlignObjMatrix.h"
#include "AliAlignObj.h"
#include <TGeoManager.h>
#include <TGeoPhysicalNode.h>
#include <TFile.h>
+#include <TString.h>
#include <sstream>
+/// \cond CLASSIMP
ClassImp(AliMUONGeometryTransformer)
+/// \endcond
+
+const TString AliMUONGeometryTransformer::fgkDefaultDetectorName = "MUON";
//______________________________________________________________________________
-AliMUONGeometryTransformer::AliMUONGeometryTransformer(Bool_t isOwner)
+AliMUONGeometryTransformer::AliMUONGeometryTransformer()
+
: TObject(),
+ fDetectorName(fgkDefaultDetectorName),
fModuleTransformers(0),
- fMisAlignArray(0)
+ fMisAlignArray(0),
+ fDEAreas(0x0)
{
/// Standard constructor
// Create array for geometry modules
- fModuleTransformers = new TObjArray();
- fModuleTransformers->SetOwner(isOwner);
+ fModuleTransformers = new TObjArray(100);
+ fModuleTransformers->SetOwner(true);
}
//______________________________________________________________________________
-AliMUONGeometryTransformer::AliMUONGeometryTransformer()
+AliMUONGeometryTransformer::AliMUONGeometryTransformer(TRootIOCtor* /*ioCtor*/)
: TObject(),
+ fDetectorName(),
fModuleTransformers(0),
- fMisAlignArray(0)
+ fMisAlignArray(0),
+ fDEAreas(0x0)
{
/// Default constructor
}
-//______________________________________________________________________________
-AliMUONGeometryTransformer::AliMUONGeometryTransformer(
- const AliMUONGeometryTransformer& right)
- : TObject(right)
-{
-/// Copy constructor (not implemented)
-
- AliFatal("Copy constructor not provided.");
-}
-
//______________________________________________________________________________
AliMUONGeometryTransformer::~AliMUONGeometryTransformer()
{
delete fModuleTransformers;
delete fMisAlignArray;
+ delete fDEAreas;
}
-//______________________________________________________________________________
-AliMUONGeometryTransformer&
-AliMUONGeometryTransformer::operator=(const AliMUONGeometryTransformer& right)
+//
+// private methods
+//
+
+
+//_____________________________________________________________________________
+AliMpArea*
+AliMUONGeometryTransformer::GetDEArea(Int_t detElemId) const
+{
+ /// Get area (in global coordinates) covered by a given detection element
+ if (!fDEAreas)
+ {
+ CreateDEAreas();
+ }
+ return static_cast<AliMpArea*>(fDEAreas->GetValue(detElemId));
+}
+
+//_____________________________________________________________________________
+void
+AliMUONGeometryTransformer::CreateDEAreas() const
{
-/// Assignement operator (not implemented)
+ /// Create DE areas
+
+ fDEAreas = new AliMpExMap;
+
+ AliMpDEIterator it;
+
+ it.First();
- // check assignement to self
- if (this == &right) return *this;
+ /// Generate the DE areas in global coordinates
- AliFatal("Assignement operator not provided.");
+ while ( !it.IsDone() )
+ {
+ Int_t detElemId = it.CurrentDEId();
- return *this;
-}
+ if ( !HasDE(detElemId) ) continue;
+
+ const AliMpVSegmentation* seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0);
+
+ Double_t xg,yg,zg;
+
+ AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
+
+ Double_t xl(0.0), yl(0.0), zl(0.0);
+ Double_t dx(seg->GetDimensionX());
+ Double_t dy(seg->GetDimensionY());
+
+ if ( stationType == AliMp::kStation12 )
+ {
+ Double_t xmin(FLT_MAX);
+ Double_t xmax(-FLT_MAX);
+ Double_t ymin(FLT_MAX);
+ Double_t ymax(-FLT_MAX);
+
+ for ( Int_t icathode = 0; icathode < 2; ++icathode )
+ {
+ const AliMpVSegmentation* cathode
+ = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(icathode));
+
+ AliMpVPadIterator* itp = cathode->CreateIterator();
+
+ itp->First();
+
+ while ( !itp->IsDone() )
+ {
+ AliMpPad pad = itp->CurrentItem();
+ AliMpArea a(pad.GetPositionX(),pad.GetPositionY(),
+ pad.GetDimensionX(), pad.GetDimensionY());
+ xmin = TMath::Min(xmin,a.LeftBorder());
+ xmax = TMath::Max(xmax,a.RightBorder());
+ ymin = TMath::Min(ymin,a.DownBorder());
+ ymax = TMath::Max(ymax,a.UpBorder());
+ itp->Next();
+ }
+
+ delete itp;
+ }
+
+ xl = (xmin+xmax)/2.0;
+ yl = (ymin+ymax)/2.0;
+ dx = (xmax-xmin)/2.0;
+ dy = (ymax-ymin)/2.0;
+
+ Local2Global(detElemId,xl,yl,zl,xg,yg,zg);
+ }
+ else
+ {
+ Local2Global(detElemId,xl,yl,zl,xg,yg,zg);
+ }
+
+ fDEAreas->Add(detElemId,new AliMpArea(xg,yg,dx,dy));
+
+ it.Next();
+ }
+}
-//
-// private methods
-//
+//_____________________________________________________________________________
+Bool_t AliMUONGeometryTransformer::LoadMapping() const
+{
+/// Load mapping from CDB
+
+ if ( ! AliMpCDB::LoadMpSegmentation() )
+ {
+ AliFatal("Could not access mapping from OCDB !");
+ return false;
+ }
+
+ return true;
+}
//_____________________________________________________________________________
AliMUONGeometryModuleTransformer*
Double_t a1, Double_t a2, Double_t a3,
Double_t a4, Double_t a5, Double_t a6) const
{
-// Builds the transformation from the given parameters
-// ---
+/// Build the transformation from the given parameters
// Compose transform
return TGeoCombiTrans(TGeoTranslation(x, y, z),
}
-//______________________________________________________________________________
-void AliMUONGeometryTransformer::FillModuleVolPath(Int_t moduleId,
- const TString& volPath)
-{
-// Create module with the given moduleId and volPath
-// ---
-
- // Get/Create geometry module transformer
- AliMUONGeometryModuleTransformer* moduleTransformer
- = GetModuleTransformerNonConst(moduleId, false);
-
- if ( !moduleTransformer ) {
- moduleTransformer = new AliMUONGeometryModuleTransformer(moduleId);
- AddModuleTransformer(moduleTransformer);
- }
- moduleTransformer->SetVolumePath(volPath);
-}
-
-//______________________________________________________________________________
-void AliMUONGeometryTransformer::FillDetElemVolPath(Int_t detElemId,
- const TString& volPath)
-{
-// Create detection element with the given detElemId and volPath
-
- // Module Id
- Int_t moduleId = AliMUONGeometryStore::GetModuleId(detElemId);
-
- // Get detection element store
- AliMUONGeometryStore* detElements =
- GetModuleTransformer(moduleId)->GetDetElementStore();
-
- // Add detection element
- AliMUONGeometryDetElement* detElement
- = new AliMUONGeometryDetElement(detElemId, volPath);
- detElements->Add(detElemId, detElement);
-}
-
-
//______________________________________________________________________________
void AliMUONGeometryTransformer::FillModuleTransform(Int_t moduleId,
Double_t x, Double_t y, Double_t z,
Double_t a1, Double_t a2, Double_t a3,
Double_t a4, Double_t a5, Double_t a6)
{
-// Fill the transformation of the module.
-// ---
-
- // Get/Create geometry module transformer
- moduleId--;
- // Modules numbers in the file are starting from 1
+/// Fill the transformation of the module.
AliMUONGeometryModuleTransformer* moduleTransformer
= GetModuleTransformerNonConst(moduleId, false);
Double_t a1, Double_t a2, Double_t a3,
Double_t a4, Double_t a5, Double_t a6)
{
-// Fill the transformation of the detection element.
-// ---
+/// Fill the transformation of the detection element.
// Module Id
- Int_t moduleId = AliMUONGeometryStore::GetModuleId(detElemId);
+ Int_t moduleId = AliMpDEManager::GetGeomModuleId(detElemId);
// Get module transformer
const AliMUONGeometryModuleTransformer* kModuleTransformer
detElement->SetGlobalTransformation(globalTransform);
}
-//______________________________________________________________________________
-Bool_t
-AliMUONGeometryTransformer::ReadVolPaths(ifstream& in)
-{
-// Reads modules and detection element volume paths from stream
-// ---
-
- Int_t id;
- TString key, volumePath;
- in >> key;
-
- while ( !in.eof() ) {
-
- in >> id >> volumePath;
-
- // cout << "id=" << id << " "
- // << "volPath= " << volumePath
- // << endl;
-
- if ( key == TString("CH") )
- FillModuleVolPath(id, volumePath);
-
- else if ( key == TString("DE") )
- FillDetElemVolPath(id, volumePath);
-
- else {
- AliFatal(Form("%s key not recognized", key.Data()));
- return false;
- }
- in >> key;
- }
-
- return true;
-}
-
//______________________________________________________________________________
TString AliMUONGeometryTransformer::ReadModuleTransforms(ifstream& in)
{
-// Reads and fills modules transformations from a file
-// Returns true, if reading finished correctly.
-// ---
+/// Read and fill modules transformations from the stream.
+/// Return true, if reading finished correctly.
- TString key("CH");
- while ( key == TString("CH") ) {
+ TString key(AliMUONGeometryModuleTransformer::GetModuleNamePrefix());
+ while ( key == AliMUONGeometryModuleTransformer::GetModuleNamePrefix() ) {
Int_t id;
Double_t x, y, z;
Double_t a1, a2, a3, a4, a5, a6;
//______________________________________________________________________________
TString AliMUONGeometryTransformer::ReadDetElemTransforms(ifstream& in)
{
-// Reads detection elements transformations from a file
-// Returns true, if reading finished correctly.
-// ---
+/// Read detection elements transformations from the stream.
+/// Return true, if reading finished correctly.
- TString key("DE");
- while ( key == TString("DE") ) {
+ TString key(AliMUONGeometryDetElement::GetDENamePrefix());
+ while ( key == AliMUONGeometryDetElement::GetDENamePrefix() ) {
// Input data
Int_t detElemId;
return key;
}
-//______________________________________________________________________________
-Bool_t
-AliMUONGeometryTransformer::LoadTransforms(TGeoManager* tgeoManager)
-{
-/// Loads transformations for defined modules and detection elements
-/// from the root file
-
- if ( !tgeoManager) {
- AliFatal("No TGeoManager defined.");
- return false;
- }
-
- for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
- AliMUONGeometryModuleTransformer* moduleTransformer
- = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
-
- // Module path
- TString path = moduleTransformer->GetVolumePath();
-
- // Make physical node
- TGeoPhysicalNode* moduleNode = tgeoManager->MakePhysicalNode(path);
- if ( ! moduleNode ) {
- AliErrorStream()
- << "Module id: " << moduleTransformer->GetModuleId()
- << " volume path: " << path << " not found in geometry." << endl;
- return false;
- }
-
- // Set matrix from physical node
- TGeoHMatrix matrix = *moduleNode->GetMatrix();
- moduleTransformer->SetTransformation(matrix);
-
- // Loop over detection elements
- AliMUONGeometryStore* detElements
- = moduleTransformer->GetDetElementStore();
-
- for (Int_t j=0; j<detElements->GetNofEntries(); j++) {
- AliMUONGeometryDetElement* detElement
- = (AliMUONGeometryDetElement*)detElements->GetEntry(j);
-
- // Det element path
- TString dePath = detElement->GetVolumePath();
-
- // Make physical node
- TGeoPhysicalNode* deNode = tgeoManager->MakePhysicalNode(dePath);
- if ( ! deNode ) {
- AliErrorStream()
- << "Det element id: " << detElement->GetId()
- << " volume path: " << path << " not found in geometry." << endl;
- return false;
- }
-
- // Set global matrix from physical node
- TGeoHMatrix globalMatrix = *deNode->GetMatrix();
- detElement->SetGlobalTransformation(globalMatrix);
-
- // Set local matrix
- TGeoHMatrix localMatrix =
- AliMUONGeometryBuilder::Multiply(
- matrix.Inverse(), globalMatrix );
- detElement->SetLocalTransformation(localMatrix);
- }
- }
- return true;
-}
-
-//______________________________________________________________________________
-Bool_t
-AliMUONGeometryTransformer::ReadVolPaths(const TString& fileName)
-{
-// Reads detection element volume paths from a file
-// Returns true, if reading finished correctly.
-// ---
-
- // File path
- TString filePath = gSystem->Getenv("ALICE_ROOT");
- filePath += "/MUON/data/";
- filePath += fileName;
-
- // Open input file
- ifstream in(filePath, ios::in);
- if (!in) {
- cerr << filePath << endl;
- AliFatal("File not found.");
- return false;
- }
-
- ReadVolPaths(in);
- return true;
-}
-
//______________________________________________________________________________
Bool_t
AliMUONGeometryTransformer::ReadTransformations(const TString& fileName)
{
-// Reads transformations from a file
-// Returns true, if reading finished correctly.
-// ---
+/// Read transformations from a file.
+/// Return true, if reading finished correctly.
// File path
TString filePath = gSystem->Getenv("ALICE_ROOT");
TString key;
in >> key;
while ( !in.eof() ) {
- if (key == TString("CH"))
+ if ( key == AliMUONGeometryModuleTransformer::GetModuleNamePrefix() )
key = ReadModuleTransforms(in);
- else if (key == TString("DE"))
+ else if ( key == AliMUONGeometryDetElement::GetDENamePrefix() )
key = ReadDetElemTransforms(in);
else {
AliFatal(Form("%s key not recognized", key.Data()));
return true;
}
-//______________________________________________________________________________
-Bool_t
-AliMUONGeometryTransformer::ReadTransformations2(const TString& fileName)
-{
-// Reads transformations from root geometry file
-// Returns true, if reading finished correctly.
-// ---
-
- // File path
- TString filePath = gSystem->Getenv("ALICE_ROOT");
- filePath += "/MUON/data/";
- filePath += fileName;
-
- // Load root geometry
- TGeoManager* tgeoManager = TGeoManager::Import(fileName);
-
- // Retrieve matrices
- LoadTransforms(tgeoManager);
-
- return true;
-}
-
//______________________________________________________________________________
void AliMUONGeometryTransformer::WriteTransform(ofstream& out,
const TGeoMatrix* transform) const
{
-// Writes the transformations
-// ---
+/// Write given transformation
out << " pos: ";
const Double_t* xyz = transform->GetTranslation();
<< setw(8) << setprecision(4) << a6 << " " << endl;
}
-//______________________________________________________________________________
-void AliMUONGeometryTransformer::WriteModuleVolPaths(ofstream& out) const
-{
-// Write modules volume paths
-
- for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
- AliMUONGeometryModuleTransformer* moduleTransformer
- = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
-
- // Write data on out
- out << "CH "
- << setw(4) << moduleTransformer->GetModuleId() << " "
- << moduleTransformer->GetVolumePath() << endl;
- }
- out << endl;
-}
-
-//______________________________________________________________________________
-void AliMUONGeometryTransformer::WriteDetElemVolPaths(ofstream& out) const
-{
-// Write detection elements volume paths
-
- for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
- AliMUONGeometryModuleTransformer* moduleTransformer
- = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
- AliMUONGeometryStore* detElements
- = moduleTransformer->GetDetElementStore();
-
- for (Int_t j=0; j<detElements->GetNofEntries(); j++) {
- AliMUONGeometryDetElement* detElement
- = (AliMUONGeometryDetElement*)detElements->GetEntry(j);
-
- // Write data on out
- out << "DE "
- << setw(4) << detElement->GetId() << " "
- << detElement->GetVolumePath() << endl;
- }
- out << endl;
- }
-}
-
//______________________________________________________________________________
void AliMUONGeometryTransformer::WriteModuleTransforms(ofstream& out) const
{
-// Write modules transformations
+/// Write module transformations for all module transformers
for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
AliMUONGeometryModuleTransformer* moduleTransformer
= moduleTransformer->GetTransformation();
// Write data on out
- out << "CH "
- << setw(4) << moduleTransformer->GetModuleId() + 1;
+ out << AliMUONGeometryModuleTransformer::GetModuleNamePrefix() << " "
+ << setw(4) << moduleTransformer->GetModuleId();
WriteTransform(out, transform);
}
//______________________________________________________________________________
void AliMUONGeometryTransformer::WriteDetElemTransforms(ofstream& out) const
{
-// Writes detection elements transformations
-// ---
+/// Write detection element transformations for all detection elements in all
+/// module transformers
for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
AliMUONGeometryModuleTransformer* moduleTransformer
= (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
- AliMUONGeometryStore* detElements
- = moduleTransformer->GetDetElementStore();
-
- for (Int_t j=0; j<detElements->GetNofEntries(); j++) {
- AliMUONGeometryDetElement* detElement
- = (AliMUONGeometryDetElement*)detElements->GetEntry(j);
+ AliMpExMap* detElements = moduleTransformer->GetDetElementStore();
+ TIter next(detElements->CreateIterator());
+ AliMUONGeometryDetElement* detElement;
+ while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+ {
const TGeoMatrix* transform
= detElement->GetLocalTransformation();
// Write data on out
- out << "DE " << setw(4) << detElement->GetId();
+ out << AliMUONGeometryDetElement::GetDENamePrefix() << " "
+ << setw(4) << detElement->GetId();
WriteTransform(out, transform);
}
}
}
+//______________________________________________________________________________
+TString AliMUONGeometryTransformer::GetModuleSymName(Int_t moduleId) const
+{
+/// Return the module symbolic name (use for alignment)
+
+ return "/" + fDetectorName + "/"
+ + AliMUONGeometryModuleTransformer::GetModuleName(moduleId);
+}
+
+//______________________________________________________________________________
+TString AliMUONGeometryTransformer::GetDESymName(Int_t detElemId) const
+{
+/// Return the detection element symbolic name (used for alignment)
+
+ // Module Id
+ Int_t moduleId = AliMpDEManager::GetGeomModuleId(detElemId);
+
+ return GetModuleSymName(moduleId) + "/"
+ + AliMUONGeometryDetElement::GetDEName(detElemId);
+}
+
//
// public functions
//
//______________________________________________________________________________
Bool_t
-AliMUONGeometryTransformer::ReadGeometryData(
- const TString& volPathFileName,
- const TString& transformFileName)
+AliMUONGeometryTransformer::LoadTransformations()
{
-/// Read geometry data from given files;
-/// if transformFileName has ".root" extension, the transformations
-/// are loaded from root geometry file, otherwise ASCII file
-/// format is supposed
+/// Load transformations for defined modules and detection elements
+/// using AliGeomManager
- Bool_t result1 = ReadVolPaths(volPathFileName);
+ if ( ! AliGeomManager::GetGeometry() ) {
+ AliFatal("Geometry has to be laoded in AliGeomManager first.");
+ return false;
+ }
- // Get file extension
- std::string fileName = transformFileName.Data();
- std::string rootExt = fileName.substr(fileName.size()-5, fileName.size());
- Bool_t result2;
- if ( rootExt != ".root" )
- result2 = ReadTransformations(transformFileName);
- else
- result2 = ReadTransformations2(transformFileName);
-
- return result1 && result2;
+ for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
+ AliMUONGeometryModuleTransformer* moduleTransformer
+ = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
+
+ // Module symbolic name
+ TString symname = GetModuleSymName(moduleTransformer->GetModuleId());
+
+ // Set matrix from physical node
+ TGeoHMatrix* matrix = AliGeomManager::GetMatrix(symname);
+ if ( ! matrix ) {
+ AliErrorStream() << "Geometry module matrix not found." << endl;
+ return false;
+ }
+ moduleTransformer->SetTransformation(*matrix);
+
+ // Loop over detection elements
+ AliMpExMap* detElements = moduleTransformer->GetDetElementStore();
+ TIter next(detElements->CreateIterator());
+ AliMUONGeometryDetElement* detElement;
+
+ while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+ {
+ // Det element symbolic name
+ TString symnameDE = GetDESymName(detElement->GetId());
+
+ // Set global matrix from physical node
+ TGeoHMatrix* globalMatrix = AliGeomManager::GetMatrix(symnameDE);
+ if ( ! globalMatrix ) {
+ AliErrorStream() << "Detection element matrix not found." << endl;
+ return false;
+ }
+ detElement->SetGlobalTransformation(*globalMatrix, false);
+
+ // Set local matrix
+ TGeoHMatrix localMatrix =
+ AliMUONGeometryBuilder::Multiply(
+ (*matrix).Inverse(), (*globalMatrix) );
+ detElement->SetLocalTransformation(localMatrix, false);
+ }
+ }
+ return true;
}
//______________________________________________________________________________
Bool_t
-AliMUONGeometryTransformer::ReadGeometryData(
- const TString& volPathFileName,
- TGeoManager* tgeoManager)
+AliMUONGeometryTransformer::LoadGeometryData(const TString& fileName)
{
-/// Load geometry data from root geometry using defined
-/// voluem paths from file
+/// Read geometry data either from ASCII file with transformations or
+/// from root geometry file (if fileName has ".root" extension)
- Bool_t result1 = ReadVolPaths(volPathFileName);
+ CreateModules();
- Bool_t result2 = LoadTransforms(tgeoManager);
+ // Get file extension
+ std::string fileName2 = fileName.Data();
+ std::string rootExt = fileName2.substr(fileName2.size()-5, fileName2.size());
- return result1 && result2;
+ if ( rootExt != ".root" )
+ return ReadTransformations(fileName);
+ else {
+ // Load root geometry
+ AliGeomManager::LoadGeometry(fileName.Data());
+ return LoadTransformations();
+ }
}
//______________________________________________________________________________
Bool_t
-AliMUONGeometryTransformer::WriteGeometryData(
- const TString& volPathFileName,
- const TString& transformFileName,
- const TString& misalignFileName) const
+AliMUONGeometryTransformer::LoadGeometryData()
{
-/// Write geometry data into given files
+/// Load geometry data from already loaded Root geometry using AliGeomManager
- Bool_t result1 = WriteVolumePaths(volPathFileName);
- Bool_t result2 = WriteTransformations(transformFileName);
-
- Bool_t result3 = true;
- if ( misalignFileName != "" )
- result3 = WriteMisAlignmentData(misalignFileName);
-
- return result1 && result2 && result3;
-}
-
-//______________________________________________________________________________
-Bool_t
-AliMUONGeometryTransformer::WriteVolumePaths(const TString& fileName) const
-{
-// Writes volume paths for modules and detection element volumes into a file
-// Returns true, if writing finished correctly.
-// ---
+ if ( ! AliGeomManager::GetGeometry() ) {
+ AliErrorStream() << "Geometry has not been loaded in AliGeomManager" << endl;
+ return false;
+ }
- // No writing
- // if builder is not associated with any geometry module
- if (fModuleTransformers->GetEntriesFast() == 0) return false;
+ CreateModules();
- // File path
- TString filePath = gSystem->Getenv("ALICE_ROOT");
- filePath += "/MUON/data/";
- filePath += fileName;
-
- // Open output file
- ofstream out(filePath, ios::out);
- if (!out) {
- cerr << filePath << endl;
- AliError("File not found.");
- return false;
- }
-#if !defined (__DECCXX)
- out.setf(std::ios::fixed);
-#endif
- WriteModuleVolPaths(out);
- WriteDetElemVolPaths(out);
-
- return true;
+ return LoadTransformations();
}
//______________________________________________________________________________
Bool_t
AliMUONGeometryTransformer::WriteTransformations(const TString& fileName) const
{
-// Writes transformations into a file
-// Returns true, if writing finished correctly.
-// ---
+/// Write transformations into a file.
+/// Return true, if writing finished correctly.
// No writing
// if builder is not associated with any geometry module
Bool_t
AliMUONGeometryTransformer::WriteMisAlignmentData(const TString& fileName) const
{
-// Writes misalignment data into a file
-// Returns true, if writing finished correctly.
-// ---
+/// Write misalignment data into a file
+/// Return true, if writing finished correctly.
// No writing
// if builder is not associated with any geometry module
void AliMUONGeometryTransformer::AddModuleTransformer(
AliMUONGeometryModuleTransformer* moduleTransformer)
{
-/// Add the geometrymodule to the array
+/// Add the module transformer to the array
+
+ // Expand the size if not sufficient
+ Int_t moduleId = moduleTransformer->GetModuleId();
+ if ( moduleId >= fModuleTransformers->GetSize() )
+ fModuleTransformers->Expand(moduleId+1);
- fModuleTransformers->AddAt(moduleTransformer,
- moduleTransformer->GetModuleId());
+ fModuleTransformers->AddAt(moduleTransformer, moduleId);
}
//_____________________________________________________________________________
void AliMUONGeometryTransformer::AddMisAlignModule(Int_t moduleId,
- const TGeoHMatrix& matrix)
+ const TGeoHMatrix& matrix, Bool_t bGlobal)
{
-/// Build AliAlignObjMatrix with module ID, its volumePaths
+/// Build AliAlignObjMatrix with module ID, its volumePath
/// and the given delta transformation matrix
if ( ! fMisAlignArray )
return;
}
- // Get path
- TString path = kTransformer->GetVolumePath();
-
// Get unique align object ID
- Int_t volId = AliAlignObj::LayerToVolUID(AliAlignObj::kMUON, moduleId);
+ Int_t volId = AliGeomManager::LayerToVolUID(AliGeomManager::kMUON, moduleId);
// Create mis align matrix
TClonesArray& refArray =*fMisAlignArray;
Int_t pos = fMisAlignArray->GetEntriesFast();
- new (refArray[pos]) AliAlignObjMatrix(path.Data(), volId,
- const_cast<TGeoHMatrix&>(matrix));
+ new (refArray[pos]) AliAlignObjMatrix(GetModuleSymName(moduleId), volId,
+ const_cast<TGeoHMatrix&>(matrix),bGlobal);
}
//_____________________________________________________________________________
void AliMUONGeometryTransformer::AddMisAlignDetElement(Int_t detElemId,
- const TGeoHMatrix& matrix)
+ const TGeoHMatrix& matrix, Bool_t bGlobal)
{
-/// Build AliAlignObjMatrix with detection element ID, its volumePaths
+/// Build AliAlignObjMatrix with detection element ID, its volumePath
/// and the given delta transformation matrix
if ( ! fMisAlignArray )
return;
}
- // Get path
- TString path = kDetElement->GetVolumePath();
-
// Get unique align object ID
- Int_t volId = AliAlignObj::LayerToVolUID(AliAlignObj::kMUON, detElemId);
+ Int_t volId = AliGeomManager::LayerToVolUID(AliGeomManager::kMUON, detElemId);
// Create mis align matrix
TClonesArray& refArray =*fMisAlignArray;
Int_t pos = fMisAlignArray->GetEntriesFast();
- new(refArray[pos]) AliAlignObjMatrix(path.Data(), volId,
- const_cast<TGeoHMatrix&>(matrix));
+ new(refArray[pos]) AliAlignObjMatrix(GetDESymName(detElemId), volId,
+ const_cast<TGeoHMatrix&>(matrix),bGlobal);
+}
+
+//______________________________________________________________________________
+void AliMUONGeometryTransformer::CreateModules()
+{
+/// Create modules and their detection elements using info from mapping;
+/// but do not fill matrices
+
+ // Load mapping as its info is used to define modules & DEs
+ LoadMapping();
+
+ if ( fModuleTransformers->GetEntriesFast() == 0 ) {
+ // Create modules only if they do not yet exist
+
+ // Loop over geometry module
+ for (Int_t moduleId = 0; moduleId < AliMpConstants::NofGeomModules(); ++moduleId ) {
+
+ // Create geometry module transformer
+ AliMUONGeometryModuleTransformer* moduleTransformer
+ = new AliMUONGeometryModuleTransformer(moduleId);
+ AddModuleTransformer(moduleTransformer);
+ }
+ }
+
+ // Loop over detection elements
+ AliMpDEIterator it;
+ for ( it.First(); ! it.IsDone(); it.Next() ) {
+
+ Int_t detElemId = it.CurrentDEId();
+ Int_t moduleId = AliMpDEManager::GetGeomModuleId(detElemId);
+
+ // Get detection element store
+ AliMpExMap* detElements =
+ GetModuleTransformer(moduleId)->GetDetElementStore();
+
+ // Add detection element
+ AliMUONGeometryDetElement* detElement
+ = new AliMUONGeometryDetElement(detElemId);
+ detElements->Add(detElemId, detElement);
+ }
}
+//_____________________________________________________________________________
+void AliMUONGeometryTransformer::AddAlignableVolumes() const
+{
+/// Set symbolic names and matrices to alignable objects to TGeo
+
+ if ( ! gGeoManager ) {
+ AliWarning("TGeoManager not defined.");
+ return;
+ }
+
+ // Modules
+ for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
+ AliMUONGeometryModuleTransformer* module
+ = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
+
+ // Set module symbolic name
+ TGeoPNEntry* pnEntry
+ = gGeoManager->SetAlignableEntry(GetModuleSymName(module->GetModuleId()),
+ module->GetVolumePath());
+ if ( ! pnEntry ) {
+ AliErrorStream()
+ << "Volume path " << module->GetVolumePath().Data()
+ << " for geometry module " << module->GetModuleId() << " " << module
+ << " not found in geometry." << endl;
+ }
+ else {
+ // Set module matrix
+ pnEntry->SetMatrix(new TGeoHMatrix(*module->GetTransformation()));
+ // the matrix will be deleted via TGeoManager
+ }
+
+ // Detection elements
+ AliMpExMap* detElements = module->GetDetElementStore();
+ TIter next(detElements->CreateIterator());
+ AliMUONGeometryDetElement* detElement;
+
+ while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+ {
+ // Set detection element symbolic name
+ TGeoPNEntry* pnEntryDE
+ = gGeoManager->SetAlignableEntry(GetDESymName(detElement->GetId()),
+ detElement->GetVolumePath());
+ if ( ! pnEntryDE ) {
+ AliErrorStream()
+ << "Volume path "
+ << detElement->GetVolumePath().Data()
+ << " for detection element " << detElement->GetId()
+ << " not found in geometry." << endl;
+ }
+ else {
+ // Set detection element matrix
+ pnEntryDE->SetMatrix(new TGeoHMatrix(*detElement->GetGlobalTransformation()));
+ // the matrix will be deleted via TGeoManager
+ }
+ }
+ }
+}
+
//_____________________________________________________________________________
TClonesArray* AliMUONGeometryTransformer::CreateZeroAlignmentData() const
{
AliMUONGeometryModuleTransformer* module
= (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
- TString path = module->GetVolumePath();
Int_t moduleId = module->GetModuleId();
// Align object ID
- Int_t volId = AliAlignObj::LayerToVolUID(AliAlignObj::kMUON, moduleId);
+ Int_t volId = AliGeomManager::LayerToVolUID(AliGeomManager::kMUON, moduleId);
// Create mis align matrix
Int_t pos = array->GetEntriesFast();
- new (refArray[pos]) AliAlignObjMatrix(path.Data(), volId, matrix);
+ new (refArray[pos]) AliAlignObjMatrix(GetModuleSymName(moduleId), volId, matrix, kTRUE);
}
// Detection elements
for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
AliMUONGeometryModuleTransformer* moduleTransformer
= (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
- AliMUONGeometryStore* detElements
- = moduleTransformer->GetDetElementStore();
- for (Int_t j=0; j<detElements->GetNofEntries(); j++) {
- AliMUONGeometryDetElement* detElement
- = (AliMUONGeometryDetElement*)detElements->GetEntry(j);
-
- TString path = detElement->GetVolumePath();
+ AliMpExMap* detElements = moduleTransformer->GetDetElementStore();
+ TIter next(detElements->CreateIterator());
+ AliMUONGeometryDetElement* detElement;
+
+ while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+ {
Int_t detElemId = detElement->GetId();
// Align object ID
- Int_t volId = AliAlignObj::LayerToVolUID(AliAlignObj::kMUON, detElemId);
+ Int_t volId = AliGeomManager::LayerToVolUID(AliGeomManager::kMUON, detElemId);
// Create mis align matrix
Int_t pos = array->GetEntriesFast();
- new (refArray[pos]) AliAlignObjMatrix(path.Data(), volId, matrix);
+ new (refArray[pos]) AliAlignObjMatrix(GetDESymName(detElemId), volId, matrix, kTRUE);
}
}
return array;
}
+//_____________________________________________________________________________
+void AliMUONGeometryTransformer::ClearMisAlignmentData()
+{
+/// Clear the array of misalignment data
+
+ if ( ! fMisAlignArray ) return;
+
+ fMisAlignArray->Delete();
+}
+
//_____________________________________________________________________________
void AliMUONGeometryTransformer::Global2Local(Int_t detElemId,
Float_t xg, Float_t yg, Float_t zg,
const AliMUONGeometryModuleTransformer*
AliMUONGeometryTransformer::GetModuleTransformer(Int_t index, Bool_t warn) const
{
-/// Return the geometry module specified by index
+/// Return the geometry module transformer specified by index
return GetModuleTransformerNonConst(index, warn);
}
AliMUONGeometryTransformer::GetModuleTransformerByDEId(Int_t detElemId,
Bool_t warn) const
{
-/// Return the geometry module specified by index
+/// Return the geometry module transformer specified by detection element ID
// Get module index
- Int_t index = AliMUONGeometryStore::GetModuleId(detElemId);
+ Int_t index = AliMpDEManager::GetGeomModuleId(detElemId);
return GetModuleTransformer(index, warn);
}
const AliMUONGeometryDetElement*
AliMUONGeometryTransformer::GetDetElement(Int_t detElemId, Bool_t warn) const
{
-/// Return detection ellemnt with given detElemId
+/// Return detection element with given detElemId
const AliMUONGeometryModuleTransformer* kTransformer
= GetModuleTransformerByDEId(detElemId, warn);
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff