o add Reset function to CalPad and CalROC o Add functionality to AliTPCdataQA - Reset...
[u/mrichter/AliRoot.git] / MUON / AliMUONAlignmentTask.cxx
index cbe2478..dc09612 100644 (file)
 /// \class AliMUONAlignmentTask
 /// AliAnalysisTask to align the MUON spectrometer.
 /// The Task reads as input ESDs and feeds the MUONTracks to AliMUONAlignment.
-/// The alignment itself is performed by AliMillepede.
+/// The alignment itself is performed by AliMillePede2.
 /// A OCDB entry is written with the alignment parameters.
-/// A list of graph are written to monitor the alignment parameters.
 ///
 /// \author Javier Castillo, CEA/Saclay - Irfu/SPhN
+/// \author Hugo Pereira Da Costa, CEA/Saclay - Irfu/SPhN
 //-----------------------------------------------------------------------------
 
-#include <fstream>
-
-#include <TString.h>
-#include <TError.h>
-#include <TGraphErrors.h>
-#include <TTree.h>
-#include <TChain.h>
-#include <TClonesArray.h>
-#include <TGeoGlobalMagField.h>
-#include <TGeoManager.h>
-#include <Riostream.h>
+// this class header must always come first
+#include "AliMUONAlignmentTask.h"
 
-#include "AliAnalysisTask.h"
+// local header must come before system headers
 #include "AliAnalysisManager.h"
+#include "AliAlignObjMatrix.h"
+#include "AliAODInputHandler.h"
+#include "AliAODHandler.h"
+#include "AliAODEvent.h"
+#include "AliAODHeader.h"
+#include "AliCDBEntry.h"
 #include "AliESDInputHandler.h"
 #include "AliESDEvent.h"
 #include "AliESDMuonTrack.h"
-#include "AliMagF.h"
+#include "AliCDBStorage.h"
 #include "AliCDBManager.h"
 #include "AliGRPManager.h"
 #include "AliCDBMetaData.h"
 #include "AliCDBId.h"
 #include "AliGeomManager.h"
 
+#include "AliMagF.h"
+#include "AliMillePedeRecord.h"
 #include "AliMpCDB.h"
+#include "AliMUONCDB.h"
 #include "AliMUONAlignment.h"
+#include "AliMUONConstants.h"
+#include "AliMUONRecoParam.h"
 #include "AliMUONTrack.h"
 #include "AliMUONTrackExtrap.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONGeometryTransformer.h"
 #include "AliMUONESDInterface.h"
 
-#include "AliMUONAlignmentTask.h"
+// system headers
+#include <cassert>
+#include <fstream>
+
+// root headers
+#include <TString.h>
+#include <TError.h>
+#include <TFile.h>
+#include <TGraphErrors.h>
+#include <TTree.h>
+#include <TChain.h>
+#include <TClonesArray.h>
+#include <TGeoGlobalMagField.h>
+#include <TGeoManager.h>
+#include <Riostream.h>
 
-///\cond CLASSIMP  
+///\cond CLASSIMP
 ClassImp(AliMUONAlignmentTask)
 ///\endcond
 
-// //________________________________________________________________________
-// AliMUONAlignmentTask::AliMUONAlignmentTask(const char *name) 
-//   : AliAnalysisTask(name, ""),
-//     fESD(0x0),
-//     fAlign(0x0),
-//     fGeoFilename(""),
-//     fTransform(0x0),
-//     fTrackTot(0),
-//     fTrackOk(0),
-//     fMSDEx(0x0), 
-//     fMSDEy(0x0), 
-//     fMSDEz(0x0),
-//     fMSDEp(0x0),
-//     fList(0x0)
-// {
-//   /// Default Constructor
-//   // Define input and output slots here
-//   // Input slot #0 works with a TChain
-//   DefineInput(0, TChain::Class());
-//   // Output slot #0 writes NTuple/histos into a TList
-//   DefineOutput(0, TList::Class());  
-
-//   // initialize parameters ...
-//   for(Int_t k=0;k<4*156;k++) {
-//     fParameters[k]=0.;
-//     fErrors[k]=0.;
-//     fPulls[k]=0.;
-//   }
-
-//   fAlign = new AliMUONAlignment();
-//   fTransform = new AliMUONGeometryTransformer();  
-// }
-
 //________________________________________________________________________
