]>
Commit | Line | Data |
---|---|---|
81f1d3ae | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
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 purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | // $Id$ | |
17 | ||
4d610fd5 | 18 | //----------------------------------------------------------------------------- |
19 | /// \class AliMUONAlignmentTask | |
20 | /// AliAnalysisTask to align the MUON spectrometer. | |
21 | /// The Task reads as input ESDs and feeds the MUONTracks to AliMUONAlignment. | |
516043cd | 22 | /// The alignment itself is performed by AliMillePede2. |
4d610fd5 | 23 | /// A OCDB entry is written with the alignment parameters. |
4d610fd5 | 24 | /// |
25 | /// \author Javier Castillo, CEA/Saclay - Irfu/SPhN | |
516043cd | 26 | /// \author Hugo Pereira Da Costa, CEA/Saclay - Irfu/SPhN |
4d610fd5 | 27 | //----------------------------------------------------------------------------- |
28 | ||
56218672 | 29 | // this class header must always come first |
30 | #include "AliMUONAlignmentTask.h" | |
4d610fd5 | 31 | |
56218672 | 32 | // local header must come before system headers |
4d610fd5 | 33 | #include "AliAnalysisManager.h" |
516043cd | 34 | #include "AliAlignObjMatrix.h" |
56218672 | 35 | #include "AliAODInputHandler.h" |
36 | #include "AliAODHandler.h" | |
37 | #include "AliAODEvent.h" | |
38 | #include "AliAODHeader.h" | |
516043cd | 39 | #include "AliCDBEntry.h" |
4d610fd5 | 40 | #include "AliESDInputHandler.h" |
41 | #include "AliESDEvent.h" | |
42 | #include "AliESDMuonTrack.h" | |
56218672 | 43 | #include "AliCDBStorage.h" |
4d610fd5 | 44 | #include "AliCDBManager.h" |
cd8521dd | 45 | #include "AliGRPManager.h" |
4d610fd5 | 46 | #include "AliCDBMetaData.h" |
47 | #include "AliCDBId.h" | |
48 | #include "AliGeomManager.h" | |
49 | ||
516043cd | 50 | #include "AliMagF.h" |
51 | #include "AliMillePedeRecord.h" | |
4d610fd5 | 52 | #include "AliMpCDB.h" |
56218672 | 53 | #include "AliMUONCDB.h" |
4d610fd5 | 54 | #include "AliMUONAlignment.h" |
516043cd | 55 | #include "AliMUONConstants.h" |
56 | #include "AliMUONRecoParam.h" | |
4d610fd5 | 57 | #include "AliMUONTrack.h" |
58 | #include "AliMUONTrackExtrap.h" | |
59 | #include "AliMUONTrackParam.h" | |
60 | #include "AliMUONGeometryTransformer.h" | |
61 | #include "AliMUONESDInterface.h" | |
62 | ||
56218672 | 63 | // system headers |
516043cd | 64 | #include <cassert> |
56218672 | 65 | #include <fstream> |
516043cd | 66 | |
67 | // root headers | |
56218672 | 68 | #include <TString.h> |
69 | #include <TError.h> | |
516043cd | 70 | #include <TFile.h> |
56218672 | 71 | #include <TGraphErrors.h> |
72 | #include <TTree.h> | |
73 | #include <TChain.h> | |
74 | #include <TClonesArray.h> | |
75 | #include <TGeoGlobalMagField.h> | |
76 | #include <TGeoManager.h> | |
77 | #include <Riostream.h> | |
4d610fd5 | 78 | |
56218672 | 79 | ///\cond CLASSIMP |
4d610fd5 | 80 | ClassImp(AliMUONAlignmentTask) |
81 | ///\endcond | |
82 | ||
4d610fd5 | 83 | //________________________________________________________________________ |
516043cd | 84 | AliMUONAlignmentTask::AliMUONAlignmentTask( const char *name ): |
56218672 | 85 | AliAnalysisTaskSE(name), |
86 | fReadRecords( kFALSE ), | |
87 | fWriteRecords( kFALSE ), | |
88 | fDoAlignment( kTRUE ), | |
516043cd | 89 | fMergeAlignmentCDBs( kTRUE ), |
90 | fForceBField( kFALSE ), | |
91 | fBFieldOn( kFALSE ), | |
56218672 | 92 | fAlign(0x0), |
470a6da0 | 93 | fDefaultStorage(), |
94 | fOldAlignStorage(), | |
516043cd | 95 | fNewAlignStorage( "local://ReAlignOCDB" ), |
96 | fOldGeoTransformer(0x0), | |
97 | fNewGeoTransformer(0x0), | |
56218672 | 98 | fLoadOCDBOnce(kFALSE), |
99 | fOCDBLoaded(kFALSE), | |
516043cd | 100 | fEvent(0), |
56218672 | 101 | fTrackTot(0), |
102 | fTrackOk(0), | |
516043cd | 103 | fRunNumberMin(0), |
104 | fRunNumberMax(0), | |
56218672 | 105 | fRecords(0x0), |
106 | fRecordCount(0) | |
4d610fd5 | 107 | { |
108 | /// Default Constructor | |
109 | // Define input and output slots here | |
110 | // Input slot #0 works with a TChain | |
111 | DefineInput(0, TChain::Class()); | |
56218672 | 112 | |
4d610fd5 | 113 | // initialize parameters ... |
516043cd | 114 | for(Int_t k=0;k<AliMUONAlignment::fNGlobal;k++) |
56218672 | 115 | { |
4d610fd5 | 116 | fParameters[k]=0.; |
117 | fErrors[k]=0.; | |
118 | fPulls[k]=0.; | |
119 | } | |
120 | ||
516043cd | 121 | // create alignment object |
122 | fAlign = new AliMUONAlignment(); | |
56218672 | 123 | |
516043cd | 124 | // create old geometry transformer |
125 | fOldGeoTransformer = new AliMUONGeometryTransformer(); | |
56218672 | 126 | |
4d610fd5 | 127 | } |
128 | ||
129 | //________________________________________________________________________ | |
56218672 | 130 | AliMUONAlignmentTask::~AliMUONAlignmentTask() |
131 | { | |
516043cd | 132 | /// destructor |
56218672 | 133 | delete fAlign; |
134 | delete fOldGeoTransformer; | |
135 | delete fNewGeoTransformer; | |
4d610fd5 | 136 | } |
137 | ||
138 | //________________________________________________________________________ | |
56218672 | 139 | void AliMUONAlignmentTask::LocalInit() |
4d610fd5 | 140 | { |
516043cd | 141 | /** |
142 | Local initialization, called once per task on the client machine | |
143 | where the analysis train is assembled | |
144 | **/ | |
145 | ||
146 | /* must run alignment when reading records */ | |
147 | if( fReadRecords && !fDoAlignment ) | |
148 | { | |
149 | ||
150 | AliInfo( "Automatically setting fDoAlignment to kTRUE because fReadRecords is kTRUE" ); | |
151 | SetDoAlignment( kTRUE ); | |
152 | ||
153 | } | |
56218672 | 154 | |
155 | // print configuration | |
516043cd | 156 | if( fRunNumberMin > 0 || fRunNumberMax > 0 ) |
157 | { AliInfo( Form( "run range: %i - %i", fRunNumberMin, fRunNumberMax ) ); } | |
158 | ||
56218672 | 159 | AliInfo( Form( "fReadRecords: %s", (fReadRecords ? "kTRUE":"kFALSE" ) ) ); |
160 | AliInfo( Form( "fWriteRecords: %s", (fWriteRecords ? "kTRUE":"kFALSE" ) ) ); | |
161 | AliInfo( Form( "fDoAlignment: %s", (fDoAlignment ? "kTRUE":"kFALSE" ) ) ); | |
162 | ||
516043cd | 163 | if( fDoAlignment ) |
164 | { | |
165 | // merge alignment DB flag is irrelevant if not actually performing the alignemnt | |
166 | AliInfo( Form( "fMergeAlignmentCDBs: %s", (fMergeAlignmentCDBs ? "kTRUE":"kFALSE" ) ) ); | |
167 | } | |
168 | ||
169 | // storage elements | |
170 | if( !fDefaultStorage.IsNull() ) AliInfo( Form( "fDefaultStorage: %s", fDefaultStorage.Data() ) ); | |
171 | if( !fOldAlignStorage.IsNull() ) AliInfo( Form( "fOldAlignStorage: %s", fOldAlignStorage.Data() ) ); | |
172 | ||
173 | if( fDoAlignment ) | |
174 | { | |
175 | // new alignment storage is irrelevant if not actually performing the alignemnt | |
176 | if( !fNewAlignStorage.IsNull() ) AliInfo( Form( "fNewAlignStorage: %s", fNewAlignStorage.Data() ) ); | |
177 | else AliFatal( "Invalid new alignment storage path" ); | |
178 | } | |
179 | ||
180 | if( !fReadRecords ) | |
181 | { | |
182 | // following flags are only relevant if not reading records | |
183 | if( fForceBField ) AliInfo( Form( "fBFieldOn: %s", (fBFieldOn ? "kTRUE":"kFALSE" ) ) ); | |
184 | else AliInfo( "fBFieldOn: from GRP" ); | |
516043cd | 185 | } |
186 | ||
56218672 | 187 | // consistency checks between flags |
188 | /* need at least one of the flags set to true */ | |
189 | if( !( fReadRecords || fWriteRecords || fDoAlignment ) ) | |
190 | { AliFatal( "Need at least one of the three flags fReadRecords, fWriteRecords and fDoAlignment set to kTRUE" ); } | |
191 | ||
192 | /* cannot read and write records at the same time */ | |
193 | if( fReadRecords && fWriteRecords ) | |
194 | { AliFatal( "Cannot set both fReadRecords and fWriteRecords to kTRUE at the same time" ); } | |
195 | ||
516043cd | 196 | /* |
197 | fix detectors | |
198 | warning, counting chambers from 1. | |
199 | this must be done before calling the Init method | |
200 | */ | |
201 | if( fDoAlignment ) | |
56218672 | 202 | { |
203 | ||
516043cd | 204 | fAlign->FixChamber(1); |
205 | fAlign->FixChamber(10); | |
56218672 | 206 | |
516043cd | 207 | } else { |
4d610fd5 | 208 | |
516043cd | 209 | AliInfo( "Not fixing detector elements, since alignment is not required" ); |
4d610fd5 | 210 | |
516043cd | 211 | } |
4d610fd5 | 212 | |
516043cd | 213 | // initialize |
214 | fAlign->Init(); | |
56218672 | 215 | |
516043cd | 216 | // Do alignment with magnetic field off |
217 | fAlign->SetBFieldOn( fBFieldOn ); | |
4d610fd5 | 218 | |
56218672 | 219 | // Set expected resolution (see AliMUONAlignment) |
220 | fAlign->SetSigmaXY(0.15,0.10); | |
221 | ||
516043cd | 222 | // initialize global parameters to provided values |
223 | fAlign->InitGlobalParameters(fParameters); | |
4d610fd5 | 224 | |
225 | } | |
226 | ||
227 | //________________________________________________________________________ | |
56218672 | 228 | void AliMUONAlignmentTask::UserCreateOutputObjects() |
4d610fd5 | 229 | { |
56218672 | 230 | |
56218672 | 231 | // connect AOD output |
232 | if( fWriteRecords ) | |
233 | { | |
234 | AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() ); | |
235 | if( handler ) | |
236 | { | |
237 | ||
238 | // get AOD output handler and add Branch | |
516043cd | 239 | fRecords = new TClonesArray( "AliMillePedeRecord", 0 ); |
56218672 | 240 | fRecords->SetName( "records" ); |
241 | handler->AddBranch("TClonesArray", &fRecords); | |
242 | ||
243 | fRecordCount = 0; | |
244 | ||
516043cd | 245 | } else AliFatal( "Error: invalid output event handler" ); |
56218672 | 246 | |
4d610fd5 | 247 | } |
4d610fd5 | 248 | |
4d610fd5 | 249 | } |
250 | ||
251 | //________________________________________________________________________ | |
56218672 | 252 | void AliMUONAlignmentTask::UserExec(Option_t *) |
4d610fd5 | 253 | { |
516043cd | 254 | |
255 | // do nothing if run number not in range | |
256 | if( fRunNumberMin > 0 && fCurrentRunNumber < fRunNumberMin ) return; | |
257 | if( fRunNumberMax > 0 && fCurrentRunNumber > fRunNumberMax ) return; | |
258 | ||
259 | // increase event count | |
260 | ++fEvent; | |
261 | ||
56218672 | 262 | // clear array |
263 | if( fWriteRecords && fRecords ) | |
264 | { | |
265 | fRecords->Clear(); | |
266 | fRecordCount = 0; | |
4d610fd5 | 267 | } |
268 | ||
516043cd | 269 | if( fReadRecords ) |
270 | { | |
56218672 | 271 | |
272 | AliAODEvent* lAOD( dynamic_cast<AliAODEvent*>(InputEvent() ) ); | |
273 | ||
274 | // check AOD | |
275 | if( !lAOD ) | |
276 | { | |
277 | AliInfo("Error: AOD event not available"); | |
278 | return; | |
279 | } | |
280 | ||
281 | // read records | |
282 | TClonesArray* records = static_cast<TClonesArray*>( lAOD->FindListObject( "records" ) ); | |
283 | if( !records ) | |
284 | { | |
285 | AliInfo( "Unable to read object name \"records\"" ); | |
286 | return; | |
287 | } | |
288 | ||
289 | // get number of records and print | |
290 | const Int_t lRecordsCount( records->GetEntriesFast() ); | |
291 | fTrackTot += lRecordsCount; | |
292 | ||
293 | // loop over records | |
294 | for( Int_t index = 0; index < lRecordsCount; ++index ) | |
295 | { | |
296 | ||
516043cd | 297 | if( AliMillePedeRecord* record = dynamic_cast<AliMillePedeRecord*>( records->UncheckedAt(index) ) ) |
56218672 | 298 | { |
299 | ||
516043cd | 300 | fAlign->ProcessTrack( record ); |
301 | ++fTrackOk; | |
302 | ||
303 | if(!(fTrackTot%100)) | |
304 | { AliInfo( Form( "Processed %i Tracks and %i were fitted.", fTrackTot, fTrackOk ) ); } | |
56218672 | 305 | |
306 | } else AliInfo( Form( "Invalid record at %i", index ) ); | |
307 | ||
308 | } | |
309 | ||
310 | } else { | |
311 | ||
312 | /// Main loop, called for each event | |
313 | AliESDEvent* lESD( dynamic_cast<AliESDEvent*>(InputEvent()) ); | |
314 | ||
315 | // check ESD | |
316 | if( !lESD ) | |
317 | { | |
318 | AliInfo("Error: ESD event not available"); | |
319 | return; | |
4d610fd5 | 320 | } |
56218672 | 321 | |
56218672 | 322 | Int_t nTracks = Int_t(lESD->GetNumberOfMuonTracks()); |
56218672 | 323 | for( Int_t iTrack = 0; iTrack < nTracks; iTrack++ ) |
324 | { | |
325 | ||
326 | AliESDMuonTrack* esdTrack = lESD->GetMuonTrack(iTrack); | |
fe0324de | 327 | if (!esdTrack->ContainTrackerData()) continue; |
56218672 | 328 | if (!esdTrack->ContainTriggerData()) continue; |
329 | ||
330 | Double_t invBenMom = esdTrack->GetInverseBendingMomentum(); | |
56218672 | 331 | if (TMath::Abs(invBenMom)<=1.04) |
332 | { | |
333 | ||
334 | AliMUONTrack track; | |
335 | AliMUONESDInterface::ESDToMUON(*esdTrack, track); | |
336 | ||
337 | // process track and retrieve corresponding records, for storage | |
516043cd | 338 | const AliMillePedeRecord* lRecords( fAlign->ProcessTrack( &track, fDoAlignment ) ); |
339 | ++fTrackOk; | |
56218672 | 340 | |
341 | // store in array | |
342 | if( fWriteRecords && fRecords ) | |
516043cd | 343 | { |
344 | new((*fRecords)[fRecordCount]) AliMillePedeRecord( *lRecords ); | |
56218672 | 345 | ++fRecordCount; |
346 | } | |
347 | ||
516043cd | 348 | } |
349 | ||
56218672 | 350 | ++fTrackTot; |
351 | ||
516043cd | 352 | if(!(fTrackTot%100)) |
56218672 | 353 | { AliInfo( Form( "Processed %i Tracks and %i were fitted.", fTrackTot, fTrackOk ) ); } |
354 | ||
56218672 | 355 | // Post final data. Write histo list to a file with option "RECREATE" |
516043cd | 356 | // PostData(1,fList); |
56218672 | 357 | |
358 | } | |
359 | ||
360 | // save AOD | |
516043cd | 361 | if( fWriteRecords && fRecordCount > 0 ) |
362 | { | |
ec542584 | 363 | AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() ); |
364 | if( handler ) | |
516043cd | 365 | { |
366 | AliAODEvent* aod = handler->GetAOD(); | |
367 | AliAODHeader* header = aod->GetHeader(); | |
368 | header->SetRunNumber(lESD->GetRunNumber()); | |
369 | AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE); | |
370 | ||
371 | } else AliInfo( "Error: invalid output event handler" ); | |
372 | ||
ec542584 | 373 | } |
56218672 | 374 | |
4d610fd5 | 375 | } |
56218672 | 376 | |
377 | } | |
378 | ||
4d610fd5 | 379 | //________________________________________________________________________ |
2df5c2cf | 380 | void AliMUONAlignmentTask::FinishTaskOutput() |
4d610fd5 | 381 | { |
56218672 | 382 | |
4d610fd5 | 383 | /// Called once per task on the client machine at the end of the analysis. |
56218672 | 384 | AliInfo( Form( "Processed %i tracks.", fTrackTot ) ); |
385 | AliInfo( Form( "Accepted %i tracks.", fTrackOk ) ); | |
386 | ||
387 | // stop here if no alignment is to be performed | |
388 | if( !fDoAlignment ) return; | |
389 | ||
390 | AliLog::SetGlobalLogLevel(AliLog::kInfo); | |
4d610fd5 | 391 | |
4d610fd5 | 392 | // Perform global fit |
393 | fAlign->GlobalFit(fParameters,fErrors,fPulls); | |
4d610fd5 | 394 | Int_t idOffset = 0; // 400 |
395 | Int_t lSDetElemCh = 0; | |
516043cd | 396 | |
397 | for( Int_t iDE=0; iDE<AliMUONAlignment::fgNDetElem; iDE++ ) | |
56218672 | 398 | { |
399 | ||
516043cd | 400 | Int_t detElemId = idOffset+100; |
401 | detElemId += iDE; | |
4d610fd5 | 402 | lSDetElemCh = 0; |
56218672 | 403 | for(Int_t iCh=0; iCh<9; iCh++) |
404 | { | |
56218672 | 405 | |
516043cd | 406 | lSDetElemCh += AliMUONAlignment::fgNDetElemCh[iCh]; |
56218672 | 407 | if (iDE>=lSDetElemCh) |
408 | { | |
516043cd | 409 | detElemId += 100; |
410 | detElemId -= AliMUONAlignment::fgNDetElemCh[iCh]; | |
4d610fd5 | 411 | } |
56218672 | 412 | |
4d610fd5 | 413 | } |
56218672 | 414 | |
4d610fd5 | 415 | } |
416 | ||
417 | // Post final data. Write histo list to a file with option "RECREATE" | |
516043cd | 418 | // PostData(1,fList); |
56218672 | 419 | |
516043cd | 420 | // store misalignments from OCDB into old transformers |
421 | if( fMergeAlignmentCDBs ) | |
422 | { SaveMisAlignmentData( fOldGeoTransformer ); } | |
4d610fd5 | 423 | |
4d610fd5 | 424 | // Re Align |
516043cd | 425 | fNewGeoTransformer = fAlign->ReAlign( fOldGeoTransformer, fParameters, true ); |
56218672 | 426 | |
4d610fd5 | 427 | // Generate realigned data in local cdb |
56218672 | 428 | const TClonesArray* array = fNewGeoTransformer->GetMisAlignmentData(); |
4d610fd5 | 429 | |
430 | // 100 mum residual resolution for chamber misalignments? | |
516043cd | 431 | fAlign->SetAlignmentResolution( array, -1, 0.01, 0.01, 0.004, 0.003 ); |
56218672 | 432 | |
4d610fd5 | 433 | // CDB manager |
56218672 | 434 | AliLog::SetGlobalDebugLevel(2); |
56218672 | 435 | |
516043cd | 436 | // recover default storage full name (raw:// cannot be used to set specific storage) |
437 | AliCDBManager* cdbManager = AliCDBManager::Instance(); | |
438 | ||
439 | // unload old alignment path | |
440 | if( cdbManager->GetEntryCache()->Contains("MUON/Align/Data") ) | |
441 | { cdbManager->UnloadFromCache("MUON/Align/Data"); } | |
56218672 | 442 | |
516043cd | 443 | // load new alignment path |
444 | if( !fNewAlignStorage.IsNull() ) cdbManager->SetSpecificStorage("MUON/Align/Data",fNewAlignStorage.Data()); | |
445 | else { | |
56218672 | 446 | |
516043cd | 447 | TString defaultStorage(cdbManager->GetDefaultStorage()->GetType()); |
448 | if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbManager->GetDefaultStorage()->GetBaseFolder().Data()); | |
449 | else defaultStorage += Form("://%s", cdbManager->GetDefaultStorage()->GetBaseFolder().Data()); | |
450 | cdbManager->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data()); | |
451 | ||
452 | } | |
56218672 | 453 | |
516043cd | 454 | // create new DB entry |
4d610fd5 | 455 | AliCDBMetaData* cdbData = new AliCDBMetaData(); |
456 | cdbData->SetResponsible("Dimuon Offline project"); | |
457 | cdbData->SetComment("MUON alignment objects with residual misalignment"); | |
56218672 | 458 | AliCDBId id("MUON/Align/Data", 0, AliCDBRunRange::Infinity()); |
516043cd | 459 | cdbManager->Put(const_cast<TClonesArray*>(array), id, cdbData); |
4d610fd5 | 460 | |
461 | } | |
462 | ||
2df5c2cf | 463 | //________________________________________________________________________ |
56218672 | 464 | void AliMUONAlignmentTask::NotifyRun() |
2df5c2cf | 465 | { |
516043cd | 466 | |
467 | /// run number (re)initialization | |
468 | ||
469 | // propagate run number to fAlign | |
470 | if( fAlign ) fAlign->SetRunNumber( fCurrentRunNumber ); | |
471 | ||
472 | // update ocdb | |
473 | if (fOCDBLoaded && fLoadOCDBOnce) | |
474 | { | |
475 | AliError(Form("OCDB already loaded %d %d",fOCDBLoaded,fLoadOCDBOnce)); | |
56218672 | 476 | return; |
477 | } | |
2df5c2cf | 478 | |
516043cd | 479 | AliCDBManager* cdbManager = AliCDBManager::Instance(); |
480 | ||
481 | // Initialize default storage | |
482 | if( !( cdbManager->IsDefaultStorageSet() || fDefaultStorage.IsNull() ) ) | |
483 | { | |
484 | ||
485 | AliInfo( Form( "Initializing default storage: %s", fDefaultStorage.Data() ) ); | |
486 | cdbManager->SetDefaultStorage(fDefaultStorage.Data()); | |
487 | ||
488 | } else if( !fDefaultStorage.IsNull() ) { | |
489 | ||
490 | AliInfo( "Default storage already set. Ignoring fDefaultStorage" ); | |
491 | ||
492 | } else { | |
493 | ||
494 | AliInfo( "Default storage already set" ); | |
495 | ||
496 | } | |
497 | ||
498 | // Initialize run number | |
499 | if( cdbManager->GetRun() < 0 ) | |
500 | { | |
501 | AliInfo( Form( "Setting run number: %i", fCurrentRunNumber ) ); | |
502 | cdbManager->SetRun(fCurrentRunNumber); | |
503 | } | |
504 | ||
505 | // following initialization is not needed when reading records | |
506 | if( !fReadRecords ) | |
507 | { | |
508 | ||
509 | // load magnetic field if needed | |
510 | if( !TGeoGlobalMagField::Instance()->IsLocked() ) | |
511 | { | |
2df5c2cf | 512 | |
516043cd | 513 | AliInfo( "Loading magnetic field" ); |
514 | if( !AliMUONCDB::LoadField() ) | |
515 | { | |
516 | AliError( "Failed to load magnetic field" ); | |
517 | return; | |
518 | } | |
cd8521dd | 519 | |
516043cd | 520 | } else { AliInfo( "Magnetic field already locked" ); } |
2df5c2cf | 521 | |
516043cd | 522 | // checking magnitic field |
523 | if( !fForceBField ) | |
524 | { | |
525 | AliInfo( "Reading magnetic field setup from GRP" ); | |
526 | ||
527 | // decide bFieldOn value base on dipole current | |
528 | // propagete to Alignment class | |
529 | // and printout | |
530 | AliMagF* magF = dynamic_cast<AliMagF*>( TGeoGlobalMagField::Instance()->GetField() ); | |
531 | fBFieldOn = TMath::Abs( magF->GetFactorDip() ) > 1e-5; | |
532 | fAlign->SetBFieldOn( fBFieldOn ); | |
533 | AliInfo( Form( "Dipole magnetic field factor: %.2f", magF->GetFactorDip() ) ); | |
534 | AliInfo( Form( "fBFieldOn = %s", (fBFieldOn ? "kTRUE":"kFALSE") ) ); | |
535 | } | |
56218672 | 536 | |
516043cd | 537 | AliInfo( "Loading muon mapping" ); |
538 | if( !AliMUONCDB::LoadMapping(kFALSE) ) | |
539 | { | |
540 | AliError( "Failed to load muon mapping" ); | |
541 | return; | |
542 | } | |
56218672 | 543 | |
516043cd | 544 | AliInfo( "Assigning field to Track extrapolator" ); |
545 | AliMUONTrackExtrap::SetField(); | |
56218672 | 546 | |
516043cd | 547 | } |
56218672 | 548 | |
516043cd | 549 | // load geometry if needed |
550 | if( !AliGeomManager::GetGeometry() ) | |
56218672 | 551 | { |
552 | ||
516043cd | 553 | // reset existing geometry/alignment if any |
554 | if( cdbManager->GetEntryCache()->Contains("GRP/Geometry/Data") ) | |
555 | { | |
556 | AliInfo( "Unloading GRP/Geometry/Data" ); | |
557 | cdbManager->UnloadFromCache("GRP/Geometry/Data"); | |
558 | } | |
559 | ||
560 | if( cdbManager->GetEntryCache()->Contains("MUON/Align/Data") ) | |
561 | { | |
562 | AliInfo( Form( "Unloading MUON/Align/Data from %s", cdbManager->GetSpecificStorage( "MUON/Align/Data" )->GetBaseFolder().Data() ) ); | |
563 | cdbManager->UnloadFromCache("MUON/Align/Data"); | |
564 | } | |
565 | ||
566 | // get original geometry transformer | |
567 | AliInfo( "Loading geometry" ); | |
568 | AliGeomManager::LoadGeometry(); | |
569 | if (!AliGeomManager::GetGeometry()) | |
570 | { | |
571 | AliError("Failed to load geometry"); | |
572 | return; | |
573 | } | |
574 | ||
575 | if (!fOldAlignStorage.IsNull()) | |
576 | { | |
577 | ||
578 | AliInfo( Form( "Initializing MUON/Align/Data using: %s", fOldAlignStorage.Data() ) ); | |
579 | cdbManager->SetSpecificStorage("MUON/Align/Data",fOldAlignStorage.Data()); | |
580 | ||
581 | } else { | |
582 | ||
583 | // recover default storage full name (raw:// cannot be used to set specific storage) | |
584 | TString defaultStorage(cdbManager->GetDefaultStorage()->GetType()); | |
585 | if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbManager->GetDefaultStorage()->GetBaseFolder().Data()); | |
586 | else defaultStorage += Form("://%s", cdbManager->GetDefaultStorage()->GetBaseFolder().Data()); | |
587 | ||
588 | AliInfo( Form( "Re-initializing MUON/Align/Data using: %s", defaultStorage.Data() ) ); | |
589 | cdbManager->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data()); | |
590 | ||
591 | } | |
592 | ||
593 | AliInfo("Loading muon Alignment objects"); | |
56218672 | 594 | AliGeomManager::ApplyAlignObjsFromCDB("MUON"); |
595 | ||
516043cd | 596 | } else { AliInfo( "Geometry already initialized - fOldAlignStorage ignored" ); } |
597 | ||
598 | // update geometry transformer and pass to Alignment object | |
599 | AliInfo("Loading muon geometry in transformer"); | |
600 | fOldGeoTransformer->LoadGeometryData(); | |
601 | fAlign->SetGeometryTransformer(fOldGeoTransformer); | |
602 | ||
603 | fOCDBLoaded = kTRUE; | |
604 | ||
605 | } | |
606 | ||
607 | //_____________________________________________________________________________________ | |
608 | void AliMUONAlignmentTask::SaveMisAlignmentData( AliMUONGeometryTransformer* transformer ) const | |
609 | { | |
610 | ||
611 | // clear transformer | |
612 | transformer->ClearMisAlignmentData(); | |
613 | ||
614 | // load MUON/Align/Data from OCDB | |
615 | AliCDBManager* cdbManager = AliCDBManager::Instance(); | |
616 | AliCDBEntry* cdbEntry = cdbManager->Get( "MUON/Align/Data" ); | |
617 | if (!cdbEntry) | |
618 | { | |
619 | ||
620 | AliError( "unable to load entry for path MUON/Align/Data" ); | |
621 | return; | |
622 | ||
623 | } | |
624 | ||
625 | // get TClonesArray and check | |
626 | TClonesArray* misArray = (TClonesArray*)cdbEntry->GetObject(); | |
627 | if( !misArray ) | |
628 | { | |
629 | ||
630 | AliError( "unable to load old misalignment array" ); | |
631 | return; | |
632 | ||
56218672 | 633 | } |
634 | ||
516043cd | 635 | // loop over stored entries |
636 | for (Int_t index=0; index<misArray->GetEntriesFast(); ++index ) | |
637 | { | |
638 | ||
639 | // load matrix and check | |
640 | AliAlignObjMatrix* matrix = (AliAlignObjMatrix*) misArray->At( index ); | |
641 | if( !matrix ) | |
642 | { | |
643 | AliError( Form( "unable to load matrix for index %i", index ) ); | |
644 | continue; | |
645 | } | |
646 | ||
647 | // get volume ID | |
648 | AliGeomManager::ELayerID layerId; | |
649 | Int_t moduleId; | |
650 | matrix->GetVolUID( layerId, moduleId); | |
651 | ||
652 | // make sure ELayerID is correct | |
653 | assert( layerId == AliGeomManager::kMUON ); | |
56218672 | 654 | |
516043cd | 655 | // printout |
656 | // AliInfo( Form( "Found matrix for %s %i", matrix->GetSymName(), moduleId ) ); | |
56218672 | 657 | |
516043cd | 658 | // get matrix |
659 | TGeoHMatrix misMatrix; | |
660 | matrix->GetMatrix(misMatrix); | |
661 | ||
662 | // add to geometry transformer | |
663 | // need the detector element | |
664 | // "detElement->GetId()" | |
665 | // see fOldGeoTransformer->GetMisAlignmentData( ... ) | |
666 | ||
667 | if( TString( matrix->GetSymName() ).Contains( "DE" ) ) transformer->AddMisAlignDetElement( moduleId, misMatrix); | |
668 | else transformer->AddMisAlignModule( moduleId, misMatrix); | |
669 | } | |
670 | ||
671 | return; | |
cd8521dd | 672 | } |
516043cd | 673 |