Updating filename

[u/mrichter/AliRoot.git] / STEER / AliRecoParam.cxx

diff --git a/STEER/AliRecoParam.cxx b/STEER/AliRecoParam.cxx
index bbdb5bd738195bc41507f283a25d3de8c03cd26f..898912cab78b44c49dc7c92eec0fe3df105aa649 100644 (file)
--- a/STEER/AliRecoParam.cxx
+++ b/STEER/AliRecoParam.cxx
@@ -16,109 +16,167 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
-// ALICE Reconstruction parameterization:
-// 
-//
-// Retrieving paramaters:
-// 0.  Read the parameters from database
-// 1.  Using the ConfigRecoParam.C script (example : $ALICE_ROOT/macros)
-// 2.  Register additional parametes (AliRecoParam::Instance()->RegisterRecoParam(tpcRecoParam);
-//
-//
-// Using the reconstruction parameters
-//    AliRecoParam::Instance()->GetRecoParam(detType, eventType)                                                                       //  
-//  detType: 
-//  1. Detectors - ITS, TPC, TRD, TOF ...
-//  2. Process   - V0, Kink, ESDcuts
-
+// ALICE Reconstruction parameterization:                                    //
+//                                                                           //
+//                                                                           //
+// Base Class for Detector reconstruction parameters                         //
+// Revision: cvetan.cheshkov@cern.ch 12/06/2008                              //
+// Its structure has been revised and it is interfaced to AliEventInfo.      //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "TObjArray.h"
 #include "AliDetectorRecoParam.h"
 
+#include "AliLog.h"
 #include "AliRecoParam.h"
 
-
 ClassImp(AliRecoParam)
 
+AliRecoParam::AliRecoParam(): 
+  TObject(),
+  fEventSpecie(kDefault)
+{
+  // Default constructor
+  // ...
+  for(Int_t iDet = 0; iDet < kNDetectors; iDet++)
+    fDetRecoParams[iDet] = NULL;
+  for(Int_t iSpecie = 0; iSpecie < kNSpecies; iSpecie++) {
+    for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+      fDetRecoParamsIndex[iSpecie][iDet] = -1;
+    }
+  }
+}
 
-AliRecoParam* AliRecoParam::fgInstance = 0x0;
-
-
-//_____________________________________________________________________________
-AliRecoParam* AliRecoParam::Instance()
+AliRecoParam::AliRecoParam(const AliRecoParam& par) :
+  TObject(),
+  fEventSpecie(par.fEventSpecie)
 {
-  //
-  // returns AliRecoParam instance (singleton)
-  //
-  if (!fgInstance) {
-    fgInstance = new AliRecoParam();
+  // copy constructor
+  for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+    if (par.fDetRecoParams[iDet])
+      fDetRecoParams[iDet] = (TObjArray*)(par.fDetRecoParams[iDet]->Clone());
+    else
+      fDetRecoParams[iDet] = NULL;
+  }
+  for(Int_t iSpecie = 0; iSpecie < kNSpecies; iSpecie++) {
+    for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+      fDetRecoParamsIndex[iSpecie][iDet] = par.fDetRecoParamsIndex[iSpecie][iDet];
+    }
   }
-  
-  return fgInstance;
 }
 