-AliMUONAlignmentTask::AliMUONAlignmentTask(const char *name, const char *geofilename, const char *defaultocdb, const char *misalignocdb) 
-  : AliAnalysisTask(name, ""),
-    fESD(0x0),
-    fAlign(0x0),
-    fGeoFilename(geofilename),
-    fMisAlignOCDB(misalignocdb),
-    fDefaultOCDB(defaultocdb),
-    fTransform(0x0),
-    fTrackTot(0),
-    fTrackOk(0),
-    fLastRunNumber(-1),
-    fMSDEx(0x0), 
-    fMSDEy(0x0), 
-    fMSDEz(0x0),
-    fMSDEp(0x0),
-    fList(0x0)
+AliMUONAlignmentTask::AliMUONAlignmentTask( const char *name ):
+  AliAnalysisTaskSE(name),
+  fReadRecords( kFALSE ),
+  fWriteRecords( kFALSE ),
+  fDoAlignment( kTRUE ),
+  fMergeAlignmentCDBs( kTRUE ),
+  fForceBField( kFALSE ),
+  fBFieldOn( kFALSE ),
+  fAlign(0x0),
+  fDefaultStorage(),
+  fOldAlignStorage(),
+  fNewAlignStorage( "local://ReAlignOCDB" ),
+  fOldGeoTransformer(0x0),
+  fNewGeoTransformer(0x0),
+  fLoadOCDBOnce(kFALSE),
+  fOCDBLoaded(kFALSE),
+  fEvent(0),
+  fTrackTot(0),
+  fTrackOk(0),
+  fRunNumberMin(0),
+  fRunNumberMax(0),
+  fRecords(0x0),
+  fRecordCount(0)
 {
   /// Default Constructor
   // Define input and output slots here
   // Input slot #0 works with a TChain
   DefineInput(0, TChain::Class());
-  // Output slot #0 writes NTuple/histos into a TList
-  DefineOutput(0, TList::Class());  
 
   // initialize parameters ...
-  for(Int_t k=0;k<4*156;k++) {
+  for(Int_t k=0;k<AliMUONAlignment::fNGlobal;k++)
+  {
     fParameters[k]=0.;
     fErrors[k]=0.;
     fPulls[k]=0.;
   }
 
+  // create alignment object
   fAlign = new AliMUONAlignment();
-  fTransform = new AliMUONGeometryTransformer();  
+
+  // create old geometry transformer
+  fOldGeoTransformer = new AliMUONGeometryTransformer();
+
 }
 
+//________________________________________________________________________
+AliMUONAlignmentTask::~AliMUONAlignmentTask()
+{
+  /// destructor
+  delete fAlign;
+  delete fOldGeoTransformer;
+  delete fNewGeoTransformer;
+}
 
 //________________________________________________________________________
-AliMUONAlignmentTask::AliMUONAlignmentTask(const AliMUONAlignmentTask& obj) 
-  : AliAnalysisTask(obj),
-    fESD(0x0),
-    fAlign(0x0),
-    fGeoFilename(""),
-    fMisAlignOCDB(""),
-    fDefaultOCDB(""),
-    fTransform(0x0),
-    fTrackTot(0),
-    fTrackOk(0),
-    fLastRunNumber(-1),
-    fMSDEx(0x0), 
-    fMSDEy(0x0), 
-    fMSDEz(0x0),
-    fMSDEp(0x0),
-    fList(0x0)
+void AliMUONAlignmentTask::LocalInit()
 {
-  /// Copy constructor
-  fESD = obj.fESD;
-  fAlign = obj.fAlign;
-  fGeoFilename = obj.fGeoFilename;
-  fTransform = obj.fTransform;
-  fTrackTot = obj.fTrackTot;  
-  fTrackOk = obj.fTrackOk;  
-  fLastRunNumber = obj.fLastRunNumber;
-  fMSDEx = obj.fMSDEx; 
-  fMSDEy = obj.fMSDEy; 
-  fMSDEz = obj.fMSDEz;
-  fMSDEp = obj.fMSDEp;
-  fList = obj.fList;  
+  /**
+  Local initialization, called once per task on the client machine
+  where the analysis train is assembled
+  **/
+
+  /* must run alignment when reading records */
+  if( fReadRecords && !fDoAlignment )
+  {
+
+    AliInfo( "Automatically setting fDoAlignment to kTRUE because fReadRecords is kTRUE" );
+    SetDoAlignment( kTRUE );
 
-  // initialize parameters ...
-  for(Int_t k=0;k<4*156;k++) {
-    fParameters[k]=obj.fParameters[k];
-    fErrors[k]=obj.fErrors[k];
-    fPulls[k]=obj.fPulls[k];
   }
 
-}
+  // print configuration
+  if( fRunNumberMin > 0 || fRunNumberMax > 0 )
+  { AliInfo( Form( "run range: %i - %i", fRunNumberMin, fRunNumberMax ) ); }
 
-//________________________________________________________________________
-AliMUONAlignmentTask& AliMUONAlignmentTask::operator=(const AliMUONAlignmentTask& other) 
-{
-  /// Assignment
-  AliAnalysisTask::operator=(other);
-  fESD = other.fESD;
-  fAlign = other.fAlign;
-  fGeoFilename = other.fGeoFilename;
-  fMisAlignOCDB = other.fMisAlignOCDB;
-  fDefaultOCDB = other.fDefaultOCDB;
-  fTransform = other.fTransform;
-  fTrackTot = other.fTrackTot;  
-  fTrackOk = other.fTrackOk;  
-  fLastRunNumber = other.fLastRunNumber;
-  fMSDEx = other.fMSDEx; 
-  fMSDEy = other.fMSDEy; 
-  fMSDEz = other.fMSDEz;
-  fMSDEp = other.fMSDEp;
-  fList = other.fList;  
+  AliInfo( Form( "fReadRecords: %s", (fReadRecords ? "kTRUE":"kFALSE" ) ) );
+  AliInfo( Form( "fWriteRecords: %s", (fWriteRecords ? "kTRUE":"kFALSE" ) ) );
+  AliInfo( Form( "fDoAlignment: %s", (fDoAlignment ? "kTRUE":"kFALSE" ) ) );
 
-  // initialize parameters ...
-  for(Int_t k=0;k<4*156;k++) {
-    fParameters[k]=other.fParameters[k];
-    fErrors[k]=other.fErrors[k];
-    fPulls[k]=other.fPulls[k];
+  if( fDoAlignment )
+  {
+    // merge alignment DB flag is irrelevant if not actually performing the alignemnt
+    AliInfo( Form( "fMergeAlignmentCDBs: %s", (fMergeAlignmentCDBs ? "kTRUE":"kFALSE" ) ) );
   }
-  
-  return *this;
-}
 
-//________________________________________________________________________
-AliMUONAlignmentTask::~AliMUONAlignmentTask() 
-{ 
-  /// Destructor
-  if (fAlign) delete fAlign;
-  if (fTransform) delete fTransform;
-}
+  // storage elements
+  if( !fDefaultStorage.IsNull() ) AliInfo( Form( "fDefaultStorage: %s", fDefaultStorage.Data() ) );
+  if( !fOldAlignStorage.IsNull() ) AliInfo( Form( "fOldAlignStorage: %s", fOldAlignStorage.Data() ) );
 
-//________________________________________________________________________
-void AliMUONAlignmentTask::LocalInit() 
-{
-  /// Local initialization, called once per task on the client machine 
-  /// where the analysis train is assembled
-  fLastRunNumber = 0; 
-  //  Prepare(fGeoFilename.Data(),fDefaultOCDB.Data(),fMisAlignOCDB.Data());
-  Prepare(fGeoFilename.Data(),"local://$ALICE_ROOT/OCDB",fMisAlignOCDB.Data());
-  fLastRunNumber = -1;
+  if( fDoAlignment )
+  {
+    // new alignment storage is irrelevant if not actually performing the alignemnt
+    if( !fNewAlignStorage.IsNull() ) AliInfo( Form( "fNewAlignStorage: %s", fNewAlignStorage.Data() ) );
+    else AliFatal( "Invalid new alignment storage path" );
+  }
 
-  // Set initial values here, good guess may help convergence
-  // St 1 
-  //  Int_t iPar = 0;
-  //  fParameters[iPar++] =  0.010300 ;  fParameters[iPar++] =  0.010600 ;  fParameters[iPar++] =  0.000396 ;  
+  if( !fReadRecords )
+  {
+    // following flags are only relevant if not reading records
+    if( fForceBField ) AliInfo( Form( "fBFieldOn: %s", (fBFieldOn ? "kTRUE":"kFALSE" ) ) );
+    else AliInfo( "fBFieldOn: from GRP" );
+  }
 
+  // consistency checks between flags
+  /* need at least one of the flags set to true */
+  if( !( fReadRecords || fWriteRecords || fDoAlignment ) )
+  { AliFatal( "Need at least one of the three flags fReadRecords, fWriteRecords and fDoAlignment set to kTRUE" ); }
 
-  fAlign->InitGlobalParameters(fParameters);
+  /* cannot read and write records at the same time */
+  if( fReadRecords && fWriteRecords )
+  { AliFatal( "Cannot set both fReadRecords and fWriteRecords to kTRUE at the same time" ); }
 
+  /*
+  fix detectors
+  warning, counting chambers from 1.
+  this must be done before calling the Init method
+  */
+  if( fDoAlignment )
+  {
 
-  fTransform->LoadGeometryData();
-  fAlign->SetGeometryTransformer(fTransform);
+    fAlign->FixChamber(1);
+    fAlign->FixChamber(10);
+
+  } else {
+
+    AliInfo( "Not fixing detector elements, since alignment is not required" );
+
+  }
+
+  // initialize
+  fAlign->Init();
 
   // Do alignment with magnetic field off
-  fAlign->SetBFieldOn(kFALSE);
-  
-  // Set tracking station to use
-  //  Bool_t bStOnOff[5] = {kTRUE,kTRUE,kTRUE,kTRUE,kTRUE};
-  Bool_t bChOnOff[10] = {kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kFALSE,kTRUE,kTRUE,kTRUE,kTRUE};
-
-  // Set degrees of freedom to align (see AliMUONAlignment)
-  fAlign->AllowVariations(bChOnOff);
-
-  // Fix parameters or add constraints here
-  //   for (Int_t iSt=0; iSt<5; iSt++)
-  //     if (!bStOnOff[iSt]) fAlign->FixStation(iSt+1);
-  for (Int_t iCh=0; iCh<10; iCh++)
-    if (!bChOnOff[iCh]) fAlign->FixChamber(iCh+1);
-
-  // Left and right sides of the detector are independent, one can choose to align 
-  // only one side
-  Bool_t bSpecLROnOff[2] = {kTRUE,kTRUE};
-  fAlign->FixHalfSpectrometer(bChOnOff,bSpecLROnOff);
-
-  fAlign->SetChOnOff(bChOnOff);
-  fAlign->SetSpecLROnOff(bChOnOff);
-
-    // Here we can fix some detection elements
-  fAlign->FixDetElem(908);
-  fAlign->FixDetElem(1020);
-
-  // Set predifined global constrains: X, Y, P, XvsZ, YvsZ, PvsZ, XvsY, YvsY, PvsY
-//   Bool_t bVarXYT[9] = {kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE};
-//   Bool_t bDetTLBR[4] = {kFALSE,kTRUE,kFALSE,kTRUE};
-  //  fAlign->AddConstraints(bChOnOff,bVarXYT,bDetTLBR,bSpecLROnOff);
+  fAlign->SetBFieldOn( fBFieldOn );
+
+  // Set expected resolution (see AliMUONAlignment)
+  fAlign->SetSigmaXY(0.15,0.10);
+
+  // initialize global parameters to provided values
+  fAlign->InitGlobalParameters(fParameters);
 
 }
 
 //________________________________________________________________________
-void AliMUONAlignmentTask::ConnectInputData(Option_t *) 
+void AliMUONAlignmentTask::UserCreateOutputObjects()
 {
-  /// Connect ESD here. Called on each input data change.
 
-  // Connect ESD here
-  TTree* esdTree = dynamic_cast<TTree*> (GetInputData(0));
-  if (!esdTree) {
-    Printf("ERROR: Could not read chain from input slot 0");
-  } 
-  else {
-    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());   
-    if (!esdH) {
-      Printf("ERROR: Could not get ESDInputHandler");
-    } 
-    else {
-      fESD = esdH->GetEvent();
-    }
+  // connect AOD output
+  if( fWriteRecords )
+  {
+    AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() );
+    if( handler )
+    {
+
+      // get AOD output handler and add Branch
+      fRecords = new TClonesArray( "AliMillePedeRecord", 0 );
+      fRecords->SetName( "records" );
+      handler->AddBranch("TClonesArray", &fRecords);
+
+      fRecordCount = 0;
+
+    } else AliFatal( "Error: invalid output event handler" );
+
   }
-}
 
-//________________________________________________________________________
-void AliMUONAlignmentTask::CreateOutputObjects()
-{
-  /// Executed once on each worker (machine actually running the analysis code)
-  //
-  // This method has to be called INSIDE the user redefined CreateOutputObjects
-  // method, before creating each object corresponding to the output containers
-  // that are to be written to a file. This need to be done in general for the big output
-  // objects that may not fit memory during processing. 
-  //  OpenFile(0); 
-
-  // Creating graphs 
-  fMSDEx = new TGraphErrors(156);
-  fMSDEy = new TGraphErrors(156);
-  fMSDEz = new TGraphErrors(156);
-  fMSDEp = new TGraphErrors(156);
-
-  // Add Ntuples to the list
-  fList = new TList();
-  fList->Add(fMSDEx);
-  fList->Add(fMSDEy);
-  fList->Add(fMSDEz);
-  fList->Add(fMSDEp);
 }
 
 //________________________________________________________________________
-void AliMUONAlignmentTask::Exec(Option_t *) 
+void AliMUONAlignmentTask::UserExec(Option_t *)
 {
-  /// Main loop, called for each event
-  if (!fESD) {
-    Printf("ERROR: fESD not available");
-    return;
-  }
 
-  Double_t trackParams[8] = {0.,0.,0.,0.,0.,0.,0.,0.};
-  if (fESD->GetRunNumber()!=fLastRunNumber){
-    fLastRunNumber = fESD->GetRunNumber();
-    Prepare(fGeoFilename.Data(),fDefaultOCDB.Data(),fMisAlignOCDB.Data());
+  // do nothing if run number not in range
+  if( fRunNumberMin > 0 && fCurrentRunNumber < fRunNumberMin ) return;
+  if( fRunNumberMax > 0 && fCurrentRunNumber > fRunNumberMax ) return;
+
+  // increase event count
+  ++fEvent;
+
+  // clear array
+  if( fWriteRecords && fRecords )
+  {
+    fRecords->Clear();
+    fRecordCount = 0;
   }
-  Int_t nTracks = Int_t(fESD->GetNumberOfMuonTracks());
-  //  if (!event%100) cout << " there are " << nTracks << " tracks in event " << event << endl;
-  for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
-    AliESDMuonTrack* esdTrack = fESD->GetMuonTrack(iTrack);
-    if (!esdTrack->ClustersStored()) continue;
-    Double_t invBenMom = esdTrack->GetInverseBendingMomentum();
-//     fInvBenMom->Fill(invBenMom);
-//     fBenMom->Fill(1./invBenMom);
-    if (TMath::Abs(invBenMom)<=1.04) {
-      AliMUONTrack track;
-      AliMUONESDInterface::ESDToMUON(*esdTrack, track);
-      fAlign->ProcessTrack(&track);
-      fAlign->LocalFit(fTrackOk++,trackParams,0);
+
+  if( fReadRecords )
+  {
+
+    AliAODEvent* lAOD( dynamic_cast<AliAODEvent*>(InputEvent() ) );
+
+    // check AOD
+    if( !lAOD )
+    {
+      AliInfo("Error: AOD event not available");
+      return;
+    }
+
+    // read records
+    TClonesArray* records = static_cast<TClonesArray*>( lAOD->FindListObject( "records" ) );
+    if( !records )
+    {
+      AliInfo( "Unable to read object name \"records\"" );
+      return;
+    }
+
+    // get number of records and print
+    const Int_t lRecordsCount( records->GetEntriesFast() );
+    fTrackTot += lRecordsCount;
+
+    // loop over records
+    for( Int_t index = 0; index < lRecordsCount; ++index )
+    {
+
+      if( AliMillePedeRecord* record = dynamic_cast<AliMillePedeRecord*>( records->UncheckedAt(index) ) )
+      {
+
+        fAlign->ProcessTrack( record );
+        ++fTrackOk;
+
+        if(!(fTrackTot%100))
+        { AliInfo( Form( "Processed %i Tracks and %i were fitted.", fTrackTot, fTrackOk ) ); }
+
+      } else AliInfo( Form( "Invalid record at %i", index ) );
+
+    }
+
+  } else {
+
+    /// Main loop, called for each event
+    AliESDEvent* lESD( dynamic_cast<AliESDEvent*>(InputEvent()) );
+
+    // check ESD
+    if( !lESD )
+    {
+      AliInfo("Error: ESD event not available");
+      return;
+    }
+
+    Int_t nTracks = Int_t(lESD->GetNumberOfMuonTracks());
+    for( Int_t iTrack = 0; iTrack < nTracks; iTrack++ )
+    {
+
+      AliESDMuonTrack* esdTrack = lESD->GetMuonTrack(iTrack);
+      if (!esdTrack->ContainTrackerData()) continue;
+      if (!esdTrack->ContainTriggerData()) continue;
+
+      Double_t invBenMom = esdTrack->GetInverseBendingMomentum();
+      if (TMath::Abs(invBenMom)<=1.04)
+      {
+
+        AliMUONTrack track;
+        AliMUONESDInterface::ESDToMUON(*esdTrack, track);
+
+        // process track and retrieve corresponding records, for storage
+        const AliMillePedeRecord* lRecords( fAlign->ProcessTrack( &track, fDoAlignment ) );
+        ++fTrackOk;
+
+        // store in array
+        if( fWriteRecords && fRecords )
+        {
+          new((*fRecords)[fRecordCount]) AliMillePedeRecord( *lRecords );
+          ++fRecordCount;
+        }
+
+      }
+
+      ++fTrackTot;
+
+      if(!(fTrackTot%100))
+      { AliInfo( Form( "Processed %i Tracks and %i were fitted.", fTrackTot, fTrackOk ) ); }
+
+      // Post final data. Write histo list to a file with option "RECREATE"
+      // PostData(1,fList);
+
     }
-    fTrackTot++;
-    cout << "Processed " << fTrackTot << " Tracks." << endl;
+
+    // save AOD
+    if( fWriteRecords && fRecordCount > 0 )
+    {
+      AliAODHandler* handler = dynamic_cast<AliAODHandler*>( AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler() );
+      if( handler )
+      {
+        AliAODEvent* aod = handler->GetAOD();
+        AliAODHeader* header = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+        if(!header) AliFatal("Not a standard AOD");
+        header->SetRunNumber(lESD->GetRunNumber());
+        AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
+
+      } else AliInfo( "Error: invalid output event handler" );
+
+    }
+
   }
-  
-  // Post final data. Write histo list to a file with option "RECREATE"
-  PostData(0,fList);
-}      
+
+}
 
 //________________________________________________________________________
 void AliMUONAlignmentTask::FinishTaskOutput()
 {
+
   /// Called once per task on the client machine at the end of the analysis.
+  AliInfo( Form( "Processed %i tracks.", fTrackTot ) );
+  AliInfo( Form( "Accepted %i tracks.", fTrackOk ) );
+
+  // stop here if no alignment is to be performed
+  if( !fDoAlignment ) return;
+
+  AliLog::SetGlobalLogLevel(AliLog::kInfo);
 
-  cout << "Processed " << fTrackTot << " Tracks." << endl;
   // Perform global fit
   fAlign->GlobalFit(fParameters,fErrors,fPulls);
-
-  cout << "Done with GlobalFit " << endl;
-
-//   // Update pointers reading them from the output slot
-//   fList = (TList*)GetOutputData(0);
-//   fMSDEx = (TGraphErrors*)fList->At(0);
-//   fMSDEy = (TGraphErrors*)fList->At(1);
-//   fMSDEz = (TGraphErrors*)fList->At(2);
-//   fMSDEp = (TGraphErrors*)fList->At(3);
-
-  // Store results
-  Double_t deId[156] = {0};
-  Double_t msdEx[156] = {0};
-  Double_t msdEy[156] = {0};
-  Double_t msdEz[156] = {0};
-  Double_t msdEp[156] = {0};
-  Double_t deIdErr[156] = {0};
-  Double_t msdExErr[156] = {0};
-  Double_t msdEyErr[156] = {0};
-  Double_t msdEzErr[156] = {0};
-  Double_t msdEpErr[156] = {0};
-  Int_t lNDetElem = 4*2+4*2+18*2+26*2+26*2;
-  Int_t lNDetElemCh[10] = {4,4,4,4,18,18,26,26,26,26};
-  // Int_t lSNDetElemCh[10] = {4,8,12,16,34,52,78,104,130,156};
   Int_t idOffset = 0; // 400
   Int_t lSDetElemCh = 0;
-  for(Int_t iDE=0; iDE<lNDetElem; iDE++){
-    deIdErr[iDE] = 0.;
-    deId[iDE] = idOffset+100;
-    deId[iDE] += iDE; 
+
+  for( Int_t iDE=0; iDE<AliMUONAlignment::fgNDetElem; iDE++ )
+  {
+
+    Int_t detElemId = idOffset+100;
+    detElemId += iDE;
     lSDetElemCh = 0;
-    for(Int_t iCh=0; iCh<9; iCh++){
-      lSDetElemCh += lNDetElemCh[iCh];
-      if (iDE>=lSDetElemCh) {
-       deId[iDE] += 100;
-       deId[iDE] -= lNDetElemCh[iCh];
+    for(Int_t iCh=0; iCh<9; iCh++)
+    {
+
+      lSDetElemCh += AliMUONAlignment::fgNDetElemCh[iCh];
+      if (iDE>=lSDetElemCh)
+      {
+        detElemId += 100;
+        detElemId -= AliMUONAlignment::fgNDetElemCh[iCh];
       }
+
     }
-    msdEx[iDE]=fParameters[3*iDE+0];
-    msdEy[iDE]=fParameters[3*iDE+1];
-    msdEz[iDE]=fParameters[3*iDE+3];
-    msdEp[iDE]=fParameters[3*iDE+2];
-    msdExErr[iDE]=(Double_t)fAlign->GetParError(3*iDE+0);
-    msdEyErr[iDE]=(Double_t)fAlign->GetParError(3*iDE+1);
-    msdEzErr[iDE]=(Double_t)fAlign->GetParError(3*iDE+3);
-    msdEpErr[iDE]=(Double_t)fAlign->GetParError(3*iDE+2);
-    fMSDEx->SetPoint(iDE,deId[iDE],fParameters[3*iDE+0]);
-    fMSDEx->SetPoint(iDE,deIdErr[iDE],(Double_t)fAlign->GetParError(3*iDE+0));
-    fMSDEy->SetPoint(iDE,deId[iDE],fParameters[3*iDE+1]);
-    fMSDEy->SetPoint(iDE,deIdErr[iDE],(Double_t)fAlign->GetParError(3*iDE+1));
-    fMSDEp->SetPoint(iDE,deId[iDE],fParameters[3*iDE+2]);
-    fMSDEp->SetPoint(iDE,deIdErr[iDE],(Double_t)fAlign->GetParError(3*iDE+2));
-    fMSDEz->SetPoint(iDE,deId[iDE],fParameters[3*iDE+3]);
-    fMSDEz->SetPoint(iDE,deIdErr[iDE],(Double_t)fAlign->GetParError(3*iDE+3));
+
   }
 
   // Post final data. Write histo list to a file with option "RECREATE"
-  PostData(0,fList);
+  // PostData(1,fList);
+
+  // store misalignments from OCDB into old transformers
+  if( fMergeAlignmentCDBs )
+  { SaveMisAlignmentData( fOldGeoTransformer ); }
 
   // Re Align
-  AliMUONGeometryTransformer *newTransform = fAlign->ReAlign(fTransform,fParameters,true); 
-  newTransform->WriteTransformations("transform2ReAlign.dat");
-  
+  fNewGeoTransformer = fAlign->ReAlign( fOldGeoTransformer, fParameters, true );
+
   // Generate realigned data in local cdb
-  const TClonesArray* array = newTransform->GetMisAlignmentData();
+  const TClonesArray* array = fNewGeoTransformer->GetMisAlignmentData();
 
   // 100 mum residual resolution for chamber misalignments?
-  fAlign->SetAlignmentResolution(array,-1,0.01,0.01,0.004,0.003);
-   
+  fAlign->SetAlignmentResolution( array, -1, 0.01, 0.01, 0.004, 0.003 );
+
   // CDB manager
+  AliLog::SetGlobalDebugLevel(2);
+
+  // recover default storage full name (raw:// cannot be used to set specific storage)
   AliCDBManager* cdbManager = AliCDBManager::Instance();
-  cdbManager->SetDefaultStorage(fDefaultOCDB.Data());
-  cdbManager->SetSpecificStorage("MUON/Align/Data",fMisAlignOCDB.Data());
-  
+
+  // unload old alignment path
+  if( cdbManager->GetEntryCache()->Contains("MUON/Align/Data") )
+  { cdbManager->UnloadFromCache("MUON/Align/Data"); }
+
+  // load new alignment path
+  if( !fNewAlignStorage.IsNull() ) cdbManager->SetSpecificStorage("MUON/Align/Data",fNewAlignStorage.Data());
+  else {
+
+    TString defaultStorage(cdbManager->GetDefaultStorage()->GetType());
+    if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbManager->GetDefaultStorage()->GetBaseFolder().Data());
+    else defaultStorage += Form("://%s", cdbManager->GetDefaultStorage()->GetBaseFolder().Data());
+    cdbManager->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data());
+
+  }
+
+  // create new DB entry
   AliCDBMetaData* cdbData = new AliCDBMetaData();
   cdbData->SetResponsible("Dimuon Offline project");
   cdbData->SetComment("MUON alignment objects with residual misalignment");
-  AliCDBId id("MUON/Align/Data", 0, AliCDBRunRange::Infinity()); 
+  AliCDBId id("MUON/Align/Data", 0, AliCDBRunRange::Infinity());
   cdbManager->Put(const_cast<TClonesArray*>(array), id, cdbData);
 
 }
 
 //________________________________________________________________________
-void AliMUONAlignmentTask::Terminate(const Option_t*)
+void AliMUONAlignmentTask::NotifyRun()
 {
-  /// Called once per task on the client machine at the end of the analysis.
 
-}
+  /// run number (re)initialization
 
-//-----------------------------------------------------------------------
-void AliMUONAlignmentTask::Prepare(const char* geoFilename, const char* defaultOCDB, const char* misAlignOCDB)
-{
-  /// Set the geometry, the magnetic field, the mapping and the reconstruction parameters
-      
-  // Load mapping
-  AliCDBManager* man = AliCDBManager::Instance();
-  man->SetDefaultStorage(defaultOCDB);
-  man->SetSpecificStorage("MUON/Align/Data",misAlignOCDB);
-  man->Print();
-  man->SetRun(fLastRunNumber);
-  if ( ! AliMpCDB::LoadDDLStore() ) {
-    Error("MUONRefit","Could not access mapping from OCDB !");
-    exit(-1);
+  // propagate run number to fAlign
+  if( fAlign ) fAlign->SetRunNumber( fCurrentRunNumber );
+
+  // update ocdb
+  if (fOCDBLoaded && fLoadOCDBOnce)
+  {
+    AliError(Form("OCDB already loaded %d %d",fOCDBLoaded,fLoadOCDBOnce));
+    return;
   }
 
-  // Import TGeo geometry (needed by AliMUONTrackExtrap::ExtrapToVertex)
-  if (!gGeoManager) {
-    AliGeomManager::LoadGeometry(geoFilename);
-    if (!gGeoManager) {
-      Error("AliMUONReAlignTask", "getting geometry from file %s failed", "generated/galice.root");
+  AliCDBManager* cdbManager = AliCDBManager::Instance();
+
+  // Initialize default storage
+  if( !( cdbManager->IsDefaultStorageSet() || fDefaultStorage.IsNull() ) )
+  {
+
+    AliInfo( Form( "Initializing default storage: %s", fDefaultStorage.Data() ) );
+    cdbManager->SetDefaultStorage(fDefaultStorage.Data());
+
+  } else if( !fDefaultStorage.IsNull() ) {
+
+    AliInfo( "Default storage already set. Ignoring fDefaultStorage" );
+
+  } else {
+
+    AliInfo( "Default storage already set" );
+
+  }
+
+  // Initialize run number
+  if( cdbManager->GetRun() < 0 )
+  {
+    AliInfo( Form( "Setting run number: %i", fCurrentRunNumber ) );
+    cdbManager->SetRun(fCurrentRunNumber);
+  }
+
+  // following initialization is not needed when reading records
+  if( !fReadRecords )
+  {
+
+    // load magnetic field if needed
+    if( !TGeoGlobalMagField::Instance()->IsLocked() )
+    {
+
+      AliInfo( "Loading magnetic field" );
+      if( !AliMUONCDB::LoadField() )
+      {
+        AliError( "Failed to load magnetic field" );
+        return;
+      }
+
+    } else { AliInfo( "Magnetic field already locked" ); }
+
+    // checking magnitic field
+    if( !fForceBField )
+    {
+      AliInfo( "Reading magnetic field setup from GRP" );
+
+      // decide bFieldOn value base on dipole current
+      // propagete to Alignment class
+      // and printout
+      AliMagF* magF = dynamic_cast<AliMagF*>( TGeoGlobalMagField::Instance()->GetField() );
+      fBFieldOn = TMath::Abs( magF->GetFactorDip() ) > 1e-5;
+      fAlign->SetBFieldOn( fBFieldOn );
+      AliInfo( Form( "Dipole magnetic field factor: %.2f", magF->GetFactorDip() ) );
+      AliInfo( Form( "fBFieldOn = %s", (fBFieldOn ? "kTRUE":"kFALSE") ) );
+    }
+
+    AliInfo( "Loading muon mapping" );
+    if( !AliMUONCDB::LoadMapping(kFALSE) )
+    {
+      AliError( "Failed to load muon mapping" );
       return;
     }
+
+    AliInfo( "Assigning field to Track extrapolator" );
+    AliMUONTrackExtrap::SetField();
+
   }
 
-  // set mag field
-  if (!TGeoGlobalMagField::Instance()->GetField()) {
-    printf("Loading field map...\n");
-    AliGRPManager *grpMan = new AliGRPManager();
-    grpMan->ReadGRPEntry();
-    grpMan->SetMagField();
-    delete grpMan;
+  // load geometry if needed
+  if( !AliGeomManager::GetGeometry() )
+  {
+
+    // reset existing geometry/alignment if any
+    if( cdbManager->GetEntryCache()->Contains("GRP/Geometry/Data") )
+    {
+      AliInfo( "Unloading GRP/Geometry/Data" );
+      cdbManager->UnloadFromCache("GRP/Geometry/Data");
+    }
+
+    if( cdbManager->GetEntryCache()->Contains("MUON/Align/Data") )
+    {
+      AliInfo( Form( "Unloading MUON/Align/Data from %s", cdbManager->GetSpecificStorage( "MUON/Align/Data" )->GetBaseFolder().Data() ) );
+      cdbManager->UnloadFromCache("MUON/Align/Data");
+    }
+
+    // get original geometry transformer
+    AliInfo( "Loading geometry" );
+    AliGeomManager::LoadGeometry();
+    if (!AliGeomManager::GetGeometry())
+    {
+      AliError("Failed to load geometry");
+      return;
+    }
+
+    if (!fOldAlignStorage.IsNull())
+    {
+
+      AliInfo( Form( "Initializing MUON/Align/Data using: %s", fOldAlignStorage.Data() ) );
+      cdbManager->SetSpecificStorage("MUON/Align/Data",fOldAlignStorage.Data());
+
+    } else {
+
+      // recover default storage full name (raw:// cannot be used to set specific storage)
+      TString defaultStorage(cdbManager->GetDefaultStorage()->GetType());
+      if (defaultStorage == "alien") defaultStorage += Form("://folder=%s", cdbManager->GetDefaultStorage()->GetBaseFolder().Data());
+      else defaultStorage += Form("://%s", cdbManager->GetDefaultStorage()->GetBaseFolder().Data());
+
+      AliInfo( Form( "Re-initializing MUON/Align/Data using: %s", defaultStorage.Data() ) );
+      cdbManager->SetSpecificStorage("MUON/Align/Data",defaultStorage.Data());
+
+    }
+
+    AliInfo("Loading muon Alignment objects");
+    AliGeomManager::ApplyAlignObjsFromCDB("MUON");
+
+  } else { AliInfo( "Geometry already initialized - fOldAlignStorage ignored" ); }
+
+  // update geometry transformer and pass to Alignment object
+  AliInfo("Loading muon geometry in transformer");
+  fOldGeoTransformer->LoadGeometryData();
+  fAlign->SetGeometryTransformer(fOldGeoTransformer);
+
+  fOCDBLoaded = kTRUE;
+
+}
+
+//_____________________________________________________________________________________
+void AliMUONAlignmentTask::SaveMisAlignmentData( AliMUONGeometryTransformer* transformer ) const
+{
+
+  // clear transformer
+  transformer->ClearMisAlignmentData();
+
+  // load MUON/Align/Data from OCDB
+  AliCDBManager* cdbManager = AliCDBManager::Instance();
+  AliCDBEntry* cdbEntry = cdbManager->Get( "MUON/Align/Data" );
+  if (!cdbEntry)
+  {
+
+    AliError( "unable to load entry for path MUON/Align/Data" );
+    return;
+
+  }
+
+  // get TClonesArray and check
+  TClonesArray* misArray = (TClonesArray*)cdbEntry->GetObject();
+  if( !misArray )
+  {
+
+    AliError( "unable to load old misalignment array" );
+    return;
+
   }
-  // set the magnetic field for track extrapolations
-  AliMUONTrackExtrap::SetField();
-  
+
+  // loop over stored entries
+  for (Int_t index=0; index<misArray->GetEntriesFast(); ++index )
+  {
+
+    // load matrix and check
+    AliAlignObjMatrix* matrix = (AliAlignObjMatrix*) misArray->At( index );
+    if( !matrix )
+    {
+      AliError( Form( "unable to load matrix for index %i", index ) );
+      continue;
+    }
+
+    // get volume ID
+    AliGeomManager::ELayerID layerId;
+    Int_t moduleId;
+    matrix->GetVolUID( layerId, moduleId);
+
+    // make sure ELayerID is correct
+    assert( layerId == AliGeomManager::kMUON );
+
+    // printout
+    // AliInfo( Form( "Found matrix for %s %i", matrix->GetSymName(), moduleId ) );
+
+    // get matrix
+    TGeoHMatrix misMatrix;
+    matrix->GetMatrix(misMatrix);
+
+    // add to geometry transformer
+    // need the detector element
+    // "detElement->GetId()"
+    // see fOldGeoTransformer->GetMisAlignmentData( ... )
+
+    if( TString( matrix->GetSymName() ).Contains( "DE" ) ) transformer->AddMisAlignDetElement( moduleId,  misMatrix);
+    else transformer->AddMisAlignModule( moduleId,  misMatrix);
+  }
+
+  return;
 }
+