Implementation of CalibTOFapi and first use of it in calibration.

Author: chiarazampolli

DataFormats/Detectors/TOF/include/DataFormatsTOF/CalibTimeSlewingParamTOF.h

@@ -52,6 +52,12 @@ class CalibTimeSlewingParamTOF
   void setFractionUnderPeak(int sector, int channel, float value) { mFractionUnderPeak[sector][channel] = value; }
   void setSigmaPeak(int sector, int channel, float value) { mSigmaPeak[sector][channel] = value; }
 
+  bool isProblematic(int channel) {
+    int sector = channel/NCHANNELXSECTOR;
+    int channelInSector = channel%NCHANNELXSECTOR;
+    return (getFractionUnderPeak(sector, channelInSector) < 0);
+  }
+
   CalibTimeSlewingParamTOF& operator+=(const CalibTimeSlewingParamTOF& other);
 
  private:

Detectors/GlobalTracking/CMakeLists.txt

@@ -20,7 +20,8 @@ o2_add_library(GlobalTracking
                                      O2::GPUTracking
                                      O2::TPCBase
                                      O2::TPCReconstruction
-                                     O2::TOFBase)
+                                     O2::TOFBase
+				     O2::TOFCalibration)
 
 o2_target_root_dictionary(GlobalTracking
                           HEADERS include/GlobalTracking/MatchTPCITS.h

Detectors/GlobalTracking/include/GlobalTracking/CalibTOF.h

@@ -30,7 +30,7 @@
 #include "TF1.h"
 #include "TFile.h"
 #include "TGraphErrors.h"
-#include "CCDB/CcdbApi.h"
+#include "TOFCalibration/CalibTOFapi.h"
 
 class TTree;
 
@@ -42,6 +42,7 @@ namespace globaltracking
 class CalibTOF
 {
   using Geo = o2::tof::Geo;
+  using CalibTOFapi = o2::tof::CalibTOFapi;
 
  public:
   static constexpr int NSTRIPSPERSTEP = 13; // we chose this number because we process per sector, and
@@ -165,6 +166,8 @@ class CalibTOF
   int mMaxTimestamp = 1; ///< maximum timestamp over the hits that we collect; we need it to
                          ///< book the histogram for the LHCPhase calibration
 
+  CalibTOFapi mCalibTOFapi; ///< API to handle TOF calibration objects
+
   //  ClassDefNV(CalibTOF, 1);
 };
 } // namespace globaltracking

Detectors/GlobalTracking/src/CalibTOF.cxx

@@ -16,7 +16,6 @@
 #include <TFile.h>
 #include "DataFormatsParameters/GRPObject.h"
 #include "ReconstructionDataFormats/PID.h"
-#include "CCDB/CcdbApi.h"
 
 #include "GlobalTracking/CalibTOF.h"
 
@@ -26,7 +25,6 @@
 #include "TRandom.h"
 
 using namespace o2::globaltracking;
-using CcdbApi = o2::ccdb::CcdbApi;
 
 ClassImp(CalibTOF);
 
@@ -114,6 +112,9 @@ void CalibTOF::init()
     mMaxTimestamp = mMinTimestamp + nbinsLHCphase * 300; // we want that the last bin of the histogram is also large 300s; this we need to do only when we have less than 1000 bins, because in this case we will integrate over intervals that are larger than 300s anyway
   mHistoLHCphase = new TH2F("hLHCphase", ";clock offset (ps); timestamp (s)", 1000, -24400, 24400, nbinsLHCphase, mMinTimestamp, mMaxTimestamp);
 
+  // setting CCDB for output
+  mCalibTOFapi.setURL(mCCDBpath.c_str());
+
   mInitDone = true;
 
   print();
