X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TOF%2FAliTOFcalib.cxx;h=a619332c901aa304dc29f900bba08fab6093e3e6;hb=281613740638839619c51125a647bd06a2a6281a;hp=37b9dd377252e6fba9c1513c9a40e6c7b2844f1f;hpb=dad2868f2e5e89c929f7ec3ca3e7045ef7230102;p=u%2Fmrichter%2FAliRoot.git

diff --git a/TOF/AliTOFcalib.cxx b/TOF/AliTOFcalib.cxx
index 37b9dd37725..a619332c901 100644
--- a/TOF/AliTOFcalib.cxx
+++ b/TOF/AliTOFcalib.cxx
@@ -84,6 +84,7 @@ author: Chiara Zampolli, zampolli@bo.infn.it
 #include "TF1.h"
 #include "TFile.h"
 #include "TH1F.h"
+#include "TH1C.h"
 #include "TH2F.h"
 //#include "TList.h"
 //#include "TROOT.h"
@@ -117,9 +118,11 @@ author: Chiara Zampolli, zampolli@bo.infn.it
 #include "AliTOFCTPLatency.h"
 #include "AliTOFT0Fill.h"
 #include "AliTOFRunParams.h"
+#include "AliLHCClockPhase.h"
 #include "AliTOFResponseParams.h"
 #include "AliESDEvent.h"
 #include "AliESDtrack.h"
+#include "TRandom.h"
 
 class TROOT;
 class TStyle;
@@ -152,15 +155,21 @@ AliTOFcalib::AliTOFcalib():
   fCTPLatency(NULL),
   fT0Fill(NULL),
   fRunParams(NULL),
+  fLHCClockPhase(NULL),
   fResponseParams(NULL),
   fReadoutEfficiency(NULL),
+  fProblematic(NULL),
   fInitFlag(kFALSE),
   fRemoveMeanT0(kTRUE),
+  fUseLHCClockPhase(kFALSE),
   fCalibrateTOFsignal(kTRUE),
-  fCorrectTExp(kFALSE)
+  fCorrectTExp(kFALSE),
+  fRunParamsSpecificVersion(-1)
 { 
   //TOF Calibration Class ctor
   fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
+
+  gRandom->SetSeed(123456789);
 }
 //____________________________________________________________________________ 
 
@@ -186,12 +195,16 @@ AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib):
   fCTPLatency(NULL),
   fT0Fill(NULL),
   fRunParams(NULL),
+  fLHCClockPhase(NULL),
   fResponseParams(NULL),
   fReadoutEfficiency(NULL),
+  fProblematic(NULL),
   fInitFlag(calib.fInitFlag),
   fRemoveMeanT0(calib.fRemoveMeanT0),
+  fUseLHCClockPhase(calib.fUseLHCClockPhase),
   fCalibrateTOFsignal(calib.fCalibrateTOFsignal),
-  fCorrectTExp(calib.fCorrectTExp)
+  fCorrectTExp(calib.fCorrectTExp),
+  fRunParamsSpecificVersion(calib.fRunParamsSpecificVersion)
 {
 
   fTOFCalOnline = new TObjArray(fNChannels);
@@ -225,6 +238,9 @@ AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib):
   if (calib.fRunParams) fRunParams = new AliTOFRunParams(*calib.fRunParams);
   if (calib.fResponseParams) fResponseParams = new AliTOFResponseParams(*calib.fResponseParams);
   if (calib.fReadoutEfficiency) fReadoutEfficiency = new TH1F(*calib.fReadoutEfficiency);
+  if (calib.fProblematic) fProblematic = new TH1C(*calib.fProblematic);
+
+  gRandom->SetSeed(123456789);
 }
 
 //____________________________________________________________________________ 
@@ -286,10 +302,16 @@ AliTOFcalib& AliTOFcalib::operator=(const AliTOFcalib &calib)
     if (fReadoutEfficiency) *fReadoutEfficiency = *calib.fReadoutEfficiency;
     else fReadoutEfficiency = new TH1F(*calib.fReadoutEfficiency);
   }
