Macro to populate CCDB (with comments added to an existing one)

chiarazampolli · sawenzel · commit 011c48968f01 · 2020-01-09T12:44:10.000+01:00
For now we use the dummy workflow as in #2629. Later we will modify the LifeTime and adapt to the common framework. Using CCDB in clusterization (but with bug still) attempt to fix inputspec in TOF clusterizer (calibration) (#16)
diff --git a/DataFormats/Detectors/TOF/include/DataFormatsTOF/CalibTimeSlewingParamTOF.h b/DataFormats/Detectors/TOF/include/DataFormatsTOF/CalibTimeSlewingParamTOF.h
@@ -15,6 +15,7 @@
 #define ALICEO2_CALIBTIMESLEWINGPARAMTOF_H
 
 #include <vector>
+#include "Rtypes.h"
 
 namespace o2
 {
@@ -87,7 +88,7 @@ class CalibTimeSlewingParamTOF
   float mFractionUnderPeak[NSECTORS][NCHANNELXSECTOR]; ///< array with the fraction of entries below the peak
   float mSigmaPeak[NSECTORS][NCHANNELXSECTOR];         ///< array with the sigma of the peak
 
-  //  ClassDefNV(CalibTimeSlewingParamTOF, 2); // class for TOF time slewing params
+  ClassDefNV(CalibTimeSlewingParamTOF, 1); // class for TOF time slewing params
 };
 } // namespace dataformats
 } // namespace o2
diff --git a/Detectors/TOF/CMakeLists.txt b/Detectors/TOF/CMakeLists.txt
@@ -9,9 +9,9 @@
 # submit itself to any jurisdiction.
 
 add_subdirectory(base)
+add_subdirectory(calibration)
 add_subdirectory(simulation)
 add_subdirectory(reconstruction)
-add_subdirectory(calibration)
 if(BUILD_TESTING)
   add_subdirectory(prototyping)
 endif()
diff --git a/Detectors/TOF/base/include/TOFBase/Digit.h b/Detectors/TOF/base/include/TOFBase/Digit.h
@@ -70,6 +70,12 @@ class Digit
   Int_t getElTDCIndex() const { return Geo::getTDCFromECH(mElectronIndex); }     // to be derived from mElectronIndex
   Int_t getElChIndex() const { return Geo::getTDCChFromECH(mElectronIndex); }    // to be derived from mElectronIndex
 
+  void setCalibratedTime(Double_t time) {mCalibratedTime = time;}
+  double getCalibratedTime() const {return mCalibratedTime;}
+  
+  void setIsProblematic(bool flag) {mIsProblematic = flag;}
+  bool isProblematic() const {return mIsProblematic;}
+
  private:
   friend class boost::serialization::access;
 
@@ -80,7 +86,9 @@ class Digit
   Int_t mLabel;            ///< Index of the corresponding entry in the MC label array
   Bool_t mIsUsedInCluster; //!/< flag to declare that the digit was used to build a cluster
   Int_t mElectronIndex;    //!/< index in electronic format
-
+  Double_t mCalibratedTime; //!< time of the digits after calibration (not persistent; it will be filled during clusterization)
+  Bool_t mIsProblematic = false;    //!< flag to tell whether the channel of the digit was problemati; not persistent; default = ok
+  
   ClassDefNV(Digit, 1);
 };
 
diff --git a/Detectors/TOF/base/include/TOFBase/Geo.h b/Detectors/TOF/base/include/TOFBase/Geo.h
@@ -110,11 +110,16 @@ class Geo
 
   static constexpr Float_t DEADTIME = 25E+03;               // Single channel dead time (ps)
   static constexpr Float_t DEADTIMETDC = DEADTIME / TDCBIN; ///< Single channel TDC dead time (ps)
-  static constexpr Float_t MATCHINGWINDOW = TDCBIN * 8192;  // Matching window  (ps) 2^13=8192
   static constexpr int NWINDOW_IN_ORBIT = 3;                //< Number of tof window in 1 orbit
-  static constexpr Float_t READOUTWINDOW = o2::constants::lhc::LHCOrbitNS / NWINDOW_IN_ORBIT; // Readout window (ns)
+  static constexpr Double_t READOUTWINDOW = o2::constants::lhc::LHCOrbitNS / NWINDOW_IN_ORBIT; // Readout window (ns) - time between two consecutive triggers = 1/3 orbit
   static constexpr int BC_IN_WINDOW = BC_IN_ORBIT / NWINDOW_IN_ORBIT;                         // N. bunch crossing in 1 tof window
