X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliRecoParam.cxx;h=2da89054e3feb444308294f05054ba26f55c7d47;hb=adf00ba689f8326e35cafc7041c5a197099400c0;hp=ad5838b2c05a32d5b5209edf3ec499b6ae01deac;hpb=6bcbb25b9dcad225115360010aeff1e6af4ef779;p=u%2Fmrichter%2FAliRoot.git

diff --git a/STEER/AliRecoParam.cxx b/STEER/AliRecoParam.cxx
index ad5838b2c05..2da89054e3f 100644
--- a/STEER/AliRecoParam.cxx
+++ b/STEER/AliRecoParam.cxx
@@ -25,69 +25,388 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include "TClass.h"
 #include "TObjArray.h"
+#include "TMath.h"
+#include "THashTable.h"
 #include "AliDetectorRecoParam.h"
 
 #include "AliLog.h"
 #include "AliRecoParam.h"
-
+#include "AliRunInfo.h"
+#include "AliEventInfo.h"
+#include "AliLog.h"
 
 ClassImp(AliRecoParam)
 
+TString AliRecoParam::fkgEventSpecieName[] = {"Default", "LowMultiplicity", "HighMultiplicity", "Cosmic", "Calib", "Unknown"} ; 
+
 AliRecoParam::AliRecoParam(): 
-  TNamed("",""),
-  fRecoParamArray(0)
+  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(const char *detector): 
-  TNamed(detector,detector),
-  fRecoParamArray(0)
+AliRecoParam::AliRecoParam(const AliRecoParam& par) :
+  TObject(),
+  fEventSpecie(par.fEventSpecie)
 {
-  // Default constructor
-  // ...
+  // 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];
+    }
+  }
+}
+
+//_____________________________________________________________________________
+AliRecoParam& AliRecoParam::operator = (const AliRecoParam& par)
+{
+  // assignment operator
+
+  if(&par == this) return *this;
+
+  this->~AliRecoParam();
+  new(this) AliRecoParam(par);
+  return *this;
 }
 
 AliRecoParam::~AliRecoParam(){
   // Destructor
   // ...
   // Delete the array with the reco-param objects
-  if (fRecoParamArray){
-    fRecoParamArray->Delete();
-    delete fRecoParamArray;
+  for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+    if (fDetRecoParams[iDet]){
+      fDetRecoParams[iDet]->Delete();
+      delete fDetRecoParams[iDet];
+    }
   }
 }
 