+  if (calib.fProblematic) {
+    if (fProblematic) *fProblematic = *calib.fProblematic;
+    else fProblematic = new TH1C(*calib.fProblematic);
+  }
   fInitFlag = calib.fInitFlag;
   fRemoveMeanT0 = calib.fRemoveMeanT0;
+  fUseLHCClockPhase = calib.fUseLHCClockPhase;
   fCalibrateTOFsignal = calib.fCalibrateTOFsignal;
   fCorrectTExp = calib.fCorrectTExp;
+  fRunParamsSpecificVersion = calib.fRunParamsSpecificVersion;
 
   return *this;
 }
@@ -330,6 +352,7 @@ AliTOFcalib::~AliTOFcalib()
     if (fRunParams) delete fRunParams;
     if (fResponseParams) delete fResponseParams;
     if (fReadoutEfficiency) delete fReadoutEfficiency;
+    if (fProblematic) delete fProblematic;
   }
   if (fTree!=0x0) delete fTree;
   if (fChain!=0x0) delete fChain;
@@ -1142,7 +1165,9 @@ Int_t AliTOFcalib::Calibrate(Int_t ichmin, Int_t ichmax, Option_t *optionSave, O
     }
   }
   nusefulbins = FindBins(hToT,&binsProfile[0]);
