1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
18 //-----------------------------------------------------------------------------
19 /// \class AliMUONAlignmentTask
20 /// AliAnalysisTask to align the MUON spectrometer.
21 /// The Task reads as input ESDs and feeds the MUONTracks to AliMUONAlignment.
22 /// The alignment itself is performed by AliMillepede.
23 /// A OCDB entry is written with the alignment parameters.
24 /// A list of graph are written to monitor the alignment parameters.
26 /// \author Javier Castillo, CEA/Saclay - Irfu/SPhN
27 //-----------------------------------------------------------------------------
29 // this class header must always come first
30 #include "AliMUONAlignmentTask.h"
32 // local header must come before system headers
33 #include "AliAnalysisManager.h"
34 #include "AliAODInputHandler.h"
35 #include "AliAODHandler.h"
36 #include "AliAODEvent.h"
37 #include "AliAODHeader.h"
38 #include "AliESDInputHandler.h"
39 #include "AliESDEvent.h"
40 #include "AliESDMuonTrack.h"
42 #include "AliCDBStorage.h"
43 #include "AliCDBManager.h"
44 #include "AliGRPManager.h"
45 #include "AliCDBMetaData.h"
47 #include "AliGeomManager.h"
50 #include "AliMUONCDB.h"
51 #include "AliMUONAlignment.h"
52 #include "AliMUONTrack.h"
53 #include "AliMUONTrackExtrap.h"
54 #include "AliMUONTrackParam.h"
55 #include "AliMUONGeometryTransformer.h"
56 #include "AliMUONESDInterface.h"
62 #include <TGraphErrors.h>
65 #include <TClonesArray.h>
66 #include <TGeoGlobalMagField.h>
67 #include <TGeoManager.h>
68 #include <Riostream.h>
71 ClassImp(AliMUONAlignmentTask)
74 //________________________________________________________________________
75 AliMUONAlignmentTask::AliMUONAlignmentTask(const char *name, const char *newalignocdb, const char *oldalignocdb, const char *defaultocdb, const char *geofilename):
76 AliAnalysisTaskSE(name),
77 fReadRecords( kFALSE ),
78 fWriteRecords( kFALSE ),
79 fDoAlignment( kTRUE ),
81 fGeoFilename(geofilename),
82 fDefaultStorage(defaultocdb),
83 fOldAlignStorage(oldalignocdb),
84 fNewAlignStorage(newalignocdb),
85 fOldGeoTransformer(NULL),
86 fNewGeoTransformer(NULL),
87 fLoadOCDBOnce(kFALSE),
100 /// Default Constructor
101 // Define input and output slots here
102 // Input slot #0 works with a TChain
103 DefineInput(0, TChain::Class());
105 // Output slot #0 writes NTuple/histos into a TList
106 DefineOutput(1, TList::Class());
108 // initialize parameters ...
109 for(Int_t k=0;k<4*156;k++)
116 fOldGeoTransformer = new AliMUONGeometryTransformer();
120 //________________________________________________________________________
121 AliMUONAlignmentTask::AliMUONAlignmentTask(const AliMUONAlignmentTask& other):
122 AliAnalysisTaskSE(other),
123 fReadRecords( other.fReadRecords ),
124 fWriteRecords( other.fWriteRecords ),
125 fDoAlignment( other.fDoAlignment ),
126 fAlign( other.fAlign ),
127 fGeoFilename( other.fGeoFilename ),
128 fDefaultStorage( other.fDefaultStorage ),
129 fOldAlignStorage( other.fOldAlignStorage ),
130 fNewAlignStorage( other.fNewAlignStorage ),
131 fOldGeoTransformer( other.fOldGeoTransformer ),
132 fNewGeoTransformer( other.fNewGeoTransformer ),
133 fLoadOCDBOnce( other.fLoadOCDBOnce ),
134 fOCDBLoaded( other.fOCDBLoaded ),
135 fTrackTot( other.fTrackTot ),
136 fTrackOk( other.fTrackOk ),
137 fLastRunNumber( other.fLastRunNumber ),
138 fMSDEx( other.fMSDEx ),
139 fMSDEy( other.fMSDEy ),
140 fMSDEz( other.fMSDEz ),
141 fMSDEp( other.fMSDEp ),
142 fList( other.fList ),
143 fRecords( other.fRecords ),
144 fRecordCount( other.fRecordCount )
147 // initialize parameters
148 for(Int_t k=0;k<4*156;k++)
151 fParameters[k]=other.fParameters[k];
152 fErrors[k]=other.fErrors[k];
153 fPulls[k]=other.fPulls[k];
159 //________________________________________________________________________
160 AliMUONAlignmentTask& AliMUONAlignmentTask::operator=(const AliMUONAlignmentTask& other)
163 if(&other == this) return *this;
164 AliAnalysisTaskSE::operator=(other);
166 fReadRecords = other.fReadRecords;
167 fWriteRecords = other.fWriteRecords;
168 fDoAlignment = other.fDoAlignment;
170 // this breaks in destructor
171 fAlign = other.fAlign;
173 fGeoFilename = other.fGeoFilename;
174 fDefaultStorage = other.fDefaultStorage;
175 fOldAlignStorage = other.fOldAlignStorage;
176 fNewAlignStorage = other.fNewAlignStorage;
178 // this breaks in destructor
179 fOldGeoTransformer = other.fOldGeoTransformer;
180 fNewGeoTransformer = other.fNewGeoTransformer;
182 fLoadOCDBOnce = other.fLoadOCDBOnce;
183 fOCDBLoaded = other.fOCDBLoaded;
184 fTrackTot = other.fTrackTot;
185 fTrackOk = other.fTrackOk;
186 fLastRunNumber = other.fLastRunNumber;
187 fMSDEx = other.fMSDEx;
188 fMSDEy = other.fMSDEy;
189 fMSDEz = other.fMSDEz;
190 fMSDEp = other.fMSDEp;
192 fRecords = other.fRecords;
193 fRecordCount = other.fRecordCount;
195 // initialize parameters ...
196 for( Int_t k=0; k<4*156; ++k)
199 fParameters[k]=other.fParameters[k];
200 fErrors[k]=other.fErrors[k];
201 fPulls[k]=other.fPulls[k];
208 //________________________________________________________________________
209 AliMUONAlignmentTask::~AliMUONAlignmentTask()
212 it is safe to delete NULL pointers, so
213 there is no need to test their validity here.
214 However, it crashes here, because of incorrect assignment operator
215 and copy constructor, resulting in double deletion of objects.
216 Would require deep copy instead.
219 delete fOldGeoTransformer;
220 delete fNewGeoTransformer;
223 //________________________________________________________________________
224 void AliMUONAlignmentTask::LocalInit()
226 /// Local initialization, called once per task on the client machine
227 /// where the analysis train is assembled
229 // print configuration
230 AliInfo( Form( "fReadRecords: %s", (fReadRecords ? "kTRUE":"kFALSE" ) ) );
231 AliInfo( Form( "fWriteRecords: %s", (fWriteRecords ? "kTRUE":"kFALSE" ) ) );
232 AliInfo( Form( "fDoAlignment: %s", (fDoAlignment ? "kTRUE":"kFALSE" ) ) );
234 // consistency checks between flags
235 /* need at least one of the flags set to true */
236 if( !( fReadRecords || fWriteRecords || fDoAlignment ) )
237 { AliFatal( "Need at least one of the three flags fReadRecords, fWriteRecords and fDoAlignment set to kTRUE" ); }
239 /* cannot read and write records at the same time */
240 if( fReadRecords && fWriteRecords )
241 { AliFatal( "Cannot set both fReadRecords and fWriteRecords to kTRUE at the same time" ); }
243 /* must run alignment when reading records */
244 if( fReadRecords && !fDoAlignment )
247 AliInfo( "Automatically setting fDoAlignment to kTRUE because fReadRecords is kTRUE" );
248 SetDoAlignment( kTRUE );
252 // Set initial values here, good guess may help convergence
255 // fParameters[iPar++] = 0.010300 ; fParameters[iPar++] = 0.010600 ; fParameters[iPar++] = 0.000396 ;
257 fAlign = new AliMUONAlignment();
258 fAlign->InitGlobalParameters(fParameters);
260 // AliCDBManager::Instance()->Print();
262 // fAlign->SetGeometryTransformer(fOldGeoTransformer);
264 // Do alignment with magnetic field off
265 fAlign->SetBFieldOn(kFALSE);
267 // Set tracking station to use
268 // Bool_t bStOnOff[5] = {kTRUE,kTRUE,kTRUE,kTRUE,kTRUE};
269 Bool_t bChOnOff[10] = {kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE};
271 // Set degrees of freedom to align (see AliMUONAlignment)
272 fAlign->AllowVariations(bChOnOff);
274 // Set expected resolution (see AliMUONAlignment)
275 fAlign->SetSigmaXY(0.15,0.10);
277 // Fix parameters or add constraints here
278 // for (Int_t iSt=0; iSt<5; iSt++)
279 // if (!bStOnOff[iSt]) fAlign->FixStation(iSt+1);
280 for (Int_t iCh=0; iCh<10; iCh++)
281 if (!bChOnOff[iCh]) fAlign->FixChamber(iCh+1);
283 // Left and right sides of the detector are independent, one can choose to align
285 Bool_t bSpecLROnOff[2] = {kTRUE,kTRUE};
286 fAlign->FixHalfSpectrometer(bChOnOff,bSpecLROnOff);
288 fAlign->SetChOnOff(bChOnOff);
289 fAlign->SetSpecLROnOff(bChOnOff);
291 // Here we can fix some detection elements
292 // fAlign->FixDetElem(908);
293 // fAlign->FixDetElem(1012);
294 fAlign->FixDetElem(608);
296 // Set predifined global constrains: X, Y, P, XvsZ, YvsZ, PvsZ, XvsY, YvsY, PvsY
297 // Bool_t bVarXYT[9] = {kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE};
298 // Bool_t bDetTLBR[4] = {kFALSE,kTRUE,kFALSE,kTRUE};
299 // fAlign->AddConstraints(bChOnOff,bVarXYT,bDetTLBR,bSpecLROnOff);
303 //________________________________________________________________________
304 void AliMUONAlignmentTask::UserCreateOutputObjects()
311 fMSDEx = new TGraphErrors(156);
312 fMSDEy = new TGraphErrors(156);
313 fMSDEz = new TGraphErrors(156);
314 fMSDEp = new TGraphErrors(156);
316 // Add Ntuples to the list
323 fList->SetOwner(kTRUE);
327 // connect AOD output
330 AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() );
334 // get AOD output handler and add Branch
335 fRecords = new TClonesArray( "AliMUONAlignmentTrackRecord", 0 );
336 fRecords->SetName( "records" );
337 handler->AddBranch("TClonesArray", &fRecords);
341 } else AliInfo( "Error: invalid output event handler" );
347 //________________________________________________________________________
348 void AliMUONAlignmentTask::UserExec(Option_t *)
350 // print configuration
351 // AliInfo( Form( "fReadRecords: %s", (fReadRecords ? "kTRUE":"kFALSE" ) ) );
352 // AliInfo( Form( "fWriteRecords: %s", (fWriteRecords ? "kTRUE":"kFALSE" ) ) );
353 // AliInfo( Form( "fDoAlignment: %s", (fDoAlignment ? "kTRUE":"kFALSE" ) ) );
355 if( fWriteRecords && fRecords )
361 // local track parameters
362 Double_t trackParams[8] = {0.,0.,0.,0.,0.,0.,0.,0.};
366 AliAODEvent* lAOD( dynamic_cast<AliAODEvent*>(InputEvent() ) );
371 AliInfo("Error: AOD event not available");
376 TClonesArray* records = static_cast<TClonesArray*>( lAOD->FindListObject( "records" ) );
379 AliInfo( "Unable to read object name \"records\"" );
383 // get number of records and print
384 const Int_t lRecordsCount( records->GetEntriesFast() );
385 fTrackTot += lRecordsCount;
388 for( Int_t index = 0; index < lRecordsCount; ++index )
391 if( AliMUONAlignmentTrackRecord* record = dynamic_cast<AliMUONAlignmentTrackRecord*>( records->UncheckedAt(index) ) )
394 fAlign->ProcessTrack( record, fDoAlignment );
396 { fAlign->LocalFit( fTrackOk++, trackParams, 0 ); }
398 } else AliInfo( Form( "Invalid record at %i", index ) );
404 /// Main loop, called for each event
405 AliESDEvent* lESD( dynamic_cast<AliESDEvent*>(InputEvent()) );
410 AliInfo("Error: ESD event not available");
414 // HUGO: Comment out check on run number, to be able to run on MC
415 // if (!lESD->GetRunNumber())
417 // AliInfo( Form( "Current Run Number: %i", lESD->GetRunNumber() ) );
421 // if (lESD->GetRunNumber()!=fLastRunNumber){
422 // fLastRunNumber = lESD->GetRunNumber();
423 // Prepare(fGeoFilename.Data(),fDefaultOCDB.Data(),fMisAlignOCDB.Data());
426 Int_t nTracks = Int_t(lESD->GetNumberOfMuonTracks());
427 // cout << " there are " << nTracks << " tracks" << endl;
428 for( Int_t iTrack = 0; iTrack < nTracks; iTrack++ )
431 AliESDMuonTrack* esdTrack = lESD->GetMuonTrack(iTrack);
432 if (!esdTrack->ContainTrackerData()) continue;
433 if (!esdTrack->ContainTriggerData()) continue;
435 Double_t invBenMom = esdTrack->GetInverseBendingMomentum();
436 // fInvBenMom->Fill(invBenMom);
437 // fBenMom->Fill(1./invBenMom);
438 if (TMath::Abs(invBenMom)<=1.04)
442 AliMUONESDInterface::ESDToMUON(*esdTrack, track);
444 // process track and retrieve corresponding records, for storage
445 const AliMUONAlignmentTrackRecord* lRecords( fAlign->ProcessTrack( &track, fDoAlignment ) );
447 // do the fit, if required
448 if( fDoAlignment ) fAlign->LocalFit(fTrackOk++,trackParams,0);
452 if( fWriteRecords && fRecords )
454 new((*fRecords)[fRecordCount]) AliMUONAlignmentTrackRecord( *lRecords );
462 if(!(fTrackTot%1000))
463 { AliInfo( Form( "Processed %i Tracks and %i were fitted.", fTrackTot, fTrackOk ) ); }
465 // cout << "Processed " << fTrackTot << " Tracks." << endl;
466 // Post final data. Write histo list to a file with option "RECREATE"
472 if( fWriteRecords && fRecordCount > 0 ) {
473 AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() );
476 // printf("handler: %p\n",handler);
477 AliAODEvent* aod = handler->GetAOD();
478 // printf("aod: %p\n",aod);
479 AliAODHeader* header = aod->GetHeader();
480 // printf("header: %p\n",header);
481 header->SetRunNumber(lESD->GetRunNumber());
482 // printf("RunNumber: %d\n",lESD->GetRunNumber());
483 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
484 } else AliInfo( "Error: invalid output event handler" );
491 //________________________________________________________________________
492 void AliMUONAlignmentTask::Terminate(const Option_t*)
495 //________________________________________________________________________
496 void AliMUONAlignmentTask::FinishTaskOutput()
499 /// Called once per task on the client machine at the end of the analysis.
500 AliInfo( Form( "Processed %i tracks.", fTrackTot ) );
501 AliInfo( Form( "Accepted %i tracks.", fTrackOk ) );
503 // stop here if no alignment is to be performed
504 if( !fDoAlignment ) return;
506 AliLog::SetGlobalLogLevel(AliLog::kInfo);
508 // Perform global fit
509 fAlign->GlobalFit(fParameters,fErrors,fPulls);
511 // // Update pointers reading them from the output slot
512 // fList = (TList*)GetOutputData(0);
513 // fMSDEx = (TGraphErrors*)fList->At(0);
514 // fMSDEy = (TGraphErrors*)fList->At(1);
515 // fMSDEz = (TGraphErrors*)fList->At(2);
516 // fMSDEp = (TGraphErrors*)fList->At(3);
519 Double_t DEid[156] = {0};
520 Double_t MSDEx[156] = {0};
521 Double_t MSDEy[156] = {0};
522 Double_t MSDEz[156] = {0};
523 Double_t MSDEp[156] = {0};
524 Double_t DEidErr[156] = {0};
525 Double_t MSDExErr[156] = {0};
526 Double_t MSDEyErr[156] = {0};
527 Double_t MSDEzErr[156] = {0};
528 Double_t MSDEpErr[156] = {0};
529 Int_t lNDetElem = 4*2+4*2+18*2+26*2+26*2;
530 Int_t lNDetElemCh[10] = {4,4,4,4,18,18,26,26,26,26};
531 // Int_t lSNDetElemCh[10] = {4,8,12,16,34,52,78,104,130,156};
532 Int_t idOffset = 0; // 400
533 Int_t lSDetElemCh = 0;
534 for(Int_t iDE=0; iDE<lNDetElem; iDE++)
538 DEid[iDE] = idOffset+100;
541 for(Int_t iCh=0; iCh<9; iCh++)
543 lSDetElemCh += lNDetElemCh[iCh];
545 if (iDE>=lSDetElemCh)
548 DEid[iDE] -= lNDetElemCh[iCh];
553 MSDEx[iDE]=fParameters[4*iDE+0];
554 MSDEy[iDE]=fParameters[4*iDE+1];
555 MSDEz[iDE]=fParameters[4*iDE+3];
556 MSDEp[iDE]=fParameters[4*iDE+2];
557 MSDExErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+0);
558 MSDEyErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+1);
559 MSDEzErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+3);
560 MSDEpErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+2);
561 fMSDEx->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+0]);
562 fMSDEx->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+0));
563 fMSDEy->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+1]);
564 fMSDEy->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+1));
565 fMSDEz->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+3]);
566 fMSDEz->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+3));
567 fMSDEp->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+2]);
568 fMSDEp->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+2));
572 // Post final data. Write histo list to a file with option "RECREATE"
575 // HUGO: stop here to test reproducibility
579 fNewGeoTransformer = fAlign->ReAlign(fOldGeoTransformer,fParameters,true);
580 // newTransform->WriteTransformations("transform2ReAlign.dat");
582 // Generate realigned data in local cdb
583 const TClonesArray* array = fNewGeoTransformer->GetMisAlignmentData();
585 // 100 mum residual resolution for chamber misalignments?
586 fAlign->SetAlignmentResolution(array,-1,0.01,0.01,0.004,0.003);
589 AliLog::SetGlobalDebugLevel(2);
590 AliCDBManager* cdbm = AliCDBManager::Instance();
591 // cdbManager->SetDefaultStorage(fDefaultOCDB.Data());
593 // recover default storage full name (raw:// cannot be used to set specific storage)
594 TString defaultStorage(cdbm->GetDefaultStorage()->GetType());
595 if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
596 else defaultStorage += Form("://%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
598 if (fOldAlignStorage != "none") cdbm->UnloadFromCache("MUON/Align/Data");
599 if (!fNewAlignStorage.IsNull()) cdbm->SetSpecificStorage("MUON/Align/Data",fNewAlignStorage.Data());
600 // else cdbm->SetSpecificStorage("MUON/Align/Data",fDefaultStorage.Data());
601 else cdbm->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data());
604 AliCDBMetaData* cdbData = new AliCDBMetaData();
605 cdbData->SetResponsible("Dimuon Offline project");
606 cdbData->SetComment("MUON alignment objects with residual misalignment");
607 AliCDBId id("MUON/Align/Data", 0, AliCDBRunRange::Infinity());
608 cdbm->Put(const_cast<TClonesArray*>(array), id, cdbData);
610 gSystem->Exec("cp -a ReAlignOCDB/MUON/Align/Data/Run0_999999999_v0_s0.root Run0_999999999_v0_s0.root");
611 gSystem->Exec("ls -l");
615 //________________________________________________________________________
616 void AliMUONAlignmentTask::NotifyRun()
619 if (fOCDBLoaded && fLoadOCDBOnce) { AliError(Form("OCDB already loaded %d %d",fOCDBLoaded,fLoadOCDBOnce));
623 AliCDBManager* cdbm = AliCDBManager::Instance();
624 cdbm->SetDefaultStorage(fDefaultStorage.Data());
625 // cdbm->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
627 // HUGO: add to comment out the specific settings below in order to be able to run.
628 //cdbm->SetSpecificStorage("GRP/GRP/Data",fDefaultStorage.Data());
629 //cdbm->SetSpecificStorage("GRP/Geometry/data",fDefaultStorage.Data());
630 //cdbm->SetSpecificStorage("MUON/Calib/MappingData",fDefaultStorage.Data());
631 cdbm->SetRun(fCurrentRunNumber);
633 if (!AliMUONCDB::LoadField()) { AliError("Problem field"); return;}
635 // set the magnetic field for track extrapolations
636 AliMUONTrackExtrap::SetField();
638 if (!AliMUONCDB::LoadMapping(kTRUE)) { AliError("Problem mapping"); return;}
640 // recover default storage full name (raw:// cannot be used to set specific storage)
641 TString defaultStorage(cdbm->GetDefaultStorage()->GetType());
642 if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
643 else defaultStorage += Form("://%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
645 // reset existing geometry/alignment if any
646 if (cdbm->GetEntryCache()->Contains("GRP/Geometry/Data")) cdbm->UnloadFromCache("GRP/Geometry/Data");
647 if (cdbm->GetEntryCache()->Contains("MUON/Align/Data")) cdbm->UnloadFromCache("MUON/Align/Data");
648 if (AliGeomManager::GetGeometry()) AliGeomManager::GetGeometry()->UnlockGeometry();
650 // get original geometry transformer
651 AliGeomManager::LoadGeometry();
652 if (!AliGeomManager::GetGeometry()) { AliError("Problem geometry"); return;}
653 if (fOldAlignStorage != "none")
656 if (!fOldAlignStorage.IsNull()) cdbm->SetSpecificStorage("MUON/Align/Data",fOldAlignStorage.Data());
657 else cdbm->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data());
658 // else cdbm->SetSpecificStorage("MUON/Align/Data",fDefaultStorage.Data());
660 AliGeomManager::ApplyAlignObjsFromCDB("MUON");
664 // fOldGeoTransformer = new AliMUONGeometryTransformer();
665 fOldGeoTransformer->LoadGeometryData();
666 fAlign->SetGeometryTransformer(fOldGeoTransformer);