-  static constexpr Float_t READOUTWINDOW_INV = 1. / READOUTWINDOW; // Readout window (ns)
+  static constexpr Double_t READOUTWINDOW_INV = 1. / READOUTWINDOW; // Readout window (ns)
+
+  static constexpr Int_t LATENCYWINDOW_IN_BC = 1400;  // Latency window  in BC (larger than 1/3 orbit 1188 BC)
+  static constexpr Int_t MATCHINGWINDOW_IN_BC = 1200;  // Latency window  in BC (larger than 1/3 orbit 1188 BC)
+  static constexpr Double_t LATENCYWINDOW = LATENCYWINDOW_IN_BC * o2::constants::lhc::LHCBunchSpacingNS;  // Latency window  in ns
+  static constexpr Double_t MATCHINGWINDOW = MATCHINGWINDOW_IN_BC * o2::constants::lhc::LHCBunchSpacingNS;  // Matching window  in ns
+  static constexpr Double_t WINDOWOVERLAP = MATCHINGWINDOW - READOUTWINDOW; // overlap between two consecutive matchingwindow
 
   static constexpr Float_t ANGLES[NPLATES][NMAXNSTRIP] = { // Strip Tilt Angles
     {43.99, 43.20, 42.40, 41.59, 40.77, 39.94, 39.11, 38.25, 37.40, 36.53,
diff --git a/Detectors/TOF/calibration/include/TOFCalibration/CalibTOFapi.h b/Detectors/TOF/calibration/include/TOFCalibration/CalibTOFapi.h
@@ -35,6 +35,7 @@ using CcdbApi = o2::ccdb::CcdbApi;
 public:
   CalibTOFapi() = default;
   CalibTOFapi(const std::string url);
+  CalibTOFapi(long timestamp, o2::dataformats::CalibLHCphaseTOF* phase, o2::dataformats::CalibTimeSlewingParamTOF* slew) : mTimeStamp(timestamp), mLHCphase(phase), mSlewParam(slew) {}
   ~CalibTOFapi() = default;
   void setTimeStamp(long t) {
     mTimeStamp = t;
diff --git a/Detectors/TOF/calibration/src/CalibTOFapi.cxx b/Detectors/TOF/calibration/src/CalibTOFapi.cxx
@@ -9,6 +9,7 @@
 // or submit itself to any jurisdiction.
 
 #include "TOFCalibration/CalibTOFapi.h"
+#include "FairLogger.h" // for LOG
 
 using namespace o2::tof;
 
@@ -92,7 +93,10 @@ float CalibTOFapi::getTimeCalibration(int ich, float tot) {
   // time calibration to correct measured TOF times
 
   float corr = 0;
-
+  if (!mLHCphase || !mSlewParam) {
+    LOG(WARNING) << "Either LHC phase or slewing object null: mLHCphase = " << mLHCphase << ", mSlewParam = " << mSlewParam;
+    return corr;
+  }
   // LHCphase
   corr += mLHCphase->getLHCphase(int(mTimeStamp/1000)); // timestamp that we use in LHCPhase is in seconds, but for CCDB we need it in ms
   
diff --git a/Detectors/TOF/prototyping/CMakeLists.txt b/Detectors/TOF/prototyping/CMakeLists.txt
@@ -43,3 +43,8 @@ o2_add_test_root_macro(findTOFclusterFromLabel.C
 o2_add_test_root_macro(checkTS.C
                        PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
 		       LABELS tof)
+
+o2_add_test_root_macro(testCCDB.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
+		       			     O2::TOFCalibration
+		       LABELS tof)
diff --git a/Detectors/TOF/prototyping/ConvertRun2CalibrationToO2.C b/Detectors/TOF/prototyping/ConvertRun2CalibrationToO2.C
@@ -11,7 +11,16 @@
 #include "TH1C.h"
 #include "AliTOFGeometry.h"
 
+// macro to be run in *** AliRoot *** to convert the TOF OCDB entries in CCDB entries
+// How to run (see below for futher instructions):
+// gROOT->LoadMacro("CalibTimeSlewingParamTOF.cxx+")
+// .x ConvertRun2CalibrationToO2.C+
+
+
 class MyFineTimeSlewing : public AliTOFCalibFineSlewing
+
+// class needed to access some data members of the AliTOFCalibFineSlewing class that are protected
+
 {
 public:
 
@@ -33,17 +42,34 @@ public:
 
 void ConvertRun2CalibrationToO2() {
 
+  // Remember: Use AliRoot!!
+  
+  // actually you need to call this outside the macro, or it won't work
+
   gROOT->LoadMacro("CalibTimeSlewingParamTOF.cxx+");
 
+  // so you should first:
+  // - copy
+  //      - DataFormats/Detectors/TOF/src/CalibTimeSlewingParamTOF.cxx
+  //   and
+  //      - DataFormats/Detectors/TOF/include/DataFormatsTOF/CalibTimeSlewingParamTOF.h
+  //   in the local working directory, substituting:
+  //      - #include "DataFormatsTOF/CalibTimeSlewingParamTOF.h"
+  //   with
+  //      - #include "CalibTimeSlewingParamTOF.h"
+  // - then call:
+  //      - gROOT->LoadMacro("CalibTimeSlewingParamTOF.cxx+")
+  //   from the prompt
+  
   o2::dataformats::CalibTimeSlewingParamTOF* mTimeSlewingObj = new o2::dataformats::CalibTimeSlewingParamTOF();
  
-  TFile* ffineSlewing = new TFile("OCDB/TOF/Calib/FineSlewing/Run0_999999999_v2_s0.root");
+  TFile* ffineSlewing = new TFile("TOF/Calib/FineSlewing/Run0_999999999_v2_s0.root");
   AliCDBEntry* efineSlewing = (AliCDBEntry*)ffineSlewing->Get("AliCDBEntry");
   AliTOFCalibFineSlewing* fs = (AliTOFCalibFineSlewing*)efineSlewing->GetObject();
-  TFile* foffset  = new TFile("OCDB/TOF/Calib/ParOffline/Run297624_999999999_v4_s0.root");
+  TFile* foffset  = new TFile("TOF/Calib/ParOffline/Run297624_999999999_v4_s0.root");
   AliCDBEntry* eoffset = (AliCDBEntry*)foffset->Get("AliCDBEntry");
   TObjArray* foff = (TObjArray*)eoffset->GetObject();
-  TFile *fproblematic = new TFile("OCDB/TOF/Calib/Problematic/Run296631_999999999_v3_s0.root");
+  TFile *fproblematic = new TFile("TOF/Calib/Problematic/Run296631_999999999_v3_s0.root");
   AliCDBEntry* eproblematic = (AliCDBEntry*)fproblematic->Get("AliCDBEntry");
   TH1C* hProb = (TH1C*)eproblematic->GetObject();
 
diff --git a/Detectors/TOF/prototyping/testCCDB.C b/Detectors/TOF/prototyping/testCCDB.C
@@ -0,0 +1,23 @@
+void testCCDB() {
+
+  // macro to populate CCDB for TOF from a "dummy" LHCphase object, and the timeSlewing (+ offset + fineSlewing + problematic) from Run2 latest OCDB objects 
+
+  o2::dataformats::CalibLHCphaseTOF* mLHCphaseObj = new o2::dataformats::CalibLHCphaseTOF();            ///< LHCPhase to be written in the output
+  mLHCphaseObj->addLHCphase(1567771312, 12); // "random" numbers, in ps
+  mLHCphaseObj->addLHCphase(1567771312+86400, 65); // "random" numbers, in ps
+
+  o2::dataformats::CalibTimeSlewingParamTOF* mTimeSlewingObj = new o2::dataformats::CalibTimeSlewingParamTOF(); ///< Time Slewing object to be written in the output
+  TFile *f = new TFile("TranslateFromRun2/outputCCDBfromOCDB.root");
+  TTree *t = (TTree *) f->Get("tree");
+  t->SetBranchAddress("CalibTimeSlewingParamTOF", &mTimeSlewingObj);  
+  t->GetEvent(0);
+
+  std::map<std::string, std::string> metadataLHCphase; // can be empty
+  o2::tof::CalibTOFapi api("http://ccdb-test.cern.ch:8080"); // or http://localhost:8080 for a local installation
+  api.writeLHCphase(mLHCphaseObj, metadataLHCphase, 1567771312000, 1567771312000+86400000); // 06/09/2019 @ 12:01:52am (UTC), till 10/09/2019 @ 12:01:52am (UTC)
+  
+  std::map<std::string, std::string> metadataChannelCalib; // can be empty
+  api.writeTimeSlewingParam(mTimeSlewingObj, metadataChannelCalib, 1567771312000); // 06/09/2019 @ 12:01am (UTC), contains both offset and time slewing
+
+  return;
+}
diff --git a/Detectors/TOF/reconstruction/CMakeLists.txt b/Detectors/TOF/reconstruction/CMakeLists.txt
@@ -13,7 +13,8 @@ o2_add_library(TOFReconstruction
                        src/ClustererTask.cxx src/Encoder.cxx
                        src/Decoder.cxx
                PUBLIC_LINK_LIBRARIES O2::TOFBase O2::DataFormatsTOF
-                                     O2::SimulationDataFormat)
+                                     O2::SimulationDataFormat
+				     O2::TOFCalibration)
 
 o2_target_root_dictionary(TOFReconstruction
                           HEADERS include/TOFReconstruction/DataReader.h
diff --git a/Detectors/TOF/reconstruction/include/TOFReconstruction/Clusterer.h b/Detectors/TOF/reconstruction/include/TOFReconstruction/Clusterer.h
@@ -20,6 +20,7 @@
 #include "TOFReconstruction/DataReader.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "SimulationDataFormat/MCCompLabel.h"
+#include "TOFCalibration/CalibTOFapi.h"
 
 namespace o2
 {
@@ -32,7 +33,8 @@ class Clusterer
   using Cluster = o2::tof::Cluster;
   using StripData = o2::tof::DataReader::StripData;
   using Digit = o2::tof::Digit;
-
+  using CalibApi = o2::tof::CalibTOFapi;
+  
  public:
   Clusterer() = default;
   ~Clusterer() = default;
@@ -44,7 +46,10 @@ class Clusterer
 
   void setMCTruthContainer(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* truth) { mClsLabels = truth; }
 
+  void setCalibApi(CalibApi* calibApi) {mCalibApi = calibApi; Printf("mCalibApi = %p", mCalibApi);}
+
  private:
+  void calibrateStrip();   
   void processStrip(std::vector<Cluster>& clusters, MCLabelContainer const* digitMCTruth);
   //void fetchMCLabels(const Digit* dig, std::array<Label, Cluster::maxLabels>& labels, int& nfilled) const;
 
@@ -56,6 +61,8 @@ class Clusterer
   int mNumberOfContributingDigits; //! number of digits contributing to the cluster; this will not be stored, it is temporary to build the final cluster
   void addContributingDigit(Digit* dig);
   void buildCluster(Cluster& c, MCLabelContainer const* digitMCTruth);
+  CalibApi* mCalibApi = nullptr; //! calib api to handle the TOF calibration
+  
 };
 
 } // namespace tof
diff --git a/Detectors/TOF/reconstruction/src/Clusterer.cxx b/Detectors/TOF/reconstruction/src/Clusterer.cxx
@@ -34,6 +34,7 @@ void Clusterer::process(DataReader& reader, std::vector<Cluster>& clusters, MCLa
                << mStripData.digits.size();
     totNumDigits += mStripData.digits.size();
 
+    calibrateStrip();
     processStrip(clusters, digitMCTruth);
   }
 
@@ -44,6 +45,20 @@ void Clusterer::process(DataReader& reader, std::vector<Cluster>& clusters, MCLa
   timerProcess.Print();
 }
 
+//__________________________________________________
+void Clusterer::calibrateStrip()
+{
+  // method to calibrate the times from the current strip
+
+  for (int idig = 0; idig < mStripData.digits.size(); idig++) {
+    //    LOG(DEBUG) << "Checking digit " << idig;
+    Digit* dig = &mStripData.digits[idig];
+    double calib = mCalibApi->getTimeCalibration(dig->getChannel(), dig->getTOT());
+    dig->setIsProblematic(mCalibApi->isProblematic(dig->getChannel()));
+    dig->setCalibratedTime(dig->getTDC() * Geo::TDCBIN + mContributingDigit[0]->getBC() * o2::constants::lhc::LHCBunchSpacingNS * 1E3 - calib); //TODO:  to be checked that "-" is correct, and we did not need "+" instead :-)
+  }
+}
+
 //__________________________________________________
 void Clusterer::processStrip(std::vector<Cluster>& clusters, MCLabelContainer const* digitMCTruth)
 {
@@ -58,8 +73,8 @@ void Clusterer::processStrip(std::vector<Cluster>& clusters, MCLabelContainer co
   for (int idig = 0; idig < mStripData.digits.size(); idig++) {
     //    LOG(DEBUG) << "Checking digit " << idig;
     Digit* dig = &mStripData.digits[idig];
-    if (dig->isUsedInCluster())
-      continue; // the digit was already used to build a cluster
+    if (dig->isUsedInCluster() || dig->isProblematic())
+      continue; // the digit was already used to build a cluster, or it was declared problematic
 
     mNumberOfContributingDigits = 0;
     dig->getPhiAndEtaIndex(iphi, ieta);
@@ -72,14 +87,14 @@ void Clusterer::processStrip(std::vector<Cluster>& clusters, MCLabelContainer co
     clusters.emplace_back();
     Cluster& c = clusters[noc];
     addContributingDigit(dig);
-    float timeDig = dig->getTDC() * Geo::TDCBIN;
+    double timeDig = dig->getCalibratedTime();
 
     for (int idigNext = idig + 1; idigNext < mStripData.digits.size(); idigNext++) {
       Digit* digNext = &mStripData.digits[idigNext];
-      if (digNext->isUsedInCluster())
-        continue; // the digit was already used to build a cluster
+      if (digNext->isUsedInCluster() || dig->isProblematic())
+        continue; // the digit was already used to build a cluster, or was problematic
       // check if the TOF time are close enough to be merged; if not, it means that nothing else will contribute to the cluster (since digits are ordered in time)
-      float timeDigNext = digNext->getTDC() * Geo::TDCBIN; // we assume it calibrated (for now); in ps
+      double timeDigNext = digNext->getCalibratedTime(); // in ps
       LOG(DEBUG) << "Time difference = " << timeDigNext - timeDig;
       if (timeDigNext - timeDig > 500 /*in ps*/)
         break;
@@ -112,12 +127,12 @@ void Clusterer::addContributingDigit(Digit* dig)
     int phi, eta;
     for (int i = 0; i < mNumberOfContributingDigits; i++) {
       mContributingDigit[i]->getPhiAndEtaIndex(phi, eta);
-      LOG(ERROR) << "digit already in " << i << ", channel = " << mContributingDigit[i]->getChannel() << ",phi,eta = (" << phi << "," << eta << "), TDC = " << mContributingDigit[i]->getTDC();
+      LOG(ERROR) << "digit already in " << i << ", channel = " << mContributingDigit[i]->getChannel() << ",phi,eta = (" << phi << "," << eta << "), TDC = " << mContributingDigit[i]->getTDC() << ", calibrated time = " << mContributingDigit[i]->getCalibratedTime();
     }
 
     dig->getPhiAndEtaIndex(phi, eta);
     LOG(ERROR) << "skipped digit"
-               << ", channel = " << dig->getChannel() << ",phi,eta = (" << phi << "," << eta << "), TDC = " << dig->getTDC();
+               << ", channel = " << dig->getChannel() << ",phi,eta = (" << phi << "," << eta << "), TDC = " << dig->getTDC() << ", calibrated time = " << dig->getCalibratedTime();
 
     dig->setIsUsedInCluster(); // flag is at used in any case
 
@@ -148,8 +163,8 @@ void Clusterer::buildCluster(Cluster& c, MCLabelContainer const* digitMCTruth)
   }
 
   c.setMainContributingChannel(mContributingDigit[0]->getChannel());
-  c.setTime(mContributingDigit[0]->getTDC() * Geo::TDCBIN + mContributingDigit[0]->getBC() * o2::constants::lhc::LHCBunchSpacingNS * 1E3);
-  c.setTimeRaw(mContributingDigit[0]->getTDC() * Geo::TDCBIN + mContributingDigit[0]->getBC() * o2::constants::lhc::LHCBunchSpacingNS * 1E3);
+  c.setTime(mContributingDigit[0]->getCalibratedTime()); // time in ps (for now we assume it calibrated)
+  c.setTimeRaw(mContributingDigit[0]->getTDC() * Geo::TDCBIN + mContributingDigit[0]->getBC() * o2::constants::lhc::LHCBunchSpacingNS * 1E3);// time in ps (for now we assume it calibrated)
 
   c.setTot(mContributingDigit[0]->getTOT() * Geo::TOTBIN * 1E-3); // TOT in ns (for now we assume it calibrated)
   //setL0L1Latency(); // to be filled (maybe)
diff --git a/Detectors/TOF/simulation/CMakeLists.txt b/Detectors/TOF/simulation/CMakeLists.txt
@@ -12,7 +12,8 @@ o2_add_library(TOFSimulation
                SOURCES src/Detector.cxx src/Digitizer.cxx src/DigitizerTask.cxx
                        src/Strip.cxx
                PUBLIC_LINK_LIBRARIES O2::DetectorsBase O2::TOFBase
-                                     O2::SimulationDataFormat)
+                                     O2::SimulationDataFormat
+				     O2::TOFCalibration)
 
 o2_target_root_dictionary(TOFSimulation
                           HEADERS include/TOFSimulation/Detector.h
diff --git a/Detectors/TOF/simulation/src/Digitizer.cxx b/Detectors/TOF/simulation/src/Digitizer.cxx
@@ -25,6 +25,42 @@ using namespace o2::tof;
 
 ClassImp(Digitizer);
 
+// How data acquisition works in real data
+/*
+           |<----------- 1 orbit ------------->|
+     ------|-----------|-----------|-----------|------
+             ^           ^           ^           ^ when triggers happen
+        |<--- latency ---|
+        |<- matching1->|
+                    |<- matching2->|
+                                |<- matching3->|
+                                |<>| = overlap between two consecutive matching
+
+Norbit = number of orbits elapsed
+Nbunch = bunch in the current orbit (0:3563)
+Ntdc = number of tdc counts within the matching window --> for 1/3 orbit (0:3649535)
+
+raw time = trigger time (Norbit and Nbunch) - latency window + TDC(Ntdc)
+ */
+
+// What we implemented here (so far)
+/*
+           |<----------- 1 orbit ------------->|
+     ------|-----------|-----------|-----------|------
+           |<- matching1->|
+                       |<- matching2->|
+                                   |<- matching3->|
+                                   |<>| = overlap between two consecutive matching windows
+
+- NO OVERLAP between two consecutive windows at the moment (to be implemented)
+- NO LATENCY WINDOW (we manage it during raw encoding/decoding) then digits already corrected
+
+NBC = Number of bunch since timeframe beginning = Norbit*3564 + Nbunch
+Ntdc = here within the current BC -> (0:1023)
+
+digit time = NBC*1024 + Ntdc
+ */
+
 void Digitizer::init()
 {
 
@@ -229,6 +265,8 @@ void Digitizer::addDigit(Int_t channel, UInt_t istrip, Float_t time, Float_t x,
   }
   time += TMath::Sqrt(timewalkX * timewalkX + timewalkZ * timewalkZ) - mTimeDelayCorr - mTimeWalkeSlope * 2;
 
+  // DECALIBRATE HERE
+
   Int_t nbc = Int_t(time * Geo::BC_TIME_INPS_INV); // time elapsed in number of bunch crossing
   //Digit newdigit(time, channel, (time - Geo::BC_TIME_INPS * nbc) * Geo::NTDCBIN_PER_PS, tot * Geo::NTOTBIN_PER_NS, nbc);
 
diff --git a/Detectors/TOF/workflow/src/DigitReaderSpec.cxx b/Detectors/TOF/workflow/src/DigitReaderSpec.cxx
@@ -72,7 +72,9 @@ void DigitReader::run(ProcessingContext& pc)
   }
 
   mState = 2;
-  pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+  //pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+  pc.services().get<ControlService>().endOfStream();
+  
 }
 
 DataProcessorSpec getDigitReaderSpec(bool useMC)
diff --git a/Detectors/TOF/workflow/src/TOFClusterizerSpec.cxx b/Detectors/TOF/workflow/src/TOFClusterizerSpec.cxx
diff --git a/Framework/TestWorkflows/src/tof-dummy-ccdb.cxx b/Framework/TestWorkflows/src/tof-dummy-ccdb.cxx
