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       if( handler )
 474         {
 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" );
 484     }
 485
 486   }
 487
 488 }
 489
 490 //________________________________________________________________________
 491 void AliMUONAlignmentTask::Terminate(const Option_t*)
 492 { return; }
 493
 494 //________________________________________________________________________
 495 void AliMUONAlignmentTask::FinishTaskOutput()
 496 {
 497
 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 ) );
 501
 502   // stop here if no alignment is to be performed
 503   if( !fDoAlignment ) return;
 504
 505   AliLog::SetGlobalLogLevel(AliLog::kInfo);
 506
 507   // Perform global fit
 508   fAlign->GlobalFit(fParameters,fErrors,fPulls);
 509
 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);
 516
 517   // Store results
 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++)
 534   {
 535
 536     DEidErr[iDE] = 0.;
 537     DEid[iDE] = idOffset+100;
 538     DEid[iDE] += iDE;
 539     lSDetElemCh = 0;
 540     for(Int_t iCh=0; iCh<9; iCh++)
 541     {
 542       lSDetElemCh += lNDetElemCh[iCh];
 543
 544       if (iDE>=lSDetElemCh)
 545       {
 546         DEid[iDE] += 100;
 547         DEid[iDE] -= lNDetElemCh[iCh];
 548       }
 549
 550     }
 551
 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));
 568
 569   }
 570
 571   // Post final data. Write histo list to a file with option "RECREATE"
 572   PostData(1,fList);
 573
 574   // HUGO: stop here to test reproducibility
 575         //  return;
 576
 577   // Re Align
 578   fNewGeoTransformer = fAlign->ReAlign(fOldGeoTransformer,fParameters,true);
 579   //  newTransform->WriteTransformations("transform2ReAlign.dat");
 580
 581   // Generate realigned data in local cdb
 582   const TClonesArray* array = fNewGeoTransformer->GetMisAlignmentData();
 583
 584   // 100 mum residual resolution for chamber misalignments?
 585   fAlign->SetAlignmentResolution(array,-1,0.01,0.01,0.004,0.003);
 586
 587   // CDB manager
 588   AliLog::SetGlobalDebugLevel(2);
 589   AliCDBManager* cdbm = AliCDBManager::Instance();
 590   // cdbManager->SetDefaultStorage(fDefaultOCDB.Data());
 591
 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());
 596
 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());
 601
 602
 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);
 608
 609         gSystem->Exec("cp -a ReAlignOCDB/MUON/Align/Data/Run0_999999999_v0_s0.root Run0_999999999_v0_s0.root");
 610         gSystem->Exec("ls -l");
 611
 612 }
 613
 614 //________________________________________________________________________
 615 void AliMUONAlignmentTask::NotifyRun()
 616 {
 617
 618   if (fOCDBLoaded && fLoadOCDBOnce) { AliError(Form("OCDB already loaded %d %d",fOCDBLoaded,fLoadOCDBOnce));
 619     return;
 620   }
 621
 622   AliCDBManager* cdbm = AliCDBManager::Instance();
 623   cdbm->SetDefaultStorage(fDefaultStorage.Data());
 624 //      cdbm->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
 625
 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);
 631
 632   if (!AliMUONCDB::LoadField()) { AliError("Problem field"); return;}
 633
 634   // set the magnetic field for track extrapolations
 635   AliMUONTrackExtrap::SetField();
 636
 637   if (!AliMUONCDB::LoadMapping(kTRUE)) { AliError("Problem mapping"); return;}
 638
 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());
 643
 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();
 648
 649         // get original geometry transformer
 650         AliGeomManager::LoadGeometry();
 651         if (!AliGeomManager::GetGeometry()) { AliError("Problem geometry"); return;}
 652         if (fOldAlignStorage != "none")
 653   {
 654
 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());
 658
 659     AliGeomManager::ApplyAlignObjsFromCDB("MUON");
 660
 661   }
 662
 663   // fOldGeoTransformer = new AliMUONGeometryTransformer();
 664         fOldGeoTransformer->LoadGeometryData();
 665         fAlign->SetGeometryTransformer(fOldGeoTransformer);
 666
 667         fOCDBLoaded = kTRUE;
 668
 669 }