Implement comparison of sim and rec CDB's, by default for the TPC/RecoParam only
authorshahoian <ruben.shahoyan@cern.ch>
Mon, 10 Mar 2014 15:28:08 +0000 (16:28 +0100)
committershahoian <ruben.shahoyan@cern.ch>
Mon, 10 Mar 2014 15:34:39 +0000 (16:34 +0100)
STEER/STEER/AliReconstruction.cxx
STEER/STEER/AliReconstruction.h

index 3dcfe74..4536877 100644 (file)
@@ -285,6 +285,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
   fCDBUri(),
   fQARefUri(),
   fSpecCDBUri(), 
+  fCheckRecoCDBvsSimuCDB(),
   fInitCDBCalled(kFALSE),
   fCDBSnapshotMode(kFALSE),
   fSetRunNumberFromDataCalled(kFALSE),
@@ -345,7 +346,9 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
     fQAWriteExpert[iDet] = kFALSE ; 
   }
   fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
-
+  //
+  AddCheckRecoCDBvsSimuCDB("TPC/Calib/RecoParam"); // check for similarity in the sim and rec
+  //
   AliPID pid;
 }
 
@@ -419,6 +422,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   fCDBUri(rec.fCDBUri),
   fQARefUri(rec.fQARefUri),
   fSpecCDBUri(), 
+  fCheckRecoCDBvsSimuCDB(),
   fInitCDBCalled(rec.fInitCDBCalled),
   fCDBSnapshotMode(rec.fCDBSnapshotMode),
   fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
@@ -486,6 +490,10 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
     if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
   }
 
+  for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
+    if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
+  }
+
   for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
 
 }
@@ -601,6 +609,12 @@ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
   fCDBUri        = "";
   fQARefUri      = rec.fQARefUri;
   fSpecCDBUri.Delete();
+  fCheckRecoCDBvsSimuCDB.Delete();
+  //
+  for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
+    if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
+  }
+  //
   fInitCDBCalled               = rec.fInitCDBCalled;
   fCDBSnapshotMode             = rec.fCDBSnapshotMode;
   fSetRunNumberFromDataCalled  = rec.fSetRunNumberFromDataCalled;
@@ -666,7 +680,7 @@ AliReconstruction::~AliReconstruction()
     delete fAlignObjArray;
   }
   fSpecCDBUri.Delete();
-
+  fCheckRecoCDBvsSimuCDB.Delete();
   AliCodeTimer::Instance()->Print();
 }
 
@@ -829,6 +843,7 @@ void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
   AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
   
 }
+
 //_____________________________________________________________________________
 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
 // Store a detector-specific CDB storage location
@@ -872,6 +887,48 @@ void AliReconstruction::SetSpecificStorage(const char* calibType, const char* ur
 }
 
 //_____________________________________________________________________________
+void AliReconstruction::AddCheckRecoCDBvsSimuCDB(const char* cdbpath,const char* comment) 
+{
+  // require the cdb item to be the same in the rec as in the sim
+  // Activate it later within the Run() method
+  TString newent = cdbpath;
+  if (newent.IsNull()) return;
+  TIter nextit(&fCheckRecoCDBvsSimuCDB);
+  TNamed* cdbent=0;
+  while ((cdbent=(TNamed*)nextit())) {
+    TString str = cdbent->GetName();
+    if (str==newent) {
+      AliInfo(Form("%s is already in the list to check",cdbpath));
+      return;
+    }
+  }
+  fCheckRecoCDBvsSimuCDB.AddLast(new TNamed(cdbpath,comment));
+  //
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::RemCheckRecoCDBvsSimuCDB(const char* cdbpath) 
+{
+  // require the cdb item to be the same in the rec as in the sim
+  // Activate it later within the Run() method
+  TString newent = cdbpath;
+  if (newent.IsNull()) return;
+  TIter nextit(&fCheckRecoCDBvsSimuCDB);
+  TNamed* cdbent=0;
+  while ((cdbent=(TNamed*)nextit())) {
+    TString str = cdbent->GetName();
+    if (str==newent) {
+      AliInfo(Form("Removing %s from the list to check",cdbpath));
+      delete fCheckRecoCDBvsSimuCDB.Remove(cdbent);
+      fCheckRecoCDBvsSimuCDB.Compress();
+      return;
+    }
+  }
+  AliInfo(Form("%s is not in the list to check",cdbpath));
+  //
+}
+
+//_____________________________________________________________________________
 Bool_t AliReconstruction::SetRunNumberFromData()
 {
   // The method is called in Run() in order
@@ -1750,6 +1807,8 @@ void AliReconstruction::SlaveBegin(TTree*)
   }
   AliSysInfo::AddStamp("LoadLoader");
  
+  CheckRecoCDBvsSimuCDB();
+
   ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
 
   // get trackers
@@ -4586,3 +4645,147 @@ Bool_t AliReconstruction::HasNextEventAfter(Int_t eventId)
         return ( (eventId < fRunLoader->GetNumberOfEvents()) ||
           (fRawReader && fRawReader->NextEvent()) );
 }
