Add first working prototype of QC on TOF digits (#394)

njacazio · web-flow · commit 7f3bfdc5c34d · 2020-05-25T09:00:04.000+02:00
* Add check on TOF digits

* Add variables for cuts, add msg, improve style

* Use info about TDC, ToT, Mult in sectors

- To be fixed: sector decision, digit count in sectors

* Filling hit mult. in every sector, filling time in every sector

* Unified digit loops

* Add realistic splitting in A/C O/I sides

* Format header

* Add support for newline

* Add TObjArray.h as include
diff --git a/Modules/TOF/include/TOF/TOFCheckRawsMulti.h b/Modules/TOF/include/TOF/TOFCheckRawsMulti.h
@@ -17,6 +17,7 @@
 #define QC_MODULE_TOF_TOFCHECKRAWSMULTI_H
 
 #include "QualityControl/CheckInterface.h"
+#include "TString.h"
 
 namespace o2::quality_control_modules::tof
 {
@@ -38,10 +39,16 @@ class TOFCheckRawsMulti : public o2::quality_control::checker::CheckInterface
   void beautify(std::shared_ptr<MonitorObject> mo, Quality checkResult) override;
   std::string getAcceptedType() override;
 
-  /// Minumum value of TOF raw hit multiplicity
+  /// Minimum value of TOF raw hit multiplicity
   Float_t minTOFrawhits;
   /// Maximum value of TOF raw hit multiplicity
   Float_t maxTOFrawhits;
+  /// Fraction of the total integral which are considered Ok at 0 mult
+  const Float_t fracAtZeroMult = 0.75;
+  /// Fraction of the total integral which are considered Ok at low mult
+  const Float_t fracAtLowMult = 0.75;
+  /// Maximum average TOF raw hit multiplicity in Pb-Pb
+  const Float_t maxTOFrawhitsPbPb = 500;
 
  private:
   /// Mean of the TOF hit multiplicity histogram
@@ -52,6 +59,8 @@ class TOFCheckRawsMulti : public o2::quality_control::checker::CheckInterface
   Float_t lowMIntegral;
   /// Number of events with TOF hits multiplicity > 0
   Float_t totIntegral;
+  /// Message to print
+  TString shifter_msg = "";
 
   ClassDefOverride(TOFCheckRawsMulti, 1);
 };
diff --git a/Modules/TOF/src/TOFCheckRawsMulti.cxx b/Modules/TOF/src/TOFCheckRawsMulti.cxx
@@ -23,6 +23,7 @@
 #include <TH1.h>
 #include <TPaveText.h>
 #include <TList.h>
+#include <TObjArray.h>
 
 using namespace std;
 
@@ -80,73 +81,79 @@ Quality TOFCheckRawsMulti::check(std::map<std::string, std::shared_ptr<MonitorOb
       //       h->SetBit(AliQAv1::GetImageBit(), kTRUE);
       //   }
       // }
-      if (h->GetEntries() == 0) {
+      if (h->GetEntries() == 0) { // Histogram is empty
         result = Quality::Medium;
         // flag = AliQAv1::kWARNING;
-      } else {
+        shifter_msg = "No counts!";
+      } else { // Histogram is non empty
         multiMean = h->GetMean();
         zeroBinIntegral = h->Integral(1, 1);
         lowMIntegral = h->Integral(1, 10);
         totIntegral = h->Integral(2, h->GetNbinsX());
 
         if (totIntegral == 0) { //if only "0 hits per event" bin is filled -> error
           if (h->GetBinContent(1) > 0) {
-            result = Quality::Medium;
+            result = Quality::Bad;
             // flag = AliQAv1::kERROR;
+            shifter_msg = "Only events at 0 filled!";
           }
         } else {
           // if (AliRecoParam::ConvertIndex(specie) == AliRecoParam::kCosmic) {
-          if (0) {
+          if (0) { // TODO: this is only for cosmics, how to check?
             if (multiMean < 10.) {
               result = Quality::Good;
+              shifter_msg = "Average within limits, OK!";
               // flag = AliQAv1::kINFO;
             } else {
               result = Quality::Medium;
+              shifter_msg = "Average outside limits!";
               // flag = AliQAv1::kWARNING;
             }
-          } else {
-            Bool_t isZeroBinContentHigh = kFALSE;
-            Bool_t isLowMultContentHigh = kFALSE;
-            Bool_t isINT7AverageLow = kFALSE;
-            Bool_t isINT7AverageHigh = kFALSE;
-
-            if (zeroBinIntegral > 0.75 * totIntegral)
-              isZeroBinContentHigh = kTRUE;
-            if (lowMIntegral > 0.75 * totIntegral)
-              isLowMultContentHigh = kTRUE;
-            if (multiMean < minTOFrawhits)
-              isINT7AverageLow = kTRUE;
-            if (multiMean > maxTOFrawhits)
-              isINT7AverageHigh = kTRUE;
+          } else { // Running with collisions
+            const Bool_t isZeroBinContentHigh = (zeroBinIntegral > fracAtZeroMult * totIntegral);
+            const Bool_t isLowMultContentHigh = (lowMIntegral > fracAtLowMult * totIntegral);
+            const Bool_t isINT7AverageLow = (multiMean < minTOFrawhits);
+            const Bool_t isINT7AverageHigh = (multiMean > maxTOFrawhits);
 
             // if (AliRecoParam::ConvertIndex(specie) == AliRecoParam::kLowMult) {
-            if (0) {
+            if (0) { // TODO: Low multiplicity running, how to check if it is pp? Probably this can be simplified in the json
               if (isZeroBinContentHigh && (multiMean > 10.)) {
 
               } else {
                 // if (!histname.Contains("INT7") && (multiMean > 100.)) {
                 if ((multiMean > 100.)) {
                   result = Quality::Medium;
+                  shifter_msg = "Average outside limits!";
                   // flag = AliQAv1::kWARNING;
                 } else {
                   // if (histname.Contains("INT7") && (isINT7AverageLow || isINT7AverageHigh)) {
                   if ((isINT7AverageLow || isINT7AverageHigh)) {
                     result = Quality::Medium;
+                    shifter_msg = "Average outside limits!";
                     // flag = AliQAv1::kWARNING;
                   } else {
                     result = Quality::Good;
+                    shifter_msg = "Average within limits, OK!";
                     // flag = AliQAv1::kINFO;
                   }
                 }
               }
-              // } else if ((AliRecoParam::ConvertIndex(specie) == AliRecoParam::kHighMult) && (isLowMultContentHigh || (multiMean > 500.))) {
-            } else if ((isLowMultContentHigh || (multiMean > 500.))) {
-              //assume that good range of multi in PbPb goes from 20 to 500 tracks
-              result = Quality::Medium;
-              // flag = AliQAv1::kWARNING;
-            } else {
-              result = Quality::Good;
-              // flag = AliQAv1::kINFO;
+            }
+            // } else if ((AliRecoParam::ConvertIndex(specie) == AliRecoParam::kHighMult) && (isLowMultContentHigh || (multiMean > 500.))) {
+            else { // High multiplicity running e.g. Pb-Pb
+              if (isLowMultContentHigh) {
+                result = Quality::Medium;
+                shifter_msg = Form("Low-multiplicity counts are high\n(%.2f higher than total)!", fracAtLowMult);
+              } else if (multiMean > maxTOFrawhitsPbPb) {
+                //assume that good range of multi in PbPb goes from 20 to 500 tracks
+                result = Quality::Medium;
+                shifter_msg = Form("Average higher than expected (%.2f)!", maxTOFrawhitsPbPb);
+                // flag = AliQAv1::kWARNING;
+              } else {
+                result = Quality::Good;
+                shifter_msg = "Average within limits";
+                // flag = AliQAv1::kINFO;
+              }
             }
           }
         }
@@ -166,10 +173,13 @@ void TOFCheckRawsMulti::beautify(std::shared_ptr<MonitorObject> mo, Quality chec
     h->GetListOfFunctions()->Add(msg);
     msg->Draw();
     msg->SetName(Form("%s_msg", mo->GetName()));
+    msg->Clear();
+    TObjArray* txt_arr = shifter_msg.Tokenize("\n");
+    for (Int_t i = 0; i < txt_arr->GetEntries(); i++) {
+      msg->AddText(txt_arr->At(i)->GetName());
+    }
 
     if (checkResult == Quality::Good) {
-      LOG(INFO) << "Quality::Good, setting to green";
-      msg->Clear();
       msg->AddText(Form("Mean value = %5.2f", multiMean));
       msg->AddText(Form("Reference range: %5.2f-%5.2f", minTOFrawhits, maxTOFrawhits));
       msg->AddText(Form("Events with 0 hits = %5.2f%%", zeroBinIntegral * 100. / totIntegral));
@@ -178,20 +188,12 @@ void TOFCheckRawsMulti::beautify(std::shared_ptr<MonitorObject> mo, Quality chec
       //
       h->SetFillColor(kGreen);
     } else if (checkResult == Quality::Bad) {
-      LOG(INFO) << "Quality::Bad, setting to red";
-      //
-      msg->Clear();
-      msg->AddText("No TOF hits for all events.");
       msg->AddText("Call TOF on-call.");
       msg->SetFillColor(kRed);
       //
       h->SetFillColor(kRed);
     } else if (checkResult == Quality::Medium) {
-      LOG(INFO) << "Quality::medium, setting to orange";
-      //
-      msg->Clear();
-      msg->AddText("No entries. IF TOF IN RUN");
-      msg->AddText("check the TOF TWiki");
+      msg->AddText("IF TOF IN RUN check the TOF TWiki");
       msg->SetFillColor(kYellow);
       //
       h->SetFillColor(kOrange);
diff --git a/Modules/TOF/src/TOFTask.cxx b/Modules/TOF/src/TOFTask.cxx
@@ -21,6 +21,10 @@
 #include <TH1I.h>
 #include <TH2I.h>
 
+// O2 includes
+#include "TOFBase/Digit.h"
+#include "TOFBase/Geo.h"
+
 // QC includes
 #include "QualityControl/QcInfoLogger.h"
 #include "TOF/TOFTask.h"
@@ -274,6 +278,7 @@ void TOFTask::startOfCycle()
 
 void TOFTask::monitorData(o2::framework::ProcessingContext& ctx)
 {
+  // LOG(INFO) << "Monitoring in the TOF Task " << ENDM;
   // In this function you can access data inputs specified in the JSON config file, for example:
   //   "query": "random:ITS/RAWDATA/0"
   // which is correspondingly <binding>:<dataOrigin>/<dataDescription>/<subSpecification
@@ -285,19 +290,97 @@ void TOFTask::monitorData(o2::framework::ProcessingContext& ctx)
 
   // Some examples:
 
-  // 1. In a loop
-  for (auto&& input : ctx.inputs()) {
-    // get message header
-    if (input.header != nullptr && input.payload != nullptr) {
-      const auto* header = header::get<header::DataHeader*>(input.header);
-      // get payload of a specific input, which is a char array.
-      // const char* payload = input.payload;
-
-      // for the sake of an example, let's fill the histogram with payload sizes
-      mTOFRawsMulti->Fill(header->payloadSize);
+  // Get TOF digits
+  auto digits = ctx.inputs().get<gsl::span<o2::tof::Digit>>("tofdigits");
+  // Get TOF Readout window
+  auto rows = ctx.inputs().get<std::vector<o2::tof::ReadoutWindowData>>("readoutwin");
+  LOG(INFO) << "ReadoutWindow size::: " << rows.size();
+
+  Int_t eta, phi;
+  // Int_t det[5] = { 0 }; // Coordinates
+  Int_t strip = 0; // Strip (Put it into Geo.h?)
+  Float_t tdc_time = 0;
+  Float_t tot_time = 0;
+  // SM in side I: 14-17, 0-4 -> 4 + 5
+  // SM in side O: 5-13 -> 9
+  // phi is counted every pad starting from SM 0.
+  // There are 48 pads per SM. Side I is from phi 0:48*4 and 48*14:48*18
+  const Int_t phi_I1 = 48 * 4;
+  const Int_t phi_I2 = 48 * 14;
+  // eta is counted every half strip starting from strip 0.
+  // Halves strips in side A 0-90, in side C 91-181
+  const Int_t half_eta = 91;
+  Bool_t isSectorI = kFALSE;
+  Int_t ndigits[4] = { 0 }; // Number of digits per side I/A,O/A,I/C,O/C
+
+  // Loop on readout windows
+  for (const auto& row : rows) {
+    mTOFRawsMulti->Fill(row.size());                      // Number of digits inside a readout window
+    auto digits_in_row = row.getBunchChannelData(digits); // Digits inside a readout window
+    // Loop on digits
+    for (auto const& digit : digits_in_row) {
+      strip = ((digit.getChannel() / 96) % 91); // Strip index
+      // o2::tof::Geo::getVolumeIndices(digit.getChannel(), det);
+      // LOG(INFO) << "Filling digit #" << ndigits << " in sector #" << det[0] << " and strip #" << strip;
+      Int_t ech = o2::tof::Geo::getECHFromCH(digit.getChannel());
+      // mTOFRawHitMap->Fill(det[0], strip);
+      mTOFRawHitMap->Fill(Float_t(o2::tof::Geo::getCrateFromECH(ech)) / 4.f, strip);
+      // TDC time and ToT time
+      tdc_time = digit.getTDC() * o2::tof::Geo::TDCBIN * 0.001;
+      tot_time = digit.getTOT() * o2::tof::Geo::TOTBIN_NS;
+      mTOFRawsTime->Fill(tdc_time);
+      mTOFRawsToT->Fill(tot_time);
+      digit.getPhiAndEtaIndex(phi, eta);
+      isSectorI = phi < phi_I1 || phi > phi_I2;
+      if (eta < half_eta) { // Sector A
+        if (isSectorI) {    // Sector I/A
+          mTOFRawsTimeIA->Fill(tdc_time);
+          mTOFRawsToTIA->Fill(tot_time);
+          ndigits[0]++;
+        } else { // Sector O/A
+          mTOFRawsTimeOA->Fill(tdc_time);
+          mTOFRawsToTOA->Fill(tot_time);
+          ndigits[1]++;
+        }
+      } else {           // Sector C
+        if (isSectorI) { // Sector I/C
+          mTOFRawsTimeIC->Fill(tdc_time);
+          mTOFRawsToTIC->Fill(tot_time);
+          ndigits[2]++;
+        } else { // Sector O/C
+          mTOFRawsTimeOC->Fill(tdc_time);
+          mTOFRawsToTOC->Fill(tot_time);
+          ndigits[3]++;
+        }
+      }
     }
+    // Filling histograms of hit multiplicity
+    mTOFRawsMultiIA->Fill(ndigits[0]);
+    mTOFRawsMultiOA->Fill(ndigits[1]);
+    mTOFRawsMultiIC->Fill(ndigits[2]);
+    mTOFRawsMultiOC->Fill(ndigits[3]);
+    //
+    ndigits[0] = 0;
+    ndigits[1] = 0;
+    ndigits[2] = 0;
+    ndigits[3] = 0;
   }
 
+  // LOG(INFO) << "Digits counted:::::::: " << ndigits << "stop";
+
+  // 1. In a loop
+  // for (auto&& input : ctx.inputs()) {
+  // get message header
+  //   if (input.header != nullptr && input.payload != nullptr) {
+  //     const auto* header = header::get<header::DataHeader*>(input.header);
+  // get payload of a specific input, which is a char array.
+  // const char* payload = input.payload;
+  //     LOG(INFO) << "Payload is :::::::: " << input.payload;
+  // for the sake of an example, let's fill the histogram with payload sizes
+  //     mTOFRawsMulti->Fill(header->payloadSize);
+  //   }
+  // }
+
   // 2. Using get("<binding>")
 
   // get the payload of a specific input, which is a char array. "random" is the binding specified in the config file.
