X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TRD%2FAliTRDcalibDB.cxx;h=c558283dd6c074b7fe3517530cfb863175f7fa8b;hb=64129b355d10efd75096de85219ac3997c7ca660;hp=a284fe6d488046e94a76accae31525c847b68dc0;hpb=3a039a317fad479f77a9bcc96c0170e6122bce67;p=u%2Fmrichter%2FAliRoot.git

diff --git a/TRD/AliTRDcalibDB.cxx b/TRD/AliTRDcalibDB.cxx
index a284fe6d488..c558283dd6c 100644
--- a/TRD/AliTRDcalibDB.cxx
+++ b/TRD/AliTRDcalibDB.cxx
@@ -28,30 +28,27 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <TMath.h>
-#include <TRandom.h>
 #include <TClonesArray.h>
+#include <TObjArray.h>
 
 #include "AliCDBManager.h"
-#include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
 #include "AliLog.h"
 
+#include "AliTRDPIDReference.h"
 #include "AliTRDcalibDB.h"
-#include "AliTRDrecoParam.h"
-#include "AliTRDgeometry.h"
-#include "AliTRDpadPlane.h"
-#include "AliTRDCommonParam.h"
 
 #include "Cal/AliTRDCalROC.h"
 #include "Cal/AliTRDCalPad.h"
 #include "Cal/AliTRDCalDet.h"
-#include "Cal/AliTRDCalFEE.h"
+#include "Cal/AliTRDCalDCS.h"
+#include "Cal/AliTRDCalDCSv2.h"
 #include "Cal/AliTRDCalPID.h"
 #include "Cal/AliTRDCalMonitoring.h"
 #include "Cal/AliTRDCalChamberStatus.h"
 #include "Cal/AliTRDCalPadStatus.h"
 #include "Cal/AliTRDCalSingleChamberStatus.h"
+#include "Cal/AliTRDCalTrkAttach.h"
 
 ClassImp(AliTRDcalibDB)
 
@@ -107,6 +104,7 @@ AliTRDcalibDB::AliTRDcalibDB()
   ,fPRFhi(0)
   ,fPRFwid(0)
   ,fPRFpad(0)
+  ,fPIDResponse(NULL)
 {
   //
   // Default constructor
@@ -136,6 +134,7 @@ AliTRDcalibDB::AliTRDcalibDB(const AliTRDcalibDB &c)
   ,fPRFhi(0)
   ,fPRFwid(0)
   ,fPRFpad(0)
+  ,fPIDResponse(NULL)
 {
   //
   // Copy constructor (not that it make any sense for a singleton...)
@@ -177,6 +176,7 @@ AliTRDcalibDB::~AliTRDcalibDB()
     delete [] fPRFsmp;
     fPRFsmp = 0;
   }
+  if(fPIDResponse) delete fPIDResponse;
 
   Invalidate();
 
@@ -253,15 +253,23 @@ const TObject *AliTRDcalibDB::GetCachedCDBObject(Int_t id)
     case kIDFEE : 
       return CacheCDBEntry(kIDFEE               ,"TRD/Calib/FEE"); 
       break;
+    case kIDDCS :
+      return CacheCDBEntry(kIDDCS               ,"TRD/Calib/DCS");
+      break;
     case kIDPIDNN : 
       return CacheCDBEntry(kIDPIDNN             ,"TRD/Calib/PIDNN");
     case kIDPIDLQ : 
       return CacheCDBEntry(kIDPIDLQ             ,"TRD/Calib/PIDLQ"); 
       break;
+    case kIDPIDLQ1D:
+      return CacheCDBEntry(kIDPIDLQ1D           ,"TRD/Calib/PIDLQ1D");
+      break;
     case kIDRecoParam : 
-      return CacheCDBEntry(kIDRecoParam             ,"TRD/Calib/RecoParam"); 
+      return CacheCDBEntry(kIDRecoParam         ,"TRD/Calib/RecoParam"); 
+      break;
+    case kIDAttach : 
+      return CacheCDBEntry(kIDAttach            ,"TRD/Calib/TrkAttach"); 
       break;
-
   }
 
   return 0;