-  meantime/=ntracksTotal;
+  if (ntracksTotal != 0){
+	  meantime/=ntracksTotal;
+  }
   AliDebug(2, Form("meantime = %f",meantime));
   
   for (Int_t j=1;j<=nusefulbins;j++) {
@@ -2031,6 +2056,25 @@ AliTOFcalib::WriteReadoutEfficiencyOnCDB(const Char_t *sel , Int_t minrun, Int_t
 
 //----------------------------------------------------------------------------
 
+void
+AliTOFcalib::WriteProblematicOnCDB(const Char_t *sel , Int_t minrun, Int_t maxrun)
+{
+  /*
+   * write problematic on CDB 
+   */
+  
+  if (!fProblematic) return;
+  AliCDBId id(Form("%s/Problematic", sel), minrun, maxrun);
+  AliCDBMetaData *md = new AliCDBMetaData();
+  md->SetResponsible("Roberto Preghenella");
+  AliCDBManager *man = AliCDBManager::Instance();
+  man->Put(fProblematic, id, md);
+  AliDebug(2,Form("Problematic written on CDB with run range [%i, %i] ",minrun ,maxrun));
+  delete md;
+}
+
+//----------------------------------------------------------------------------
+
 Bool_t
 AliTOFcalib::ReadDeltaBCOffsetFromCDB(const Char_t *sel , Int_t nrun)
 {
@@ -2108,7 +2152,7 @@ AliTOFcalib::ReadRunParamsFromCDB(const Char_t *sel , Int_t nrun)
    */
   
   AliCDBManager *man = AliCDBManager::Instance();
-  AliCDBEntry *entry = man->Get(Form("%s/RunParams", sel),nrun);
+  AliCDBEntry *entry = man->Get(Form("%s/RunParams", sel),nrun, fRunParamsSpecificVersion);
   if (!entry) { 
     AliFatal("No RunParams entry found in CDB");
     exit(0);  
@@ -2123,6 +2167,29 @@ AliTOFcalib::ReadRunParamsFromCDB(const Char_t *sel , Int_t nrun)
 
 //----------------------------------------------------------------------------
 
+Bool_t
+AliTOFcalib::ReadLHCClockPhaseFromCDB(const Char_t *sel , Int_t nrun)
+{
+  /*
+   * read LHC clock-phase from CDB
+   */
+  
+  AliCDBManager *man = AliCDBManager::Instance();
+  AliCDBEntry *entry = man->Get(Form("%s/LHCClockPhase", sel),nrun);
+  if (!entry) { 
+    AliFatal("No LHCClockPhase entry found in CDB");
+    exit(0);  
+  }
+  fLHCClockPhase =(AliLHCClockPhase *)entry->GetObject();
+  if(!fRunParams){
+    AliFatal("No LHCClockPhase object found in CDB entry");
+    exit(0);  
+  }  
+  return kTRUE; 
+}
+
+//----------------------------------------------------------------------------
+
 Bool_t
 AliTOFcalib::ReadReadoutEfficiencyFromCDB(const Char_t *sel , Int_t nrun)
 {
@@ -2146,6 +2213,29 @@ AliTOFcalib::ReadReadoutEfficiencyFromCDB(const Char_t *sel , Int_t nrun)
 
 //----------------------------------------------------------------------------
 
+Bool_t
+AliTOFcalib::ReadProblematicFromCDB(const Char_t *sel , Int_t nrun)
+{
+  /*
+   * read problematic from CDB
+   */
+  
+  AliCDBManager *man = AliCDBManager::Instance();
+  AliCDBEntry *entry = man->Get(Form("%s/Problematic", sel),nrun);
+  if (!entry) { 
+    AliFatal("No Problematic entry found in CDB");
+    exit(0);  
+  }
+  fProblematic = (TH1C *)entry->GetObject();
+  if(!fProblematic){
+    AliFatal("No Problematic object found in CDB entry");
+    exit(0);  
+  }  
+  return kTRUE; 
+}
+
+//----------------------------------------------------------------------------
+
 Bool_t 
 AliTOFcalib::Init(Int_t run)
 {
@@ -2183,11 +2273,21 @@ AliTOFcalib::Init(Int_t run)
     AliError("cannot get \"RunParams\" object from OCDB");
     return kFALSE;
   }
+  /* get LHC clock-phase obj */
+  if (!ReadLHCClockPhaseFromCDB("GRP/Calib", run)) {
+    AliError("cannot get \"LHCClockPhase\" object from OCDB");
+    return kFALSE;
+  }
   /* get readout efficiency obj */
   if (!ReadReadoutEfficiencyFromCDB("TOF/Calib", run)) {
     AliError("cannot get \"ReadoutEfficiency\" object from OCDB");
     return kFALSE;
   }
+  /* get readout efficiency obj */
+  if (!ReadProblematicFromCDB("TOF/Calib", run)) {
+    AliError("cannot get \"Problematic\" object from OCDB");
+    return kFALSE;
+  }
   /* get response params */
   TFile *responseFile = TFile::Open("$ALICE_ROOT/TOF/data/AliTOFresponsePar.root");
   if (!responseFile || !responseFile->IsOpen()) {
@@ -2201,6 +2301,13 @@ AliTOFcalib::Init(Int_t run)
   }
   responseFile->Close();
 
+  /* check whether to use the clock phase */
+  if (fRunParams->GetUseLHCClockPhase())
+    fUseLHCClockPhase = kTRUE;
+ 
+  if (fUseLHCClockPhase)
+    AliInfo("calibration using BPTX LHC clock-phase");
+
   /* all done */
   fInitFlag = kTRUE;
   return kTRUE;
@@ -2221,15 +2328,21 @@ AliTOFcalib::GetTimeCorrection(Int_t index, Double_t tot, Int_t deltaBC, Int_t l
     return 0.;
   }
 
+  /* deal with L0-L1 orbit crossing (negative values) */
+  if (l0l1 < 0) l0l1 += 3564;
+
   /* get calibration params */
   AliTOFChannelOffline *parOffline = (AliTOFChannelOffline *)fTOFCalOffline->At(index);
   Int_t deltaBCOffset = fDeltaBCOffset->GetDeltaBCOffset();
   Float_t ctpLatency = fCTPLatency->GetCTPLatency();
   Float_t tdcLatencyWindow = fStatus->GetLatencyWindow(index) * 1.e3;
   Float_t timezero = fRunParams->EvalT0(timestamp);
+  Float_t clockphase = fLHCClockPhase->GetPhase(timestamp);
   /* check whether to remove mean T0.
    * useful when one wants to compute mean T0 */
   if (!fRemoveMeanT0) timezero = 0.;
+  /* check whether to use the clock phase */
+  if (fUseLHCClockPhase) timezero -= 1.e3 * clockphase;
 
   /* compute correction */
   Double_t corr = 0.;
@@ -2315,7 +2428,7 @@ AliTOFcalib::CalibrateESD(AliESDEvent *event)
 //----------------------------------------------------------------------------
 
 Bool_t
-AliTOFcalib::IsChannelEnabled(Int_t index, Bool_t checkEfficiency)
+AliTOFcalib::IsChannelEnabled(Int_t index, Bool_t checkEfficiency, Bool_t checkProblematic)
 {
   /*
    * is channel enabled
@@ -2331,6 +2444,7 @@ AliTOFcalib::IsChannelEnabled(Int_t index, Bool_t checkEfficiency)
   if (fStatus->GetNoiseStatus(index) == AliTOFChannelOnlineStatusArray::kTOFNoiseBad) return kFALSE;
   if (fStatus->GetHWStatus(index) == AliTOFChannelOnlineStatusArray::kTOFHWBad) return kFALSE;
   if (checkEfficiency && !IsChannelEfficient(index)) return kFALSE;
+  if (checkProblematic && IsChannelProblematic(index)) return kFALSE;
   
   /* good status */
   return kTRUE;
@@ -2359,6 +2473,26 @@ AliTOFcalib::IsChannelEfficient(Int_t index)
 
 //----------------------------------------------------------------------------
 
+Bool_t
+AliTOFcalib::IsChannelProblematic(Int_t index)
+{
+  /*
+   * is channel problematic
+   */
+
+  if (!fInitFlag) {
+    AliError("class not yet initialized. Initialize it before.");
+    return kTRUE;
+  }
+
+  /* check problematic */
+  if (fProblematic->GetBinContent(index + 1) != 0) return kTRUE;
+  return kFALSE;
+
+}
+
+//----------------------------------------------------------------------------
+
 void
 AliTOFcalib::CalibrateTExp(AliESDEvent *event) const
 {
@@ -2392,3 +2526,50 @@ AliTOFcalib::CalibrateTExp(AliESDEvent *event) const
 
 }
 
+//----------------------------------------------------------------------------
+
+Double_t
+AliTOFcalib::TuneForMC(AliESDEvent *event, Double_t resolution)
+{
+  /*
+   * tune for MC
+   */
+
+  /* get vertex spread and define T0-spread */
+  Double_t diamond2 = TMath::Abs(event->GetSigma2DiamondZ());
+  Double_t t0spread = TMath::Sqrt(diamond2) / 2.99792457999999984e-02;
+  /* generate random startTime */
+  Double_t startTime = gRandom->Gaus(0., t0spread);
+  /* define extra smearing for resolution */
+  Double_t defaultResolution = 80.;
+  Double_t extraSmearing = 0.;
+  if (resolution > defaultResolution)
+    extraSmearing = TMath::Sqrt(resolution * resolution - defaultResolution * defaultResolution);
+
+  /* loop over tracks */
+  AliESDtrack *track = NULL;
+  Double_t time;
+  for (Int_t itrk = 0; itrk < event->GetNumberOfTracks(); itrk++) {
+    /* get track */
+    track = event->GetTrack(itrk);
+    if (!track) continue;
+    /* check TOF match */
+    if (!track->IsOn(AliESDtrack::kTOFout)) continue;
+    /* check if channel is enabled */
+    if (!IsChannelEnabled(track->GetTOFCalChannel())) {
+      /* reset TOF status */
+      track->ResetStatus(AliESDtrack::kTOFin);
+      track->ResetStatus(AliESDtrack::kTOFout);
+      track->ResetStatus(AliESDtrack::kTOFmismatch);
+      track->ResetStatus(AliESDtrack::kTOFpid);
+    }
+    /* get original time and manipulate it */
+    time = track->GetTOFsignal();
+    time += startTime; /* add start time */
+    time += gRandom->Gaus(0., extraSmearing); /* extra smearing */
+    time -= 25.; /* remove 25 ps to center the signal */
+    track->SetTOFsignal(time);
+  }
+
+  return startTime;
+}