+
+//_________________________________________________________________
+void AliReconstruction::CheckRecoCDBvsSimuCDB()
+{
+  // if some CDB entries must be the same in the simulation
+  // and reconstruction, check here
+  int nent = fCheckRecoCDBvsSimuCDB.GetEntriesFast();
+  AliInfo(Form("Check %d entries for matching between sim and rec",nent));
+  //
+  // get simulation CDB
+  fRunLoader->CdGAFile();
+  TMap*  cdbMapSim  = (TMap*)gDirectory->Get("cdbMap");
+  TList* cdbListSim = (TList*)gDirectory->Get("cdbList");
+  if (!(cdbMapSim && cdbListSim)) {
+    AliInfo(Form("No CDBMap/List found in %s, nothing to check",fGAliceFileName.Data()));
+    return;
+  }
+  // read the requested objects to make sure they will appear in the reco list
+  for (Int_t i=0;i<nent;i++) {
+    TNamed* cdbent = (TNamed*) fCheckRecoCDBvsSimuCDB[i];
+    if (!cdbent) continue;
+    AliCDBManager::Instance()->Get(cdbent->GetName());
+  }
+  // get default path for simulation
+  TPair* pair;
+  TObjString* stro;
+  pair = (TPair*)cdbMapSim->FindObject("default");
+  if (!pair) {AliFatal("Did not find default storage used for simulations"); return;}
+  TString defSimStore = ((TObjString*)pair->Value())->GetString();
+  RectifyCDBurl(defSimStore);
+  //
+  // get reconstruction CDB
+  const TMap *cdbMapRec = AliCDBManager::Instance()->GetStorageMap();   
+  const TList *cdbListRec = AliCDBManager::Instance()->GetRetrievedIds();       
+  //
+  // get default path for reconstruction
+  pair = (TPair*)cdbMapRec->FindObject("default");
+  if (!pair) {AliFatal("Did not find default storage used for reconstruction"); return;}
+  TString defRecStore = ((TObjString*)pair->Value())->GetString();
+  RectifyCDBurl(defRecStore);
+  //
+  for (Int_t i=0;i<nent;i++) {
+    TNamed* cdbent = (TNamed*) fCheckRecoCDBvsSimuCDB[i];
+    if (!cdbent) continue;
+    //
+    AliInfo(Form("#%d Checking %s",i,cdbent->GetName()));
+    //
+    // check in the simuCDB special params
+    pair = (TPair*)cdbMapSim->FindObject(cdbent->GetName());
+    TString idSimD = "";
+    TString idSimS = "";
+    if (pair) { // specific path is used
+      idSimS = ((TObjString*)pair->Value())->GetString();
+      RectifyCDBurl(idSimS);
+    }
+    else { // check in default storage list
+      TIter nextSim(cdbListSim);
+      while ((stro=(TObjString*)nextSim())) {
+       if (stro->GetString().Contains(cdbent->GetName())) {
+         idSimD = stro->GetString();
+         break;
+       }
+      }
+    }
+    //
+    // check in the recoCDB special params
+    pair = (TPair*)cdbMapRec->FindObject(cdbent->GetName());
+    TString idRecD = "";
+    TString idRecS = "";
+    if (pair) {  // specific path is used
+      idRecS = ((TObjString*)pair->Value())->GetString();
+      RectifyCDBurl(idRecS);
+    }
+    else { // check in default storage list
+      TIter nextRec(cdbListRec);
+      while ((stro=(TObjString*)nextRec())) {
+       if (stro->GetString().Contains(cdbent->GetName())) {
+         idRecD = stro->GetString();
+         break;
+       }
+      }
+    }
+    //-----------------------------
+    Bool_t ok = kTRUE;
+    if (!idSimD.IsNull()) {  // simulation used object from default storage
+      AliInfo(Form("Simulation used default storage %s\nentry %s",defSimStore.Data(),idSimD.Data()));
+      if (!idRecD.IsNull()) { // reco also
+       AliInfo(Form("Reconstruction used default storage %s\nentry %s",defRecStore.Data(),idRecD.Data()));
+       if ( (idSimD!=idRecD) || (defSimStore!=defRecStore) ) ok = kFALSE;
+      }
+      else if (!idRecS.IsNull()) { // reco used specific storage, strict check of version is not possible
+       AliInfo(Form("Reconstruction used specific storage %s",idRecS.Data()));
+       if (defSimStore!=idRecS) ok = kFALSE;
+      }
+      else {
+       AliInfo("Did not find object used in reconstruction");
+       ok = kFALSE;
+      }
+    }
+    else if (!idSimS.IsNull()) { // simulation used object from specific storage
+      AliInfo(Form("Simulation used specific storage %s",idSimS.Data()));
+      if (!idRecS.IsNull()) { // reco also     
+       AliInfo(Form("Reconstruction used specific storage %s",idRecS.Data()));
+       if (idSimS!=idRecS) ok = kFALSE;
+      }
+      else if (!idRecD.IsNull()) {
+       AliInfo(Form("Reconstruction used default storage %s\nentry",idRecD.Data()));
+       if (idSimS!=defRecStore) ok = kFALSE;
+      }
+      else {
+       AliInfo("Did not find object used in reconstruction");
+       ok = kFALSE;
+      }      
+    }
+    else {
+      AliInfo("Did not find object used in simulation");
+      ok = kFALSE;      
+    }
+    if (!ok) AliFatal("Different objects were used in sim and rec");
+  }
+  //
+}
+
+//_________________________________________________________
+void AliReconstruction::RectifyCDBurl(TString& url)
+{
+  // TBD RS
+  // remove everything but the url
+  TString sbs;
+  if (!(sbs=url("\\?User=[^?]*")).IsNull())                url.ReplaceAll(sbs,"");
+  if (!(sbs=url("\\?DBFolder=[^?]*")).IsNull())            url.ReplaceAll("?DB","");
+  if (!(sbs=url("\\?SE=[^?]*")).IsNull())                  url.ReplaceAll(sbs,"");
+  if (!(sbs=url("\\?CacheFolder=[^?]*")).IsNull())         url.ReplaceAll(sbs,"");
+  if (!(sbs=url("\\?OperateDisconnected=[^?]*")).IsNull()) url.ReplaceAll(sbs,"");
+  if (!(sbs=url("\\?CacheSize=[^?]*")).IsNull())           url.ReplaceAll(sbs,"");  
+  if (!(sbs=url("\\?CleanupInterval=[^?]*")).IsNull())     url.ReplaceAll(sbs,"");  
+  Bool_t slash=kFALSE,space=kFALSE;
+  while ( (slash=url.EndsWith("/")) || (space=url.EndsWith(" ")) ) {
+    if (slash) url = url.Strip(TString::kTrailing,'/');
+    if (space) url = url.Strip(TString::kTrailing,' ');
+  }
+  //url.ToLower();
+  //
+}
index 35548b3..a037f3a 100644 (file)
@@ -127,7 +127,12 @@ public:
   void SetDefaultStorage(const char* uri);
   void SetSpecificStorage(const char* calibType, const char* uri);
   void SetCDBSnapshotMode(const char* snapshotFileName);