@@ -291,16 +299,15 @@ const TObject *AliTRDcalibDB::CacheCDBEntry(Int_t id, const char *cdbPath)
   //
   // Caches the entry <id> with cdb path <cdbPath>
   //
-  
+
   if (!fCDBCache[id]) {
     fCDBEntries[id] = GetCDBEntry(cdbPath);
     if (fCDBEntries[id]) {
       fCDBCache[id] = fCDBEntries[id]->GetObject();
     }
-  }
-
+  } 
+  
   return fCDBCache[id];
-
 }
 
 //_____________________________________________________________________________
@@ -597,12 +604,13 @@ Float_t AliTRDcalibDB::GetT0Average(Int_t det)
     return -1;
   }
 
-  Double_t mean = 0.0; 
+  Double_t sum = 0.0; 
   for (Int_t channel = 0; channel < roc->GetNchannels(); ++channel) {
-    mean += (calDet->GetValue(det) + roc->GetValue(channel)) / roc->GetNchannels();
+    sum += roc->GetValue(channel);
   }
-
-  return mean;
+  sum /= roc->GetNchannels();
+  sum += calDet->GetValue(det);
+  return sum;
 
 }
 
@@ -740,20 +748,199 @@ Float_t AliTRDcalibDB::GetPRFWidth(Int_t det, Int_t col, Int_t row)
 }
   
 //_____________________________________________________________________________