+Int_t AliRecoParam::AConvert(EventSpecie_t es)
+{
+  //Converts EventSpecie_t  into int
+  Int_t rv = -1 ; 
+  switch (es) {
+    case kDefault:
+      rv = 0 ; 
+      break;
+    case kLowMult:
+      rv = 1 ; 
+      break;
+    case kHighMult:
+      rv = 2 ; 
+      break;
+    case kCosmic:
+      rv = 3 ; 
+      break;
+    case kCalib:
+      rv = 4 ; 
+      break;
+    default:
+      break;
+  }
+
+  if (rv < 0) 
+    AliFatalClass(Form("Wrong event specie conversion %d", es)) ; 
+
+  return rv ;
+}
+
+AliRecoParam::EventSpecie_t AliRecoParam::Convert(Int_t ies)
+{
+  //Converts int into EventSpecie_t
+  AliRecoParam::EventSpecie_t es = kDefault ; 
+  if ( ies >> 1) 
+    es = kLowMult ; 
+  if ( ies >> 2) 
+    es = kHighMult ;   
+  if ( ies >> 3) 
+    es = kCosmic ;   
+  if ( ies >> 4) 
+    es = kCalib ;
+
+  return es ;   
+}
+
+AliRecoParam::EventSpecie_t AliRecoParam::ConvertIndex(Int_t index)
+{
+  //Converts index of lists into eventspecie
+  EventSpecie_t es = kDefault ; 
+  switch (index) {
+    case 0:
+      es = kDefault ; 
+      break;
+    case 1:
+      es = kLowMult ; 
+      break;
+    case 2:
+      es = kHighMult ;   
+      break;
+    case 3:
+      es = kCosmic ;   
+      break;
+    case 4:
+      es = kCalib ;
+      break;
+    default:
+      break;
+  }
+  return es ;
+}
+
 void  AliRecoParam::Print(Option_t *option) const {
   //
   // Print reconstruction setup
   //
-  printf("AliRecoParam object for %s\n",GetName()); 
-  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::SetEventSpecie(const AliRunInfo *runInfo, const AliEventInfo &evInfo,
+				  const THashTable *cosmicTriggersList)
+{
+  // Implemented according to the discussions
+  // and meetings with physics and trigger coordination
+
+  fEventSpecie = kDefault;
+
+  if (strcmp(runInfo->GetRunType(),"PHYSICS")) {
+    // Not a physics run, the event specie is set to kCalib
+    fEventSpecie = kCalib;
+    return;
   }
+
+  // Special DAQ events considered as calibration events
+  if (evInfo.GetEventType() != 7) {
+    // START_OF_*, END_OF_*, CALIBRATION etc events
+    fEventSpecie = kCalib;
+    return;
+  }
+
+    if ((strcmp(runInfo->GetLHCState(),"STABLE_BEAMS") == 0) &&
+	((strcmp(runInfo->GetBeamType(),"A-A") == 0) ||
+	(strcmp(runInfo->GetBeamType(),"A-") == 0) ||
+	(strcmp(runInfo->GetBeamType(),"-A") == 0))) {
+      // Heavy ion run (any beam that is not pp, the event specie is set to kHighMult
+      fEventSpecie = kHighMult;
+    }
+    else if ((strcmp(runInfo->GetLHCState(),"STABLE_BEAMS") == 0) &&
+	     ((strcmp(runInfo->GetBeamType(),"p-p") == 0) ||
+	      (strcmp(runInfo->GetBeamType(),"p-") == 0) ||
+	      (strcmp(runInfo->GetBeamType(),"-p") == 0) ||
+	      (strcmp(runInfo->GetBeamType(),"P-P") == 0) ||
+	      (strcmp(runInfo->GetBeamType(),"P-") == 0) ||
+	      (strcmp(runInfo->GetBeamType(),"-P") == 0))) {
+      // Proton run, the event specie is set to kLowMult
+      fEventSpecie = kLowMult;
+    }
+    else if (strcmp(runInfo->GetBeamType(),"-") == 0) {
+      // No beams, we assume cosmic data
+      fEventSpecie = kCosmic;
+    }
+
+    // Now we look into the trigger type in order to decide
+    // on the remaining cases (cosmic event within LHC run,
+    // calibration, for example TPC laser, triggers within physics run
+    TString triggerClasses = evInfo.GetTriggerClasses();
+    TObjArray* trClassArray = triggerClasses.Tokenize(" ");
+    Int_t nTrClasses = trClassArray->GetEntriesFast();
+    Bool_t cosmicTrigger = kFALSE,
+      calibTrigger = kFALSE,
+      otherTrigger = kFALSE;
+    for( Int_t i=0; i<nTrClasses; ++i ) {
+      TString trClass = ((TObjString*)trClassArray->At(i))->String();
+
+      if (trClass.BeginsWith("C0L")) {
+	// Calibration triggers always start with C0L
+	calibTrigger = kTRUE;
+	continue;
+      }
+
+      if (cosmicTriggersList) {
+	if (cosmicTriggersList->FindObject(trClass.Data())) {
+	  // Cosmic trigger accorind to the table
+	  // provided in OCDB
+	  cosmicTrigger = kTRUE;
+	  AliDebug(1,Form("Trigger %s identified as cosmic according to the list defined in OCDB.",
+			  trClass.Data()));
+	  continue;
+	}
+      }
+      else {
+	AliDebug(1,"Cosmic trigger list is not provided, cosmic event specie is effectively disabled!");
+      }
+
+      otherTrigger = kTRUE;
+    }
+
+    if (calibTrigger) {
+      fEventSpecie = kCalib;
+      return;
+    }
+    if (cosmicTrigger && !otherTrigger) {
+      fEventSpecie = kCosmic;
+      return;
+    }
+
+    // Here we have to add if we have other cases
+    // and also HLT info if any...
 }
 
-AliDetectorRecoParam *AliRecoParam::GetRecoParam(const AliEventInfo &/*evInfo*/) const {
-  // To be implemented by the detectors
-  // Here we return the last AliDetectorRecoParam!!
-  if (!fRecoParamArray) return NULL;
-  if (fRecoParamArray->GetEntriesFast() != 1)
-    AliWarning(Form("Method not implemented by the detector %s, using the last AliDetectorRecoParam !",GetName()));
+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 if (fDetRecoParamsIndex[0][iDet] >= 0)
+	return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
+      else {
+	AliError(Form("no RecoParam set for detector %d", iDet));
+	return NULL;
+      }
+    }
+  }
+
+  // Default one
+  AliError(Form("Invalid event specie: %d!",fEventSpecie));
+  if (fDetRecoParamsIndex[0][iDet] >= 0)
+    return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
 
-  return (AliDetectorRecoParam *)fRecoParamArray->Last();
+  AliError(Form("no RecoParam set for detector %d", iDet));
+  return NULL;
 }
 
-void  AliRecoParam::AddRecoParam(AliDetectorRecoParam* param){
+void  AliRecoParam::AddDetRecoParam(Int_t iDet, AliDetectorRecoParam* param)
+{
   // Add an instance of reco params object into
-  // the fRecoParamArray
-  //
-  if (!fRecoParamArray) fRecoParamArray = new TObjArray;
-  fRecoParamArray->AddLast(param);
+  // 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;
+}
+
+const char*  AliRecoParam::PrintEventSpecie() const
+{
+  // Print the current
+  // event specie
+  switch (fEventSpecie) {
+  case kDefault:
+    return fkgEventSpecieName[0].Data() ;
+    break;
+  case kLowMult:
+    return fkgEventSpecieName[1].Data() ;
+    break;
+  case kHighMult:
+    return fkgEventSpecieName[2].Data() ;
+    break;
+  case kCosmic:
+    return fkgEventSpecieName[3].Data() ;
+    break;
+  case kCalib:
+    return fkgEventSpecieName[4].Data() ;
+    break;
+  default:
+    return fkgEventSpecieName[5].Data() ;
+    break;
+  }
+}
+
+const char * AliRecoParam::GetEventSpecieName(EventSpecie_t es)
+{
+  switch (es) {
+    case kDefault:
+      return fkgEventSpecieName[0].Data() ;
+      break;
+    case kLowMult:
+      return fkgEventSpecieName[1].Data() ;
+      break;
+    case kHighMult:
+      return fkgEventSpecieName[2].Data() ;
+      break;
+    case kCosmic:
+      return fkgEventSpecieName[3].Data() ;
+      break;
+    case kCalib:
+      return fkgEventSpecieName[4].Data() ;
+      break;
+    default:
+      return fkgEventSpecieName[5].Data() ;
+      break;
+  }
+}
+
+const char * AliRecoParam::GetEventSpecieName(Int_t esIndex)
+{
+  if ( esIndex >= 0 && esIndex < kNSpecies) 
+    return fkgEventSpecieName[esIndex].Data() ;
+  else 
+    return fkgEventSpecieName[kNSpecies].Data() ;
 }