-
+  void AddCheckRecoCDBvsSimuCDB(const char* cdbpath,const char* comment="");
+  void RemCheckRecoCDBvsSimuCDB(const char* cdbpath);
+  void ResetCheckRecoCDBvsSimuCDB() {fCheckRecoCDBvsSimuCDB.Delete();}
+  void RectifyCDBurl(TString& url);
+  const TObjArray* GetCheckRecoCDBvsSimuCDB() const {return &fCheckRecoCDBvsSimuCDB;}
+  void CheckRecoCDBvsSimuCDB();
   Bool_t MisalignGeometry(const TString& detectors);
 
   void           SetAlignObjArray(TObjArray *array)
@@ -341,6 +346,7 @@ private:
   TString       fCDBUri;             //! Uri of the default CDB storage
   TString       fQARefUri;         //! Uri of the default QA reference storage
   TObjArray      fSpecCDBUri;         //! Array with detector specific CDB storages
+  TObjArray      fCheckRecoCDBvsSimuCDB; // Array for CDB items which must be the same in the sim and rec
   Bool_t        fInitCDBCalled;               //! flag to check if CDB storages are already initialized
   Bool_t         fCDBSnapshotMode;             //! flag true if we are setting the CDB Manager in snapshot mode
   Bool_t        fSetRunNumberFromDataCalled;  //! flag to check if run number is already loaded from run loader
@@ -406,7 +412,7 @@ private:
   Int_t                fMaxVMEM;        //  max VMEM memory, MB
   static const char*   fgkStopEvFName;  //  filename for stop.event stamp
   //
-  ClassDef(AliReconstruction, 48)      // class for running the reconstruction
+  ClassDef(AliReconstruction, 49)      // class for running the reconstruction
 };
 
 #endif