-Int_t AliTRDcalibDB::GetNumberOfTimeBins()
+Int_t AliTRDcalibDB::GetNumberOfTimeBinsDCS()
 {
   //
-  // Returns the number of time bins which are read-out.
+  // Returns Number of time bins from the DCS
   //
 
-  const AliTRDCalFEE *calFEE     = dynamic_cast<const AliTRDCalFEE *> 
-                                   (GetCachedCDBObject(kIDFEE));
-  if (!calFEE) {
-    return -1;
+  Int_t nMixed = -2; // not the same number for all chambers
+  Int_t nUndef = -1; // default value - has not been set!
+  Int_t nTbSor = nUndef;
+  Int_t nTbEor = nUndef;
+  Int_t calver = 0; // Check CalDCS version
+
+  const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
+  if (!dcsArr) {
+    AliError("No DCS object found!");
+    return nUndef;
   }
 
-  return calFEE->GetNumberOfTimeBins();
+  if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS"))   calver = 1;
+  if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
+
+  if (calver == 1) {
+    // DCS object
+    const AliTRDCalDCS *calDCSsor = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(0));
+    const AliTRDCalDCS *calDCSeor = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(1));
+    if (!calDCSsor) {
+      // the SOR file is mandatory
+      AliError("NO SOR AliTRDCalDCS object found in CDB file!");
+      return nUndef;
+    }
+    if (!calDCSeor) {
+      // this can happen if the run is shorter than a couple of seconds.
+      AliWarning("NO EOR AliTRDCalDCS object found in CDB file.");
+    }
+
+    // get the numbers
+    nTbSor = calDCSsor->GetGlobalNumberOfTimeBins();
+    if (calDCSeor) nTbEor = calDCSeor->GetGlobalNumberOfTimeBins();
+
+  } else if (calver == 2) {
+    // DCSv2 object
+    const AliTRDCalDCSv2 *calDCSsorv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(0));
+    const AliTRDCalDCSv2 *calDCSeorv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(1));
+    if (!calDCSsorv2) {
+      // the SOR file is mandatory
+      AliError("NO SOR AliTRDCalDCSv2 object found in CDB file!");
+      return nUndef;
+    }
+    if (!calDCSeorv2) {
+      // this can happen if the run is shorter than a couple of seconds.
+      AliWarning("NO EOR AliTRDCalDCSv2 object found in CDB file.");
+    }
+
+    // get the numbers
+    nTbSor = calDCSsorv2->GetGlobalNumberOfTimeBins();
+    if (calDCSeorv2) nTbEor = calDCSeorv2->GetGlobalNumberOfTimeBins();
+
+  } else AliError("NO DCS/DCSv2 OCDB entry found!");
+
+  // if they're the same return the value
+  // -2 means mixed, -1: no data, >= 0: good number of time bins
+  if (nTbSor == nTbEor) return nTbSor;
+
+  // if they're differing:
+  if (nTbSor == nMixed || nTbEor == nMixed) {
+    AliWarning("Inconsistent number of time bins found!");
+    return nMixed;
+  }
+
+  // one is undefined, the other ok -> return that one
+  if (nTbSor == nUndef) return nTbEor;
+  if (nTbEor == nUndef) return nTbSor;
+
+  // only remains: two different numbers >= 0
+  return nMixed;
+}
+
+//_____________________________________________________________________________
+void AliTRDcalibDB::GetFilterType(TString &filterType)
+{
+  //
+  // Returns the filter type
+  //
+
+  const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
+  if(!dcsArr){
+    filterType = "";
+    return;
+  }
+
+  Int_t esor   = 0; // Take SOR
+  Int_t calver = 0; // Check CalDCS version
+  if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS"))   calver = 1;
+  if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
+
+  if (calver == 1) {
+    // DCS object
+    const AliTRDCalDCS *calDCS = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(esor));
+    if(!calDCS){
+      filterType = "";
+      return;
+    } 
+    filterType = calDCS->GetGlobalFilterType();
+  } else if (calver == 2) {
+    // DCSv2 object
+    const AliTRDCalDCSv2 *calDCSv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(esor));
+    if(!calDCSv2){
+      filterType = "";
+      return;
+    } 
+    filterType = calDCSv2->GetGlobalFilterType();
+  } else AliError("NO DCS/DCSv2 OCDB entry found!"); 
+
+}
+
+//_____________________________________________________________________________
+void AliTRDcalibDB::GetGlobalConfiguration(TString &config){
+  //
+  // Get Configuration from the DCS
+  //
+
+  const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
+  if(!dcsArr){
+    config = "";
+    return;
+  }
+
+  Int_t esor   = 0; // Take SOR
+  Int_t calver = 0; // Check CalDCS version
+  if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS"))   calver = 1;
+  if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
+
+  if (calver == 1) {
+    // DCS object
+    const AliTRDCalDCS *calDCS = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(esor));
+    if(!calDCS){
+      config = "";
+      return;
+    } 
+    config = calDCS->GetGlobalConfigName();
+  } else if (calver == 2) {
+    // DCSv2 object
+    const AliTRDCalDCSv2 *calDCSv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(esor));
+    if(!calDCSv2){
+      config = "";
+      return;
+    } 
+    config = calDCSv2->GetGlobalConfigName();
+  } else AliError("NO DCS/DCSv2 OCDB entry found!");
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDcalibDB::HasOnlineFilterPedestal()
+{
+  //
+  // Checks whether pedestal filter was applied online
+  //
+  TString cname;
+  // Temporary: Get the filter config from the configuration name
+  GetGlobalConfiguration(cname);
+  TString filterconfig = cname(cname.First("_") + 1, cname.First("-") - cname.First("_") - 1);
+  // TString filterconfig;
+  //GetFilterType(filterconfig);
+  return filterconfig.Contains("p");
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDcalibDB::HasOnlineFilterGain(){
+  //
+  // Checks whether online gain filter was applied
+  //
+  TString cname;
+  // Temporary: Get the filter config from the configuration name
+  GetGlobalConfiguration(cname);
+  TString filterconfig = cname(cname.First("_") + 1, cname.First("-") - cname.First("_") - 1);
+  //TString filterconfig;
+  //GetFilterType(filterconfig);
+  return filterconfig.Contains("g");
+}
 
+//_____________________________________________________________________________
+Bool_t AliTRDcalibDB::HasOnlineTailCancellation(){
+  //
+  // Checks whether online tail cancellation was applied
+  //
+  TString cname;
+  // Temporary: Get the filter config from the configuration name
+  GetGlobalConfiguration(cname);
+  TString filterconfig = cname(cname.First("_") + 1, cname.First("-") - cname.First("_") - 1);
+  //TString filterconfig;
+  //GetFilterType(filterconfig);
+  return filterconfig.Contains("t");
 }
 
 //_____________________________________________________________________________
@@ -821,14 +1008,19 @@ Char_t AliTRDcalibDB::GetChamberStatus(Int_t det)
 //_____________________________________________________________________________
 AliTRDrecoParam* AliTRDcalibDB::GetRecoParam(Int_t */*eventtype*/)
 {
+  //
+  // Returns the TRD reconstruction parameters from the OCDB
+  //
+
   const TClonesArray *recos = dynamic_cast<const TClonesArray*>(GetCachedCDBObject(kIDRecoParam));
-  if(!recos) return 0x0;
+  if (!recos) return 0x0;
 
   // calculate entry based on event type info
   Int_t n = 0; //f(eventtype[0], eventtype[1], ....)
+
   return (AliTRDrecoParam*)recos->UncheckedAt(n);
-}
 
+}
 
 //_____________________________________________________________________________
 Bool_t AliTRDcalibDB::IsPadMasked(Int_t det, Int_t col, Int_t row)