@@ -266,16 +267,13 @@ void CalibTOF::fillOutput(int flag)
   mOutputTree->Fill();
 
   if (mFillCCDB) {
-    CcdbApi api;
-    api.init(mCCDBpath.c_str()); // or http://localhost:8080 for a local installation
-    
     if (flag & kLHCphase) {
       std::map<std::string, std::string> metadataLHCphase; // can be empty
-      api.storeAsTFileAny(mLHCphaseObj, "TOF/LHCphase", metadataLHCphase, (ulong)mMinTimestamp*1000, (ulong)mMaxTimestamp*1000); // we use as validity the timestamps that we got from the input for the calibration; but we need to convert to ms for the CCDB (at least for now that we use an integer for the timestamp)
+      mCalibTOFapi.writeLHCphase(mLHCphaseObj, metadataLHCphase, (ulong)mMinTimestamp*1000, (ulong)mMaxTimestamp*1000); // we use as validity the timestamps that we got from the input for the calibration; but we need to convert to ms for the CCDB (at least for now that we use an integer for the timestamp)
     }
     if (flag & kChannelOffset || flag & kChannelTimeSlewing) {
       std::map<std::string, std::string> metadataChannelCalib; // can be empty
-      api.storeAsTFileAny(mTimeSlewingObj, "TOF/ChannelCalib", metadataChannelCalib, (ulong)mMinTimestamp*1000); // contains both offset and time slewing; we use as validity the START ONLY timestamp that we got from the input for the calibration; but we need to convert to ms for the CCDB (at least for now that we use an integer for the timestamp), END is default
+      mCalibTOFapi.writeTimeSlewingParam(mTimeSlewingObj, metadataChannelCalib, (ulong)mMinTimestamp*1000); // contains both offset and time slewing; we use as validity the START ONLY timestamp that we got from the input for the calibration; but we need to convert to ms for the CCDB (at least for now that we use an integer for the timestamp), END is default
     }
   }
 }

Detectors/TOF/CMakeLists.txt

@@ -11,6 +11,7 @@
 add_subdirectory(base)
 add_subdirectory(simulation)
 add_subdirectory(reconstruction)
+add_subdirectory(calibration)
 if(BUILD_TESTING)
   add_subdirectory(prototyping)
 endif()

Detectors/TOF/calibration/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright CERN and copyright holders of ALICE O2. This software is distributed
+# under the terms of the GNU General Public License v3 (GPL Version 3), copied
+# verbatim in the file "COPYING".
+#
+# See http://alice-o2.web.cern.ch/license for full licensing information.
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization or
+# submit itself to any jurisdiction.
+
+o2_add_library(TOFCalibration
+               SOURCES src/CalibTOFapi.cxx
+               PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF 
+                                     O2::CCDB)
+
+o2_target_root_dictionary(TOFCalibration
+                          HEADERS include/TOFCalibration/CalibTOFapi.h)

Detectors/TOF/calibration/include/TOFCalibration/CalibTOFapi.h

@@ -0,0 +1,64 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CalibTOFapi.h
+/// \brief Class to use TOF calibration (decalibration, calibration)
+/// \author Francesco.Noferini@cern.ch, Chiara.Zampolli@cern.ch
+
+#ifndef ALICEO2_TOF_CALIBTOFAPI_H_
+#define ALICEO2_TOF_CALIBTOFAPI_H_
+
+#include <iostream>
+#include "CCDB/BasicCCDBManager.h"
+#include "DataFormatsTOF/CalibLHCphaseTOF.h"
+#include "DataFormatsTOF/CalibTimeSlewingParamTOF.h"
+
+namespace o2
+{
+  namespace tof {
+
+class CalibTOFapi
+{
+
+using lhcPhase = o2::dataformats::CalibLHCphaseTOF;
+using slewParam = o2::dataformats::CalibTimeSlewingParamTOF;
+using ccdbManager = o2::ccdb::BasicCCDBManager;
+using CcdbApi = o2::ccdb::CcdbApi;
+
+public:
+  CalibTOFapi() = default;
+  CalibTOFapi(const std::string url);
+  ~CalibTOFapi() = default;
+  void setTimeStamp(long t) {
+    mTimeStamp = t;
+  }
+  void setURL(const std::string url) {
+    auto& mgr = ccdbManager::instance();
+    mgr.setURL(url);
+  }
+  void readLHCphase();
+  void readTimeSlewingParam();
+  void writeLHCphase(lhcPhase* phase, std::map<std::string, std::string> metadataLHCphase, ulong minTimeSTamp, ulong maxTimeStamp);
+  void writeTimeSlewingParam(slewParam* param, std::map<std::string, std::string> metadataChannelCalib, ulong minTimeSTamp, ulong maxTimeStamp = 0);
+  float getTimeCalibration(int ich, float tot);
+  float getTimeDecalibration(int ich, float tot);
+  bool isProblematic(int ich);
+    
+ private:
+
+  long mTimeStamp;        ///< timeStamp for queries
+  lhcPhase* mLHCphase = nullptr;    ///< object for LHC phase
+  slewParam* mSlewParam = nullptr;  ///< object for timeslewing (containing info also for offset and problematic)
+  
+  ClassDefNV(CalibTOFapi, 1);
+};
+} // namespace tof
+} // namespace o2
+#endif

