Coverity 17476
[u/mrichter/AliRoot.git] / MUON / AliMUONAlignmentTask.cxx
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
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.
25 ///
26 /// \author Javier Castillo, CEA/Saclay - Irfu/SPhN
27 //-----------------------------------------------------------------------------
28
29 // this class header must always come first
30 #include "AliMUONAlignmentTask.h"
31
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"
41 #include "AliMagF.h"
42 #include "AliCDBStorage.h"
43 #include "AliCDBManager.h"
44 #include "AliGRPManager.h"
45 #include "AliCDBMetaData.h"
46 #include "AliCDBId.h"
47 #include "AliGeomManager.h"
48
49 #include "AliMpCDB.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"
57
58 // system headers
59 #include <fstream>
60 #include <TString.h>
61 #include <TError.h>
62 #include <TGraphErrors.h>
63 #include <TTree.h>
64 #include <TChain.h>
65 #include <TClonesArray.h>
66 #include <TGeoGlobalMagField.h>
67 #include <TGeoManager.h>
68 #include <Riostream.h>
69
70 ///\cond CLASSIMP
71 ClassImp(AliMUONAlignmentTask)
72 ///\endcond
73
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 ),
80   fAlign(0x0),
81   fGeoFilename(geofilename),
82   fDefaultStorage(defaultocdb),
83   fOldAlignStorage(oldalignocdb),
84   fNewAlignStorage(newalignocdb),
85   fOldGeoTransformer(NULL),
86   fNewGeoTransformer(NULL),
87   fLoadOCDBOnce(kFALSE),
88   fOCDBLoaded(kFALSE),
89   fTrackTot(0),
90   fTrackOk(0),
91   fLastRunNumber(-1),
92   fMSDEx(0x0),
93   fMSDEy(0x0),
94   fMSDEz(0x0),
95   fMSDEp(0x0),
96   fList(0x0),
97   fRecords(0x0),
98   fRecordCount(0)
99 {
100   /// Default Constructor
101   // Define input and output slots here
102   // Input slot #0 works with a TChain
103   DefineInput(0, TChain::Class());
104
105   // Output slot #0 writes NTuple/histos into a TList
106   DefineOutput(1, TList::Class());
107
108   // initialize parameters ...
109   for(Int_t k=0;k<4*156;k++)
110   {
111     fParameters[k]=0.;
112     fErrors[k]=0.;
113     fPulls[k]=0.;
114   }
115
116   fOldGeoTransformer = new AliMUONGeometryTransformer();
117
118 }
119
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 )
145 {
146
147   // initialize parameters
148   for(Int_t k=0;k<4*156;k++)
149   {
150
151     fParameters[k]=other.fParameters[k];
152     fErrors[k]=other.fErrors[k];
153     fPulls[k]=other.fPulls[k];
154
155   }
156
157 }
158
159 //________________________________________________________________________
160 AliMUONAlignmentTask& AliMUONAlignmentTask::operator=(const AliMUONAlignmentTask& other)
161 {
162   /// Assignment
163   AliAnalysisTaskSE::operator=(other);
164
165   fReadRecords = other.fReadRecords;
166   fWriteRecords = other.fWriteRecords;
167   fDoAlignment = other.fDoAlignment;
168
169   // this breaks in destructor
170   fAlign = other.fAlign;
171
172   fGeoFilename = other.fGeoFilename;
173   fDefaultStorage = other.fDefaultStorage;
174   fOldAlignStorage = other.fOldAlignStorage;
175   fNewAlignStorage = other.fNewAlignStorage;
176
177   // this breaks in destructor
178   fOldGeoTransformer = other.fOldGeoTransformer;
179   fNewGeoTransformer = other.fNewGeoTransformer;
180
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;
190   fList = other.fList;
191   fRecords = other.fRecords;
192   fRecordCount = other.fRecordCount;
193
194   // initialize parameters ...
195   for( Int_t k=0; k<4*156; ++k)
196   {
197
198     fParameters[k]=other.fParameters[k];
199     fErrors[k]=other.fErrors[k];
200     fPulls[k]=other.fPulls[k];
201
202   }
203
204   return *this;
205 }
206
207 //________________________________________________________________________
208 AliMUONAlignmentTask::~AliMUONAlignmentTask()
209 {
210   /*
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.
216   */
217   delete fAlign;
218   delete fOldGeoTransformer;
219   delete fNewGeoTransformer;
220 }
221
222 //________________________________________________________________________
223 void AliMUONAlignmentTask::LocalInit()
224 {
225   /// Local initialization, called once per task on the client machine
226   /// where the analysis train is assembled
227
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" ) ) );
232
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" ); }
237
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" ); }
241
242   /* must run alignment when reading records */
243   if( fReadRecords && !fDoAlignment )
244   {
245
246     AliInfo( "Automatically setting fDoAlignment to kTRUE because fReadRecords is kTRUE" );
247     SetDoAlignment( kTRUE );
248
249   }
250
251   // Set initial values here, good guess may help convergence
252   // St 1
253   //  Int_t iPar = 0;
254   //  fParameters[iPar++] =  0.010300 ;  fParameters[iPar++] =  0.010600 ;  fParameters[iPar++] =  0.000396 ;
255
256   fAlign = new AliMUONAlignment();
257   fAlign->InitGlobalParameters(fParameters);
258
259 //  AliCDBManager::Instance()->Print();
260 //
261 //  fAlign->SetGeometryTransformer(fOldGeoTransformer);
262
263   // Do alignment with magnetic field off
264   fAlign->SetBFieldOn(kFALSE);
265
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};
269
270   // Set degrees of freedom to align (see AliMUONAlignment)
271   fAlign->AllowVariations(bChOnOff);
272
273   // Set expected resolution (see AliMUONAlignment)
274   fAlign->SetSigmaXY(0.15,0.10);
275
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);
281
282   // Left and right sides of the detector are independent, one can choose to align
283   // only one side
284   Bool_t bSpecLROnOff[2] = {kTRUE,kTRUE};
285   fAlign->FixHalfSpectrometer(bChOnOff,bSpecLROnOff);
286
287   fAlign->SetChOnOff(bChOnOff);
288   fAlign->SetSpecLROnOff(bChOnOff);
289
290     // Here we can fix some detection elements
291   //  fAlign->FixDetElem(908);
292         //  fAlign->FixDetElem(1012);
293         fAlign->FixDetElem(608);
294
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);
299
300 }
301
302 //________________________________________________________________________
303 void AliMUONAlignmentTask::UserCreateOutputObjects()
304 {
305
306   if( fDoAlignment )
307   {
308
309     // Creating graphs
310     fMSDEx = new TGraphErrors(156);
311     fMSDEy = new TGraphErrors(156);
312     fMSDEz = new TGraphErrors(156);
313     fMSDEp = new TGraphErrors(156);
314
315     // Add Ntuples to the list
316     fList = new TList();
317     fList->Add(fMSDEx);
318     fList->Add(fMSDEy);
319     fList->Add(fMSDEz);
320     fList->Add(fMSDEp);
321
322     fList->SetOwner(kTRUE);
323     PostData(1, fList);
324   }
325
326   // connect AOD output
327   if( fWriteRecords )
328   {
329     AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() );
330     if( handler )
331     {
332
333       // get AOD output handler and add Branch
334       fRecords = new TClonesArray( "AliMUONAlignmentTrackRecord", 0 );
335       fRecords->SetName( "records" );
336       handler->AddBranch("TClonesArray", &fRecords);
337
338       fRecordCount = 0;
339
340     } else AliInfo( "Error: invalid output event handler" );
341
342   }
343
344 }
345
346 //________________________________________________________________________
347 void AliMUONAlignmentTask::UserExec(Option_t *)
348 {
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" ) ) );
353   // clear array
354   if( fWriteRecords && fRecords )
355   {
356     fRecords->Clear();
357     fRecordCount = 0;
358   }
359
360   // local track parameters
361   Double_t trackParams[8] = {0.,0.,0.,0.,0.,0.,0.,0.};
362
363   if( fReadRecords ) {
364
365     AliAODEvent* lAOD( dynamic_cast<AliAODEvent*>(InputEvent() ) );
366
367     // check AOD
368     if( !lAOD )
369     {
370       AliInfo("Error: AOD event not available");
371       return;
372     }
373
374     // read records
375     TClonesArray* records = static_cast<TClonesArray*>( lAOD->FindListObject( "records" ) );
376     if( !records )
377     {
378       AliInfo( "Unable to read object name \"records\"" );
379       return;
380     }
381
382     // get number of records and print
383     const Int_t lRecordsCount( records->GetEntriesFast() );
384     fTrackTot += lRecordsCount;
385
386     // loop over records
387     for( Int_t index = 0; index < lRecordsCount; ++index )
388     {
389
390       if( AliMUONAlignmentTrackRecord* record = dynamic_cast<AliMUONAlignmentTrackRecord*>( records->UncheckedAt(index) ) )
391       {
392
393         fAlign->ProcessTrack( record, fDoAlignment );
394         if( fDoAlignment )
395         { fAlign->LocalFit( fTrackOk++, trackParams, 0 ); }
396
397       } else AliInfo( Form( "Invalid record at %i", index ) );
398
399     }
400
401   } else {
402
403     /// Main loop, called for each event
404     AliESDEvent* lESD( dynamic_cast<AliESDEvent*>(InputEvent()) );
405
406     // check ESD
407     if( !lESD )
408     {
409       AliInfo("Error: ESD event not available");
410       return;
411     }
412
413 // HUGO: Comment out check on run number, to be able to run on MC
414 //     if (!lESD->GetRunNumber())
415 //     {
416 //       AliInfo( Form( "Current Run Number: %i", lESD->GetRunNumber() ) );
417 //       return;
418 //     }
419
420     //  if (lESD->GetRunNumber()!=fLastRunNumber){
421     //    fLastRunNumber = lESD->GetRunNumber();
422     //    Prepare(fGeoFilename.Data(),fDefaultOCDB.Data(),fMisAlignOCDB.Data());
423     //  }
424
425     Int_t nTracks = Int_t(lESD->GetNumberOfMuonTracks());
426 //    cout << " there are " << nTracks << " tracks" << endl;
427     for( Int_t iTrack = 0; iTrack < nTracks; iTrack++ )
428     {
429
430       AliESDMuonTrack* esdTrack = lESD->GetMuonTrack(iTrack);
431       if (!esdTrack->ClustersStored()) continue;
432       if (!esdTrack->ContainTriggerData()) continue;
433
434       Double_t invBenMom = esdTrack->GetInverseBendingMomentum();
435       //     fInvBenMom->Fill(invBenMom);
436       //     fBenMom->Fill(1./invBenMom);
437       if (TMath::Abs(invBenMom)<=1.04)
438       {
439
440         AliMUONTrack track;
441         AliMUONESDInterface::ESDToMUON(*esdTrack, track);
442
443         // process track and retrieve corresponding records, for storage
444         const AliMUONAlignmentTrackRecord* lRecords( fAlign->ProcessTrack( &track, fDoAlignment ) );
445
446         // do the fit, if required
447         if( fDoAlignment ) fAlign->LocalFit(fTrackOk++,trackParams,0);
448         else fTrackOk++;
449
450         // store in array
451         if( fWriteRecords && fRecords )
452         {                                       
453           new((*fRecords)[fRecordCount]) AliMUONAlignmentTrackRecord( *lRecords );
454           ++fRecordCount;
455         }
456
457       }                 
458                         
459       ++fTrackTot;
460
461       if(!(fTrackTot%1000))
462       { AliInfo( Form( "Processed %i Tracks and %i were fitted.", fTrackTot, fTrackOk ) ); }
463
464 //      cout << "Processed " << fTrackTot << " Tracks." << endl;
465       // Post final data. Write histo list to a file with option "RECREATE"
466       PostData(1,fList);
467
468     }
469
470     // save AOD
471     if( fWriteRecords && fRecordCount > 0 ) { 
472                         AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() );
473 //                      printf("handler: %p\n",handler);
474                         AliAODEvent* aod = handler->GetAOD();
475 //                      printf("aod: %p\n",aod);
476                         AliAODHeader* header = aod->GetHeader();
477 //                      printf("header: %p\n",header);
478                         header->SetRunNumber(lESD->GetRunNumber());
479 //                      printf("RunNumber: %d\n",lESD->GetRunNumber());
480                         AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE); }
481
482   }
483
484 }
485
486 //________________________________________________________________________
487 void AliMUONAlignmentTask::Terminate(const Option_t*)
488 { return; }
489
490 //________________________________________________________________________
491 void AliMUONAlignmentTask::FinishTaskOutput()
492 {
493
494   /// Called once per task on the client machine at the end of the analysis.
495   AliInfo( Form( "Processed %i tracks.", fTrackTot ) );
496   AliInfo( Form( "Accepted %i tracks.", fTrackOk ) );
497
498   // stop here if no alignment is to be performed
499   if( !fDoAlignment ) return;
500
501   AliLog::SetGlobalLogLevel(AliLog::kInfo);
502
503   // Perform global fit
504   fAlign->GlobalFit(fParameters,fErrors,fPulls);
505
506 //   // Update pointers reading them from the output slot
507 //   fList = (TList*)GetOutputData(0);
508 //   fMSDEx = (TGraphErrors*)fList->At(0);
509 //   fMSDEy = (TGraphErrors*)fList->At(1);
510 //   fMSDEz = (TGraphErrors*)fList->At(2);
511 //   fMSDEp = (TGraphErrors*)fList->At(3);
512
513   // Store results
514   Double_t DEid[156] = {0};
515   Double_t MSDEx[156] = {0};
516   Double_t MSDEy[156] = {0};
517   Double_t MSDEz[156] = {0};
518   Double_t MSDEp[156] = {0};
519   Double_t DEidErr[156] = {0};
520   Double_t MSDExErr[156] = {0};
521   Double_t MSDEyErr[156] = {0};
522   Double_t MSDEzErr[156] = {0};
523   Double_t MSDEpErr[156] = {0};
524   Int_t lNDetElem = 4*2+4*2+18*2+26*2+26*2;
525   Int_t lNDetElemCh[10] = {4,4,4,4,18,18,26,26,26,26};
526   // Int_t lSNDetElemCh[10] = {4,8,12,16,34,52,78,104,130,156};
527   Int_t idOffset = 0; // 400
528   Int_t lSDetElemCh = 0;
529   for(Int_t iDE=0; iDE<lNDetElem; iDE++)
530   {
531
532     DEidErr[iDE] = 0.;
533     DEid[iDE] = idOffset+100;
534     DEid[iDE] += iDE;
535     lSDetElemCh = 0;
536     for(Int_t iCh=0; iCh<9; iCh++)
537     {
538       lSDetElemCh += lNDetElemCh[iCh];
539
540       if (iDE>=lSDetElemCh)
541       {
542         DEid[iDE] += 100;
543         DEid[iDE] -= lNDetElemCh[iCh];
544       }
545
546     }
547
548     MSDEx[iDE]=fParameters[4*iDE+0];
549     MSDEy[iDE]=fParameters[4*iDE+1];
550     MSDEz[iDE]=fParameters[4*iDE+3];
551     MSDEp[iDE]=fParameters[4*iDE+2];
552     MSDExErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+0);
553     MSDEyErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+1);
554     MSDEzErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+3);
555     MSDEpErr[iDE]=(Double_t)fAlign->GetParError(4*iDE+2);
556     fMSDEx->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+0]);
557     fMSDEx->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+0));
558     fMSDEy->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+1]);
559     fMSDEy->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+1));
560     fMSDEz->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+3]);
561     fMSDEz->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+3));
562     fMSDEp->SetPoint(iDE,DEid[iDE],fParameters[4*iDE+2]);
563     fMSDEp->SetPointError(iDE,DEidErr[iDE],(Double_t)fAlign->GetParError(4*iDE+2));
564
565   }
566
567   // Post final data. Write histo list to a file with option "RECREATE"
568   PostData(1,fList);
569
570   // HUGO: stop here to test reproducibility
571         //  return;
572
573   // Re Align
574   fNewGeoTransformer = fAlign->ReAlign(fOldGeoTransformer,fParameters,true);
575   //  newTransform->WriteTransformations("transform2ReAlign.dat");
576
577   // Generate realigned data in local cdb
578   const TClonesArray* array = fNewGeoTransformer->GetMisAlignmentData();
579
580   // 100 mum residual resolution for chamber misalignments?
581   fAlign->SetAlignmentResolution(array,-1,0.01,0.01,0.004,0.003);
582
583   // CDB manager
584   AliLog::SetGlobalDebugLevel(2);
585   AliCDBManager* cdbm = AliCDBManager::Instance();
586   // cdbManager->SetDefaultStorage(fDefaultOCDB.Data());
587
588         // recover default storage full name (raw:// cannot be used to set specific storage)
589         TString defaultStorage(cdbm->GetDefaultStorage()->GetType());
590         if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
591         else defaultStorage += Form("://%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
592
593         if (fOldAlignStorage != "none") cdbm->UnloadFromCache("MUON/Align/Data");
594         if (!fNewAlignStorage.IsNull()) cdbm->SetSpecificStorage("MUON/Align/Data",fNewAlignStorage.Data());
595         //      else cdbm->SetSpecificStorage("MUON/Align/Data",fDefaultStorage.Data());
596         else cdbm->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data());
597
598
599   AliCDBMetaData* cdbData = new AliCDBMetaData();
600   cdbData->SetResponsible("Dimuon Offline project");
601   cdbData->SetComment("MUON alignment objects with residual misalignment");
602   AliCDBId id("MUON/Align/Data", 0, AliCDBRunRange::Infinity());
603   cdbm->Put(const_cast<TClonesArray*>(array), id, cdbData);
604
605         gSystem->Exec("cp -a ReAlignOCDB/MUON/Align/Data/Run0_999999999_v0_s0.root Run0_999999999_v0_s0.root");
606         gSystem->Exec("ls -l");
607
608 }
609
610 //________________________________________________________________________
611 void AliMUONAlignmentTask::NotifyRun()
612 {
613   
614   if (fOCDBLoaded && fLoadOCDBOnce) { AliError(Form("OCDB already loaded %d %d",fOCDBLoaded,fLoadOCDBOnce));
615     return;
616   }
617
618   AliCDBManager* cdbm = AliCDBManager::Instance();
619   cdbm->SetDefaultStorage(fDefaultStorage.Data());
620 //      cdbm->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
621
622   // HUGO: add to comment out the specific settings below in order to be able to run.
623   //cdbm->SetSpecificStorage("GRP/GRP/Data",fDefaultStorage.Data());
624         //cdbm->SetSpecificStorage("GRP/Geometry/data",fDefaultStorage.Data());
625         //cdbm->SetSpecificStorage("MUON/Calib/MappingData",fDefaultStorage.Data());
626         cdbm->SetRun(fCurrentRunNumber);
627
628   if (!AliMUONCDB::LoadField()) { AliError("Problem field"); return;}
629
630   // set the magnetic field for track extrapolations
631   AliMUONTrackExtrap::SetField();
632
633   if (!AliMUONCDB::LoadMapping(kTRUE)) { AliError("Problem mapping"); return;}
634
635         // recover default storage full name (raw:// cannot be used to set specific storage)
636         TString defaultStorage(cdbm->GetDefaultStorage()->GetType());
637         if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
638         else defaultStorage += Form("://%s", cdbm->GetDefaultStorage()->GetBaseFolder().Data());
639
640         // reset existing geometry/alignment if any
641         if (cdbm->GetEntryCache()->Contains("GRP/Geometry/Data")) cdbm->UnloadFromCache("GRP/Geometry/Data");
642         if (cdbm->GetEntryCache()->Contains("MUON/Align/Data")) cdbm->UnloadFromCache("MUON/Align/Data");
643         if (AliGeomManager::GetGeometry()) AliGeomManager::GetGeometry()->UnlockGeometry();
644
645         // get original geometry transformer
646         AliGeomManager::LoadGeometry();
647         if (!AliGeomManager::GetGeometry()) { AliError("Problem geometry"); return;}
648         if (fOldAlignStorage != "none")
649   {
650
651                 if (!fOldAlignStorage.IsNull()) cdbm->SetSpecificStorage("MUON/Align/Data",fOldAlignStorage.Data());
652                 else cdbm->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data());
653                 //              else cdbm->SetSpecificStorage("MUON/Align/Data",fDefaultStorage.Data());
654                 
655     AliGeomManager::ApplyAlignObjsFromCDB("MUON");
656
657   }
658
659   // fOldGeoTransformer = new AliMUONGeometryTransformer();
660         fOldGeoTransformer->LoadGeometryData();
661         fAlign->SetGeometryTransformer(fOldGeoTransformer);
662
663         fOCDBLoaded = kTRUE;
664
665 }