@@ -887,6 +1079,7 @@ Bool_t AliTRDcalibDB::IsPadNotConnected(Int_t det, Int_t col, Int_t row)
   //
   // Returns status, see name of functions for details ;-)
   //
+
   const AliTRDCalPadStatus         * cal = dynamic_cast<const AliTRDCalPadStatus *> 
                                            (GetCachedCDBObject(kIDPadStatus));
   if (!cal) {
@@ -930,19 +1123,35 @@ Bool_t AliTRDcalibDB::IsChamberMasked(Int_t det)
   return cal->IsMasked(det);
 
 }
+//_____________________________________________________________________________
+Bool_t AliTRDcalibDB::IsHalfChamberMasked(Int_t det, Int_t side){
+  //
+  // Returns status, see name of functions for details ;-)
+  //
+
+  const AliTRDCalChamberStatus     * cal = dynamic_cast<const AliTRDCalChamberStatus *> 
+                                           (GetCachedCDBObject(kIDChamberStatus));
+  if (!cal) {
+    return -1;
+  }
+
+  return side > 0 ? cal->IsHalfChamberSideBMasked(det) : cal->IsHalfChamberSideAMasked(det);
 
+}
 //_____________________________________________________________________________
-const AliTRDCalPID *AliTRDcalibDB::GetPIDObject(AliTRDReconstructor::AliTRDpidMethod method)
+const AliTRDCalPID *AliTRDcalibDB::GetPIDObject(AliTRDpidUtil::ETRDPIDMethod method)
 {
   //
   // Returns the object storing the distributions for PID with likelihood
   //
 
   switch(method) {
-  case AliTRDReconstructor::kLQPID: 
+  case AliTRDpidUtil::kLQ: 
     return dynamic_cast<const AliTRDCalPID *>(GetCachedCDBObject(kIDPIDLQ));
-  case AliTRDReconstructor::kNNPID: 
+  case AliTRDpidUtil::kNN: 
     return dynamic_cast<const AliTRDCalPID *>(GetCachedCDBObject(kIDPIDNN));
+  case AliTRDpidUtil::kESD:
+    return 0x0; // To avoid compiler warnings 
   }
 
   return 0x0;
@@ -950,61 +1159,48 @@ const AliTRDCalPID *AliTRDcalibDB::GetPIDObject(AliTRDReconstructor::AliTRDpidMe
 }
 
 //_____________________________________________________________________________
-const AliTRDCalMonitoring *AliTRDcalibDB::GetMonitoringObject()
+AliTRDPIDResponse *AliTRDcalibDB::GetPIDResponse(AliTRDPIDResponse::ETRDPIDMethod method){
+  if(!fPIDResponse){
+    fPIDResponse = new AliTRDPIDResponse;
+    // Load Reference Histos from OCDB
+    fPIDResponse->SetPIDmethod(method);
+    const TObjArray *references = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDPIDLQ1D));
+    TIter refs(references);
+    TObject *obj = NULL;
+    AliTRDPIDReference *ref = NULL;
+    Bool_t hasReference = kFALSE;
+    while((obj = refs())){
+    	if((ref = dynamic_cast<AliTRDPIDReference *>(obj))){
+        	fPIDResponse->Load(ref);
+        	hasReference = kTRUE;
+        	break;
+    	}
+    }
+    if(!hasReference) AliError("Reference histograms not found in the OCDB");
+  }
+  return fPIDResponse;
+}
+
+//_____________________________________________________________________________
+const AliTRDCalTrkAttach* AliTRDcalibDB::GetAttachObject()
 {
   //
-  // Returns the object storing the monitoring data
+  // Returns the object storing likelihood distributions for cluster to track attachment
   //
-
-  return dynamic_cast<const AliTRDCalMonitoring *> 
-         (GetCachedCDBObject(kIDMonitoringData));
-   
+  return dynamic_cast<const AliTRDCalTrkAttach*>(GetCachedCDBObject(kIDAttach));
 }
 