Detectors/TOF/calibration/include/TOFcalibration/CalibTOFapi.h

@@ -11,17 +11,105 @@
 #include "TOFCalibration/CalibTOFapi.h"
 
 using namespace o2::tof;
-using ccdbManager = o2::ccdb::BasicCCDBManager;
 
-ClassImp(CalibTOFapi);
+ClassImp(o2::tof::CalibTOFapi);
 
-CalibTOFapi(const std::string db) {
+CalibTOFapi::CalibTOFapi(const std::string url) {
+
+  // setting the URL to the CCDB manager
+  
+  setURL(url);
+
+}
+
+
+//______________________________________________________________________
+
+void CalibTOFapi::readLHCphase() {
+
+  // getting the LHCphase calibration
+
+  auto& mgr = ccdbManager::instance();
+  mLHCphase = mgr.getForTimeStamp<lhcPhase>("TOF/LHCphase", mTimeStamp);
+  
+}
+
+//______________________________________________________________________
+
+void CalibTOFapi::readTimeSlewingParam() {
+
+  // getting the TimeSlewing calibration
+  // it includes also offset and information on problematic
 
-  mCCDB = db;
   auto& mgr = ccdbManager::instance();
-  mgr.setURL(db);
+  mSlewParam = mgr.getForTimeStamp<slewParam>("TOF/ChannelCalib", mTimeStamp);
+  
+}
+
+//______________________________________________________________________
 
+void CalibTOFapi::writeLHCphase(lhcPhase* phase, std::map<std::string, std::string> metadataLHCphase, ulong minTimeStamp, ulong maxTimeStamp) {
+
+  // write LHCphase object to CCDB
+
+  auto& mgr = ccdbManager::instance();
+  CcdbApi api;
+  api.init(mgr.getURL());
+  api.storeAsTFileAny(phase, "TOF/LHCphase", metadataLHCphase, minTimeStamp, maxTimeStamp); 
+  
 }
 
 //______________________________________________________________________
 
+void CalibTOFapi::writeTimeSlewingParam(slewParam* param, std::map<std::string, std::string> metadataChannelCalib, ulong minTimeStamp, ulong maxTimeStamp) {
+
+  // write TiemSlewing object to CCDB (it includes offset + problematic)
+
+  auto& mgr = ccdbManager::instance();
+  CcdbApi api;
+  api.init(mgr.getURL());
+  if (maxTimeStamp == 0) {
+    api.storeAsTFileAny(param, "TOF/ChannelCalib", metadataChannelCalib, minTimeStamp);
+  }
+  else api.storeAsTFileAny(param, "TOF/ChannelCalib", metadataChannelCalib, minTimeStamp, maxTimeStamp);
+
+}
+
+//______________________________________________________________________
+
+bool CalibTOFapi::isProblematic(int ich) {
+
+  // method to know if the channel was problematic or not
+
+  return mSlewParam->isProblematic(ich);
+
+}
+  
+//______________________________________________________________________
+
+float CalibTOFapi::getTimeCalibration(int ich, float tot) {
+
+  // time calibration to correct measured TOF times
+
+  float corr = 0;
+
+  // LHCphase
+  corr += mLHCphase->getLHCphase(int(mTimeStamp/1000)); // timestamp that we use in LHCPhase is in seconds, but for CCDB we need it in ms
+  
+  // time slewing + channel offset
+  corr += mSlewParam->evalTimeSlewing(ich, tot);
+
+  return corr;
+  
+}
+
+//______________________________________________________________________
+
+float CalibTOFapi::getTimeDecalibration(int ich, float tot) {
+
+  // time decalibration for simulation (it is just the opposite of the calibration)
+
+  return -getTimeCalibration(ich, tot); 
+  
+}
+

Detectors/TOF/calibration/src/CalibTOFapi.cxx

@@ -0,0 +1,19 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::tof::CalibTOFapi + ;
+
+#endif