+//_____________________________________________________________________________
+AliRecoParam& AliRecoParam::operator = (const AliRecoParam& par)
+{
+  // assignment operator
 
+  if(&par == this) return *this;
 
-AliRecoParam::AliRecoParam(): 
-  TNamed("ALICE","ALICE"),
-  fRecoParamArray(0)
-{
-  //
-  //
-  //
+  this->~AliRecoParam();
+  new(this) AliRecoParam(par);
+  return *this;
 }
 
 AliRecoParam::~AliRecoParam(){
-  //
-  //
-  //
-  if (fRecoParamArray){
-    fRecoParamArray->Delete();
-    delete fRecoParamArray;
+  // Destructor
+  // ...
+  // Delete the array with the reco-param objects
+  for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+    if (fDetRecoParams[iDet]){
+      fDetRecoParams[iDet]->Delete();
+      delete fDetRecoParams[iDet];
+    }
   }
 }
 
-void  AliRecoParam::Print(Option_t *option) const{
+void  AliRecoParam::Print(Option_t *option) const {
   //
   // Print reconstruction setup
   //
-  printf("AliRecoParam\n"); 
-  if (!fRecoParamArray) return;
-  Int_t nparam = fRecoParamArray->GetEntriesFast();
-  for (Int_t iparam=0; iparam<nparam; iparam++){
-    AliDetectorRecoParam * param = (AliDetectorRecoParam *)fRecoParamArray->At(iparam);
-    if (!param) continue;
-    param->Print(option);
+  for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+    if (fDetRecoParams[iDet]){
+      printf("AliDetectorRecoParam objects for detector %d:\n",iDet); 
+      Int_t nparam = fDetRecoParams[iDet]->GetEntriesFast();
+      for (Int_t iparam=0; iparam<nparam; iparam++){
+       AliDetectorRecoParam * param = (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(iparam);
+       if (!param) continue;
+       param->Print(option);
+      }
+    }
+    else {
+      printf("No AliDetectorRecoParam objects specified for detector %d\n",iDet); 
+    }
   }
 }
 
-void  AliRecoParam::RegisterRecoParam(AliDetectorRecoParam* param){
-  //
-  //
-  //
-  if (!fRecoParamArray) fRecoParamArray = new TObjArray;
-  fRecoParamArray->AddLast(param);
+void AliRecoParam::SetEventSpecie(const AliRunInfo */*runInfo*/, const AliEventInfo &/*evInfo*/)
+{
+  // To be implemented
+  // Here we return always kDefault!!
+  fEventSpecie = kDefault;
 }
 
-TObjArray * AliRecoParam::GetRecoParam(const char * detType, Int_t */*eventType*/){
-  //
-  // Get the list of Reconstruction parameters for given detector
-  // and event type
-  //
-  if (!fRecoParamArray) return 0;
-  TObjArray * array = 0;
-  Int_t nparam = fRecoParamArray->GetEntriesFast();
-  for (Int_t iparam=0;iparam<nparam; iparam++){
-    AliDetectorRecoParam * param = (AliDetectorRecoParam *)fRecoParamArray->At(iparam);
-    if (!param) continue;
-    TString str(param->GetName());
-    if (!str.Contains(detType)) continue;
-    if (!array) array = new TObjArray;
-    array->AddLast(param);    
+const AliDetectorRecoParam *AliRecoParam::GetDetRecoParam(Int_t iDet) const
+{
+  // Return AliDetectorRecoParam object for a given detector
+  // according to the event specie provided as an argument
+  if ( iDet >= kNDetectors) return NULL;
+  if (!fDetRecoParams[iDet]) return NULL;
+  if (fDetRecoParams[iDet]->GetEntries() == 0) return NULL;
+
+  for(Int_t iBit = 0; iBit < kNSpecies; iBit++) {
+    if (fEventSpecie & (1 << iBit)) {
+      if (fDetRecoParamsIndex[iBit][iDet] >= 0)
+       return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[iBit][iDet]);
+      else
+       return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
+    }
   }
-  return array;
+
+  // Default one
+  AliError(Form("Invalid event specie: %d!",fEventSpecie));
+  return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
 }
 
+void  AliRecoParam::AddDetRecoParam(Int_t iDet, AliDetectorRecoParam* param)
+{
+  // Add an instance of reco params object into
+  // the fDetRecoParams for detector iDet
+  // Updates the fDetRecoParams index
+  if (!fDetRecoParams[iDet]) fDetRecoParams[iDet] = new TObjArray;
+  fDetRecoParams[iDet]->AddLast(param);
+  Int_t index = fDetRecoParams[iDet]->GetLast();
+
+  // Index
+  Int_t specie = param->GetEventSpecie();
+  for(Int_t iBit = 0; iBit < kNSpecies; iBit++) {
+    if (specie & (1 << iBit)) {
+      fDetRecoParamsIndex[iBit][iDet] = index;
+    }
+  }
+}
 
+Bool_t AliRecoParam::AddDetRecoParamArray(Int_t iDet, TObjArray* parArray)
+{
+  // Add an array of reconstruction parameter objects
+  // for a given detector
+  // Basic check on the consistency of the array
+  Bool_t defaultFound = kFALSE;
+  for(Int_t i = 0; i < parArray->GetEntriesFast(); i++) {
+    AliDetectorRecoParam *par = (AliDetectorRecoParam*)parArray->At(i);
+    if (!par) continue;
+    if (par->IsDefault()) defaultFound = kTRUE;
+
+    Int_t specie = par->GetEventSpecie();
+    for(Int_t iBit = 0; iBit < kNSpecies; iBit++) {
+      if (specie & (1 << iBit)) {
+       fDetRecoParamsIndex[iBit][iDet] = i;
+      }
+    }
+ }
+   
+  fDetRecoParams[iDet] = parArray;
+
+  return defaultFound;
+}