+
 //_____________________________________________________________________________
-Float_t AliTRDcalibDB::GetOmegaTau(Float_t vdrift, Float_t bz)
+const AliTRDCalMonitoring *AliTRDcalibDB::GetMonitoringObject()
 {
   //
-  // Returns omega*tau (tan(Lorentz-angle)) for a given drift velocity <vdrift> 
-  // and a B-field <bz> for Xe/CO2 (15%).
-  // The values are according to a GARFIELD simulation.
-  //
-  // This function basically does not belong to the calibration class.
-  // It should be moved somewhere else. 
-  // However, currently it is in use by simulation and reconstruction.
+  // Returns the object storing the monitoring data
   //
-  
-  Float_t fieldAbs = TMath::Abs(bz);
-  Float_t fieldSgn = (bz > 0.0) ? 1.0 : -1.0;
-
-  const Int_t kNb = 5;
-  Float_t p0[kNb] = {  0.004810,  0.007412,  0.010252,  0.013409,  0.016888 };
-  Float_t p1[kNb] = {  0.054875,  0.081534,  0.107333,  0.131983,  0.155455 };
-  Float_t p2[kNb] = { -0.008682, -0.012896, -0.016987, -0.020880, -0.024623 };
-  Float_t p3[kNb] = {  0.000155,  0.000238,  0.000330,  0.000428,  0.000541 };
-
-  // No ExB if field is too small (or zero)
-  if (fieldAbs < 0.01) {
-
-    return 0.0;
-
-  }
-  // Calculate ExB from parametrization
-  else {
-
-    Int_t ib = ((Int_t) (10 * (fieldAbs - 0.15)));
-    ib       = TMath::Max(  0,ib);
-    ib       = TMath::Min(kNb,ib);
-
-    Float_t alphaL = p0[ib] 
-                   + p1[ib] * vdrift
-                   + p2[ib] * vdrift*vdrift
-                   + p3[ib] * vdrift*vdrift*vdrift;
-
-    return TMath::Tan(fieldSgn * alphaL);
-
-  }
 
+  return dynamic_cast<const AliTRDCalMonitoring *> 
+         (GetCachedCDBObject(kIDMonitoringData));
+   
 }
 
 //_____________________________________________________________________________
@@ -1166,7 +1362,7 @@ void AliTRDcalibDB::SamplePRF()
 
 //_____________________________________________________________________________
 Int_t AliTRDcalibDB::PadResponse(Double_t signal, Double_t dist
-                                , Int_t layer, Double_t *pad) const
+                               , Int_t layer, Double_t *pad) const
 {
   //
   // Applies the pad response
@@ -1174,7 +1370,7 @@ Int_t AliTRDcalibDB::PadResponse(Double_t signal, Double_t dist
   // something dependent on calibration values
   //
 
-  Int_t iBin  = ((Int_t) ((dist - fPRFlo) / fPRFwid));
+  Int_t iBin  = ((Int_t) ((-dist - fPRFlo) / fPRFwid));
   Int_t iOff  = layer * fPRFbin;
 
   Int_t iBin0 = iBin - fPRFpad + iOff;
@@ -1204,3 +1400,5 @@ Int_t AliTRDcalibDB::PadResponse(Double_t signal, Double_t dist
   }
 
 }
+
+