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 AliAnalysisTaskSE::operator=(other);
165 fReadRecords = other.fReadRecords;
166 fWriteRecords = other.fWriteRecords;
167 fDoAlignment = other.fDoAlignment;
169 // this breaks in destructor
170 fAlign = other.fAlign;
172 fGeoFilename = other.fGeoFilename;
173 fDefaultStorage = other.fDefaultStorage;
174 fOldAlignStorage = other.fOldAlignStorage;
175 fNewAlignStorage = other.fNewAlignStorage;
177 // this breaks in destructor
178 fOldGeoTransformer = other.fOldGeoTransformer;
179 fNewGeoTransformer = other.fNewGeoTransformer;
181 fLoadOCDBOnce = other.fLoadOCDBOnce;
182 fOCDBLoaded = other.fOCDBLoaded;
183 fTrackTot = other.fTrackTot;
184 fTrackOk = other.fTrackOk;
185 fLastRunNumber = other.fLastRunNumber;
186 fMSDEx = other.fMSDEx;
187 fMSDEy = other.fMSDEy;
188 fMSDEz = other.fMSDEz;
189 fMSDEp = other.fMSDEp;
191 fRecords = other.fRecords;
192 fRecordCount = other.fRecordCount;
194 // initialize parameters ...
195 for( Int_t k=0; k<4*156; ++k)
198 fParameters[k]=other.fParameters[k];
199 fErrors[k]=other.fErrors[k];
200 fPulls[k]=other.fPulls[k];
207 //________________________________________________________________________
208 AliMUONAlignmentTask::~AliMUONAlignmentTask()
211 it is safe to delete NULL pointers, so
212 there is no need to test their validity here.
213 However, it crashes here, because of incorrect assignment operator
214 and copy constructor, resulting in double deletion of objects.
215 Would require deep copy instead.
218 delete fOldGeoTransformer;
219 delete fNewGeoTransformer;
222 //________________________________________________________________________
223 void AliMUONAlignmentTask::LocalInit()
225 /// Local initialization, called once per task on the client machine
226 /// where the analysis train is assembled
228 // print configuration
229 AliInfo( Form( "fReadRecords: %s", (fReadRecords ? "kTRUE":"kFALSE" ) ) );
230 AliInfo( Form( "fWriteRecords: %s", (fWriteRecords ? "kTRUE":"kFALSE" ) ) );
231 AliInfo( Form( "fDoAlignment: %s", (fDoAlignment ? "kTRUE":"kFALSE" ) ) );
233 // consistency checks between flags
234 /* need at least one of the flags set to true */
235 if( !( fReadRecords || fWriteRecords || fDoAlignment ) )
236 { AliFatal( "Need at least one of the three flags fReadRecords, fWriteRecords and fDoAlignment set to kTRUE" ); }
238 /* cannot read and write records at the same time */
239 if( fReadRecords && fWriteRecords )
240 { AliFatal( "Cannot set both fReadRecords and fWriteRecords to kTRUE at the same time" ); }
242 /* must run alignment when reading records */
243 if( fReadRecords && !fDoAlignment )
246 AliInfo( "Automatically setting fDoAlignment to kTRUE because fReadRecords is kTRUE" );
247 SetDoAlignment( kTRUE );
251 // Set initial values here, good guess may help convergence
254 // fParameters[iPar++] = 0.010300 ; fParameters[iPar++] = 0.010600 ; fParameters[iPar++] = 0.000396 ;
256 fAlign = new AliMUONAlignment();
257 fAlign->InitGlobalParameters(fParameters);
259 // AliCDBManager::Instance()->Print();
261 // fAlign->SetGeometryTransformer(fOldGeoTransformer);
263 // Do alignment with magnetic field off
264 fAlign->SetBFieldOn(kFALSE);
266 // Set tracking station to use
267 // Bool_t bStOnOff[5] = {kTRUE,kTRUE,kTRUE,kTRUE,kTRUE};
268 Bool_t bChOnOff[10] = {kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE};
270 // Set degrees of freedom to align (see AliMUONAlignment)
271 fAlign->AllowVariations(bChOnOff);
273 // Set expected resolution (see AliMUONAlignment)
274 fAlign->SetSigmaXY(0.15,0.10);
276 // Fix parameters or add constraints here
277 // for (Int_t iSt=0; iSt<5; iSt++)
278 // if (!bStOnOff[iSt]) fAlign->FixStation(iSt+1);
279 for (Int_t iCh=0; iCh<10; iCh++)
280 if (!bChOnOff[iCh]) fAlign->FixChamber(iCh+1);
282 // Left and right sides of the detector are independent, one can choose to align
284 Bool_t bSpecLROnOff[2] = {kTRUE,kTRUE};
285 fAlign->FixHalfSpectrometer(bChOnOff,bSpecLROnOff);
287 fAlign->SetChOnOff(bChOnOff);
288 fAlign->SetSpecLROnOff(bChOnOff);
290 // Here we can fix some detection elements
291 // fAlign->FixDetElem(908);
292 // fAlign->FixDetElem(1012);
293 fAlign->FixDetElem(608);
295 // Set predifined global constrains: X, Y, P, XvsZ, YvsZ, PvsZ, XvsY, YvsY, PvsY
296 // Bool_t bVarXYT[9] = {kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE};
297 // Bool_t bDetTLBR[4] = {kFALSE,kTRUE,kFALSE,kTRUE};
298 // fAlign->AddConstraints(bChOnOff,bVarXYT,bDetTLBR,bSpecLROnOff);
302 //________________________________________________________________________
303 void AliMUONAlignmentTask::UserCreateOutputObjects()
310 fMSDEx = new TGraphErrors(156);
311 fMSDEy = new TGraphErrors(156);
312 fMSDEz = new TGraphErrors(156);
313 fMSDEp = new TGraphErrors(156);
315 // Add Ntuples to the list
322 fList->SetOwner(kTRUE);
326 // connect AOD output
329 AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() );
333 // get AOD output handler and add Branch
334 fRecords = new TClonesArray( "AliMUONAlignmentTrackRecord", 0 );
335 fRecords->SetName( "records" );
336 handler->AddBranch("TClonesArray", &fRecords);
340 } else AliInfo( "Error: invalid output event handler" );
346 //________________________________________________________________________
347 void AliMUONAlignmentTask::UserExec(Option_t *)
349 // print configuration
350 // AliInfo( Form( "fReadRecords: %s", (fReadRecords ? "kTRUE":"kFALSE" ) ) );
351 // AliInfo( Form( "fWriteRecords: %s", (fWriteRecords ? "kTRUE":"kFALSE" ) ) );
352 // AliInfo( Form( "fDoAlignment: %s", (fDoAlignment ? "kTRUE":"kFALSE" ) ) );
354 if( fWriteRecords && fRecords )
360 // local track parameters
361 Double_t trackParams[8] = {0.,0.,0.,0.,0.,0.,0.,0.};
365 AliAODEvent* lAOD( dynamic_cast<AliAODEvent*>(InputEvent() ) );
370 AliInfo("Error: AOD event not available");
375 TClonesArray* records = static_cast<TClonesArray*>( lAOD->FindListObject( "records" ) );
378 AliInfo( "Unable to read object name \"records\"" );
382 // get number of records and print
383 const Int_t lRecordsCount( records->GetEntriesFast() );
384 fTrackTot += lRecordsCount;
387 for( Int_t index = 0; index < lRecordsCount; ++index )
390 if( AliMUONAlignmentTrackRecord* record = dynamic_cast<AliMUONAlignmentTrackRecord*>( records->UncheckedAt(index) ) )
393 fAlign->ProcessTrack( record, fDoAlignment );
395 { fAlign->LocalFit( fTrackOk++, trackParams, 0 ); }
397 } else AliInfo( Form( "Invalid record at %i", index ) );
403 /// Main loop, called for each event
404 AliESDEvent* lESD( dynamic_cast<AliESDEvent*>(InputEvent()) );
409 AliInfo("Error: ESD event not available");
413 // HUGO: Comment out check on run number, to be able to run on MC
414 // if (!lESD->GetRunNumber())
416 // AliInfo( Form( "Current Run Number: %i", lESD->GetRunNumber() ) );
420 // if (lESD->GetRunNumber()!=fLastRunNumber){
421 // fLastRunNumber = lESD->GetRunNumber();
422 // Prepare(fGeoFilename.Data(),fDefaultOCDB.Data(),fMisAlignOCDB.Data());
425 Int_t nTracks = Int_t(lESD->GetNumberOfMuonTracks());
426 // cout << " there are " << nTracks << " tracks" << endl;
427 for( Int_t iTrack = 0; iTrack < nTracks; iTrack++ )
430 AliESDMuonTrack* esdTrack = lESD->GetMuonTrack(iTrack);
431 if (!esdTrack->ClustersStored()) continue;
432 if (!esdTrack->ContainTriggerData()) continue;
434 Double_t invBenMom = esdTrack->GetInverseBendingMomentum();
435 // fInvBenMom->Fill(invBenMom);
436 // fBenMom->Fill(1./invBenMom);
437 if (TMath::Abs(invBenMom)<=1.04)
441 AliMUONESDInterface::ESDToMUON(*esdTrack, track);
443 // process track and retrieve corresponding records, for storage
444 const AliMUONAlignmentTrackRecord* lRecords( fAlign->ProcessTrack( &track, fDoAlignment ) );
446 // do the fit, if required
447 if( fDoAlignment ) fAlign->LocalFit(fTrackOk++,trackParams,0);
451 if( fWriteRecords && fRecords )
453 new((*fRecords)[fRecordCount]) AliMUONAlignmentTrackRecord( *lRecords );
461 if(!(fTrackTot%1000))
462 { AliInfo( Form( "Processed %i Tracks and %i were fitted.", fTrackTot, fTrackOk ) ); }
464 // cout << "Processed " << fTrackTot << " Tracks." << endl;
465 // Post final data. Write histo list to a file with option "RECREATE"
471 if( fWriteRecords && fRecordCount > 0 ) {
472 AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() );
475 // printf("handler: %p\n",handler);
476 AliAODEvent* aod = handler->GetAOD();
477 // printf("aod: %p\n",aod);
478 AliAODHeader* header = aod->GetHeader();
479 // printf("header: %p\n",header);
480 header->SetRunNumber(lESD->GetRunNumber());
481 // printf("RunNumber: %d\n",lESD->GetRunNumber());
482 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
483 } else AliInfo( "Error: invalid output event handler" );
490 //________________________________________________________________________
491 void AliMUONAlignmentTask::Terminate(const Option_t*)
494 //________________________________________________________________________
495 void AliMUONAlignmentTask::FinishTaskOutput()
498 /// Called once per task on the client machine at the end of the analysis.
499 AliInfo( Form( "Processed %i tracks.", fTrackTot ) );
500 AliInfo( Form( "Accepted %i tracks.", fTrackOk ) );
502 // stop here if no alignment is to be performed
503 if( !fDoAlignment ) return;
505 AliLog::SetGlobalLogLevel(AliLog::kInfo);
507 // Perform global fit
508 fAlign->GlobalFit(fParameters,fErrors,fPulls);
510 // // Update pointers reading them from the output slot
511 // fList = (TList*)GetOutputData(0);
512 // fMSDEx = (TGraphErrors*)fList->At(0);
513 // fMSDEy = (TGraphErrors*)fList->At(1);
514 // fMSDEz = (TGraphErrors*)fList->At(2);
515 // fMSDEp = (TGraphErrors*)fList->At(3);
518 Double_t DEid[156] = {0};
519 Double_t MSDEx[156] = {0};
520 Double_t MSDEy[156] = {0};
521 Double_t MSDEz[156] = {0};
522 Double_t MSDEp[156] = {0};
523 Double_t DEidErr[156] = {0};
524 Double_t MSDExErr[156] = {0};
525 Double_t MSDEyErr[156] = {0};
526 Double_t MSDEzErr[156] = {0};
527 Double_t MSDEpErr[156] = {0};
528 Int_t lNDetElem = 4*2+4*2+18*2+26*2+26*2;
529 Int_t lNDetElemCh[10] = {4,4,4,4,18,18,26,26,26,26};
530 // Int_t lSNDetElemCh[10] = {4,8,12,16,34,52,78,104,130,156};
531 Int_t idOffset = 0; // 400
532 Int_t lSDetElemCh = 0;
533 for(Int_t iDE=0; iDE<lNDetElem; iDE++)
537 DEid[iDE] = idOffset+100;
540 for(Int_t iCh=0; iCh<9; iCh++)
542 lSDetElemCh += lNDetElemCh[iCh];
544 if (iDE>=lSDetElemCh)
547 DEid[iDE] -= lNDetElemCh[iCh];
552 MSDEx[iDE]=fParameters[4*iDE+0];
553 MSDEy[iDE]=fParameters[4*iDE+1];
554 MSDEz[iDE]=fParameters[4*iDE+3];
555 MSDEp[iDE]=fParameters[4*iDE+2];
556 MSDExErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+0);
557 MSDEyErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+1);
558 MSDEzErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+3);
559 MSDEpErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+2);
560 fMSDEx->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+0]);
561 fMSDEx->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+0));
562 fMSDEy->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+1]);
563 fMSDEy->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+1));
564 fMSDEz->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+3]);
565 fMSDEz->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+3));
566 fMSDEp->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+2]);
567 fMSDEp->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+2));
571 // Post final data. Write histo list to a file with option "RECREATE"
574 // HUGO: stop here to test reproducibility
578 fNewGeoTransformer = fAlign->ReAlign(fOldGeoTransformer,fParameters,true);
579 // newTransform->WriteTransformations("transform2ReAlign.dat");
581 // Generate realigned data in local cdb
582 const TClonesArray* array = fNewGeoTransformer->GetMisAlignmentData();
584 // 100 mum residual resolution for chamber misalignments?
585 fAlign->SetAlignmentResolution(array,-1,0.01,0.01,0.004,0.003);
588 AliLog::SetGlobalDebugLevel(2);
589 AliCDBManager* cdbm = AliCDBManager::Instance();
590 // cdbManager->SetDefaultStorage(fDefaultOCDB.Data());
592 // recover default storage full name (raw:// cannot be used to set specific storage)
593 TString defaultStorage(cdbm->GetDefaultStorage()->GetType());
594 if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
595 else defaultStorage += Form("://%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
597 if (fOldAlignStorage != "none") cdbm->UnloadFromCache("MUON/Align/Data");
598 if (!fNewAlignStorage.IsNull()) cdbm->SetSpecificStorage("MUON/Align/Data",fNewAlignStorage.Data());
599 // else cdbm->SetSpecificStorage("MUON/Align/Data",fDefaultStorage.Data());
600 else cdbm->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data());
603 AliCDBMetaData* cdbData = new AliCDBMetaData();
604 cdbData->SetResponsible("Dimuon Offline project");
605 cdbData->SetComment("MUON alignment objects with residual misalignment");
606 AliCDBId id("MUON/Align/Data", 0, AliCDBRunRange::Infinity());
607 cdbm->Put(const_cast<TClonesArray*>(array), id, cdbData);
609 gSystem->Exec("cp -a ReAlignOCDB/MUON/Align/Data/Run0_999999999_v0_s0.root Run0_999999999_v0_s0.root");
610 gSystem->Exec("ls -l");
614 //________________________________________________________________________
615 void AliMUONAlignmentTask::NotifyRun()
618 if (fOCDBLoaded && fLoadOCDBOnce) { AliError(Form("OCDB already loaded %d %d",fOCDBLoaded,fLoadOCDBOnce));
622 AliCDBManager* cdbm = AliCDBManager::Instance();
623 cdbm->SetDefaultStorage(fDefaultStorage.Data());
624 // cdbm->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
626 // HUGO: add to comment out the specific settings below in order to be able to run.
627 //cdbm->SetSpecificStorage("GRP/GRP/Data",fDefaultStorage.Data());
628 //cdbm->SetSpecificStorage("GRP/Geometry/data",fDefaultStorage.Data());
629 //cdbm->SetSpecificStorage("MUON/Calib/MappingData",fDefaultStorage.Data());
630 cdbm->SetRun(fCurrentRunNumber);
632 if (!AliMUONCDB::LoadField()) { AliError("Problem field"); return;}
634 // set the magnetic field for track extrapolations
635 AliMUONTrackExtrap::SetField();
637 if (!AliMUONCDB::LoadMapping(kTRUE)) { AliError("Problem mapping"); return;}
639 // recover default storage full name (raw:// cannot be used to set specific storage)
640 TString defaultStorage(cdbm->GetDefaultStorage()->GetType());
641 if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
642 else defaultStorage += Form("://%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
644 // reset existing geometry/alignment if any
645 if (cdbm->GetEntryCache()->Contains("GRP/Geometry/Data")) cdbm->UnloadFromCache("GRP/Geometry/Data");
646 if (cdbm->GetEntryCache()->Contains("MUON/Align/Data")) cdbm->UnloadFromCache("MUON/Align/Data");
647 if (AliGeomManager::GetGeometry()) AliGeomManager::GetGeometry()->UnlockGeometry();
649 // get original geometry transformer
650 AliGeomManager::LoadGeometry();
651 if (!AliGeomManager::GetGeometry()) { AliError("Problem geometry"); return;}
652 if (fOldAlignStorage != "none")
655 if (!fOldAlignStorage.IsNull()) cdbm->SetSpecificStorage("MUON/Align/Data",fOldAlignStorage.Data());
656 else cdbm->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data());
657 // else cdbm->SetSpecificStorage("MUON/Align/Data",fDefaultStorage.Data());
659 AliGeomManager::ApplyAlignObjsFromCDB("MUON");
663 // fOldGeoTransformer = new AliMUONGeometryTransformer();
664 fOldGeoTransformer->LoadGeometryData();
665 fAlign->SetGeometryTransformer(fOldGeoTransformer);