Merge branch 'AliceO2Group:dev' into cholmcc_aod_producers_refactor

Author: Christian Holm Christensen

CCDB/src/CCDBDownloader.cxx

@@ -403,30 +403,37 @@ std::string CCDBDownloader::trimHostUrl(std::string full_host_url) const
 {
   CURLU* host_url = curl_url();
   curl_url_set(host_url, CURLUPART_URL, full_host_url.c_str(), 0);
-  // Get host part
+
+  // Get host part (the only critical part)
   char* host;
   CURLUcode host_result = curl_url_get(host_url, CURLUPART_HOST, &host, 0);
-  std::string host_name;
-  if (host_result == CURLUE_OK) {
-    // Host part present
-    host_name = host;
-    curl_free(host);
-  } else {
+  if (host_result != CURLUE_OK) {
     LOG(error) << "CCDBDownloader: Malformed url detected when processing redirect, could not identify the host part: " << host;
     curl_url_cleanup(host_url);
     return "";
   }
   // Get scheme (protocol) part
   char* scheme;
   CURLUcode scheme_result = curl_url_get(host_url, CURLUPART_SCHEME, &scheme, 0);
+  // Get port
+  char* port;
+  CURLUcode port_result = curl_url_get(host_url, CURLUPART_PORT, &port, 0);
+
   curl_url_cleanup(host_url);
+
+  // Assemble parts
+  std::string trimmed_url = "";
   if (scheme_result == CURLUE_OK) {
-    // If protocol present combine with host
-    curl_free(scheme);
-    return scheme + std::string("://") + host_name;
-  } else {
-    return host_name;
+    trimmed_url += scheme + std::string("://");
+    free(scheme);
+  }
+  trimmed_url += host;
+  free(host);
+  if (port_result == CURLUE_OK) {
+    trimmed_url += std::string(":") + port;
+    free(port);
   }
+  return trimmed_url;
 }
 
 std::string CCDBDownloader::prepareRedirectedURL(std::string address, std::string potentialHost) const

DataFormats/Detectors/CTP/src/Configuration.cxx

@@ -1049,6 +1049,9 @@ void CTPInputsConfiguration::printStream(std::ostream& stream) const
     input.printStream(stream);
   }
 }
+//
+// EMBA - software generated input for EMC - Min Bias Accepted
+//
 const std::vector<CTPInput> CTPInputsConfiguration::CTPInputsDefault =
   {
     CTPInput("MT0A", "FT0", 1), CTPInput("MT0C", "FT0", 2), CTPInput("MTVX", "FT0", 3), CTPInput("MTSC", "FT0", 4), CTPInput("MTCE", "FT0", 5),
@@ -1057,7 +1060,7 @@ const std::vector<CTPInput> CTPInputsConfiguration::CTPInputsDefault =
     CTPInput("0DMC", "EMC", 14), CTPInput("0DJ1", "EMC", 41), CTPInput("0DG1", "EMC", 42), CTPInput("0DJ2", "EMC", 43), CTPInput("0DG2", "EMC", 44),
     CTPInput("0EMC", "EMC", 21), CTPInput("0EJ1", "EMC", 37), CTPInput("0EG1", "EMC", 38), CTPInput("0EJ2", "EMC", 39), CTPInput("0EG2", "EMC", 40),
     CTPInput("0PH0", "PHS", 22), CTPInput("1PHL", "PHS", 27), CTPInput("1PHH", "PHS", 28), CTPInput("1PHL", "PHM", 29),
-    CTPInput("1ZED", "ZDC", 25), CTPInput("1ZNC", "ZDC", 26)};
+    CTPInput("1ZED", "ZDC", 25), CTPInput("1ZNC", "ZDC", 26), CTPInput("EMBA", "EMC", 48)};
 void CTPInputsConfiguration::initDefaultInputConfig()
 {
   defaultInputConfig.CTPInputs = CTPInputsConfiguration::CTPInputsDefault;

DataFormats/Detectors/CTP/src/Scalers.cxx

@@ -628,6 +628,8 @@ void CTPRunScalers::printLMBRateVsT() const
 
 // returns the pair of global (levelled) interaction rate, as well as instantaneous interpolated
 // rate in Hz at a certain orbit number within the run
+// type - 7 : inputs
+// type - 1..6 : lmb,lma,l0b,l0a,l1b,l1a
 std::pair<double, double> CTPRunScalers::getRate(uint32_t orbit, int classindex, int type) const
 {
   if (mScalerRecordO2.size() <= 1) {
@@ -646,23 +648,49 @@ std::pair<double, double> CTPRunScalers::getRate(uint32_t orbit, int classindex,
     auto next = &mScalerRecordO2[index2];
     auto prev = &mScalerRecordO2[index1];
     auto timedelta = (next->intRecord.orbit - prev->intRecord.orbit) * 88.e-6; // converts orbits into time
-    auto s0 = &(prev->scalers[classindex]);                                    // type CTPScalerO2*
-    auto s1 = &(next->scalers[classindex]);
-    return (s1->lmBefore - s0->lmBefore) / timedelta; // rate --> should be made better by selecting on type
+    if (type < 7) {
+      auto s0 = &(prev->scalers[classindex]); // type CTPScalerO2*
+      auto s1 = &(next->scalers[classindex]);
+      switch (type) {
+        case 1:
+          return (s1->lmBefore - s0->lmBefore) / timedelta;
+        case 2:
+          return (s1->lmAfter - s0->lmAfter) / timedelta;
+        case 3:
+          return (s1->l0Before - s0->l0Before) / timedelta;
+        case 4:
+          return (s1->l0After - s0->l0After) / timedelta;
+        case 5:
+          return (s1->l1Before - s0->l1Before) / timedelta;
+        case 6:
+          return (s1->l1After - s0->l1After) / timedelta;
+        default:
+          LOG(error) << "Wrong type:" << type;
+          return -1; // wrong type
+      }
+    } else if (type == 7) {
+      auto s0 = &(prev->scalersInps[classindex]); // type CTPScalerO2*
+      auto s1 = &(next->scalersInps[classindex]);
+      return (s1 - s0) / timedelta;
+    } else {
+      LOG(error) << "Wrong type:" << type;
+      return -1; // wrong type
+    }
   };
 
   if (nextindex == 0 || nextindex == mScalerRecordO2.size()) {
     // orbit is out of bounds
     LOG(info) << "query orbit " << orbit << " out of bounds; Just returning the global rate";
     return std::make_pair(/*global mean rate*/ calcRate(0, mScalerRecordO2.size() - 1), /* current rate */ -1);
   } else {
-
     return std::make_pair(/*global mean rate*/ calcRate(0, mScalerRecordO2.size() - 1), /* current rate */ calcRate(nextindex - 1, nextindex));
   }
   return std::make_pair(-1., -1.);
 }
 // returns the pair of global (levelled) interaction rate, as well as instantaneous interpolated
 // rate in Hz at a certain orbit number within the run
+// type - 7 : inputs
+// type - 1..6 : lmb,lma,l0b,l0a,l1b,l1a
 std::pair<double, double> CTPRunScalers::getRateGivenT(double timestamp, int classindex, int type) const
 {
   if (mScalerRecordO2.size() <= 1) {
@@ -681,11 +709,37 @@ std::pair<double, double> CTPRunScalers::getRateGivenT(double timestamp, int cla
     auto next = &mScalerRecordO2[index2];
     auto prev = &mScalerRecordO2[index1];
     auto timedelta = (next->intRecord.orbit - prev->intRecord.orbit) * 88.e-6; // converts orbits into time
-    auto s0 = &(prev->scalers[classindex]);                                    // type CTPScalerO2*
-    auto s1 = &(next->scalers[classindex]);
-    return (s1->lmBefore - s0->lmBefore) / timedelta; // rate --> should be made better by selecting on type
+    // std::cout << "timedelta:" << timedelta << std::endl;
+    if (type < 7) {
+      auto s0 = &(prev->scalers[classindex]); // type CTPScalerO2*
+      auto s1 = &(next->scalers[classindex]);
+      switch (type) {
+        case 1:
+          return (s1->lmBefore - s0->lmBefore) / timedelta;
+        case 2:
+          return (s1->lmAfter - s0->lmAfter) / timedelta;
+        case 3:
+          return (s1->l0Before - s0->l0Before) / timedelta;
+        case 4:
+          return (s1->l0After - s0->l0After) / timedelta;
+        case 5:
+          return (s1->l1Before - s0->l1Before) / timedelta;
+        case 6:
+          return (s1->l1After - s0->l1After) / timedelta;
+        default:
+          LOG(error) << "Wrong type:" << type;
+          return -1; // wrong type
+      }
+    } else if (type == 7) {
+      // LOG(info) << "doing input:";
+      auto s0 = prev->scalersInps[classindex]; // type CTPScalerO2*
+      auto s1 = next->scalersInps[classindex];
+      return (s1 - s0) / timedelta;
+    } else {
+      LOG(error) << "Wrong type:" << type;
+      return -1; // wrong type
+    }
   };
-
   if (nextindex == 0 || nextindex == mScalerRecordO2.size()) {
     // orbit is out of bounds
     LOG(info) << "query timestamp " << timestamp << " out of bounds; Just returning the global rate";

DataFormats/Detectors/TPC/include/DataFormatsTPC/PIDResponse.h

@@ -58,7 +58,7 @@ class PIDResponse
   GPUd() float getExpectedSignal(const TrackTPC& track, const o2::track::PID::ID id) const;
 
   /// get most probable PID of the track
-  GPUd() o2::track::PID::ID getMostProbablePID(const TrackTPC& track, float PID_EKrangeMin, float PID_EKrangeMax, float PID_EPrangeMin, float PID_EPrangeMax, float PID_EDrangeMin, float PID_EDrangeMax, float PID_ETrangeMin, float PID_ETrangeMax) const;
+  GPUd() o2::track::PID::ID getMostProbablePID(const TrackTPC& track, float PID_EKrangeMin, float PID_EKrangeMax, float PID_EPrangeMin, float PID_EPrangeMax, float PID_EDrangeMin, float PID_EDrangeMax, float PID_ETrangeMin, float PID_ETrangeMax, char PID_useNsigma, float PID_sigma) const;
 
  private:
   float mBetheBlochParams[5] = {0.19310481, 4.26696118, 0.00522579, 2.38124907, 0.98055396}; // BBAleph average fit parameters
@@ -88,7 +88,7 @@ GPUd() float PIDResponse::getExpectedSignal(const TrackTPC& track, const o2::tra
 }
 
 // get most probable PID
-GPUd() o2::track::PID::ID PIDResponse::getMostProbablePID(const TrackTPC& track, float PID_EKrangeMin, float PID_EKrangeMax, float PID_EPrangeMin, float PID_EPrangeMax, float PID_EDrangeMin, float PID_EDrangeMax, float PID_ETrangeMin, float PID_ETrangeMax) const
+GPUd() o2::track::PID::ID PIDResponse::getMostProbablePID(const TrackTPC& track, float PID_EKrangeMin, float PID_EKrangeMax, float PID_EPrangeMin, float PID_EPrangeMax, float PID_EDrangeMin, float PID_EDrangeMax, float PID_ETrangeMin, float PID_ETrangeMax, char PID_useNsigma, float PID_sigma) const
 {
   const float dEdx = track.getdEdx().dEdxTotTPC;
 
@@ -97,12 +97,28 @@ GPUd() o2::track::PID::ID PIDResponse::getMostProbablePID(const TrackTPC& track,
   }
 
   auto id = o2::track::PID::Electron;
-  float distanceMin = o2::gpu::GPUCommonMath::Abs(dEdx - getExpectedSignal(track, id));
+  float distanceMin = 0.;
+  float dEdxExpected = getExpectedSignal(track, id);
+  if (PID_useNsigma) {
+    // using nSigma
+    distanceMin = o2::gpu::GPUCommonMath::Abs((dEdx - dEdxExpected) / (PID_sigma * dEdxExpected));
+  } else {
+    // using absolute distance
+    distanceMin = o2::gpu::GPUCommonMath::Abs(dEdx - dEdxExpected);
+  }
 
   // calculate the distance to the expected dEdx signals
   // start from Pion to exlude Muons
   for (o2::track::PID::ID i = o2::track::PID::Pion; i < o2::track::PID::NIDs; i++) {
-    const float distance = o2::gpu::GPUCommonMath::Abs(dEdx - getExpectedSignal(track, i));
+    float distance = 0.;
+    dEdxExpected = getExpectedSignal(track, i);
+    if (PID_useNsigma) {
+      // using nSigma
+      distance = o2::gpu::GPUCommonMath::Abs((dEdx - dEdxExpected) / (PID_sigma * dEdxExpected));
+    } else {
+      // using absolute distance
+      distance = o2::gpu::GPUCommonMath::Abs(dEdx - dEdxExpected);
+    }
     if (distance < distanceMin) {
       id = i;
       distanceMin = distance;

DataFormats/Detectors/TRD/include/DataFormatsTRD/Constants.h

@@ -41,6 +41,7 @@ constexpr int TRDLINKID = 15;        ///< hard coded link id, specific to TRD
 constexpr int NCOLUMN = 144; ///< the number of pad columns for each chamber
 constexpr int NROWC0 = 12;   ///< the number of pad rows for chambers of type C0 (installed in stack 2)
 constexpr int NROWC1 = 16;   ///< the number of pad rows for chambers of type C1 (installed in stacks 0, 1, 3 and 4)
+constexpr int FIRSTROW[NSTACK] = {0, 16, 32, 44, 60}; ///< first pad row for each stack
 
 constexpr int NMCMROB = 16;     ///< the number of MCMs per ROB
 constexpr int NMCMHCMAX = 64;   ///< the maximum number of MCMs for one half chamber (C1 type)

DataFormats/Detectors/TRD/include/DataFormatsTRD/Digit.h

@@ -82,6 +82,7 @@ class Digit
   int getPadCol() const { return HelperMethods::getPadColFromADC(mROB, mMCM, mChannel); }
   int getROB() const { return mROB; }
   int getMCM() const { return mMCM; }
+  int getMCMCol() const { return (getMCM() % constants::NMCMROBINCOL) + constants::NMCMROBINCOL * (getROB() % 2); }
   int getChannel() const { return mChannel; }
   int getPreTrigPhase() const { return ((mDetector >> 12) & 0xf); }
   bool isSharedDigit() const;

DataFormats/MemoryResources/test/testMemoryResources.cxx

@@ -47,7 +47,7 @@ int testData::nconstructions = 0;
 
 BOOST_AUTO_TEST_CASE(transportallocatormap_test)
 {
-  size_t session{fair::mq::tools::UuidHash()};
+  size_t session{(size_t)getpid() * 1000};
   fair::mq::ProgOptions config;
   config.SetProperty<std::string>("session", std::to_string(session));
 
@@ -64,7 +64,7 @@ using namespace boost::container::pmr;
 
 BOOST_AUTO_TEST_CASE(allocator_test)
 {
-  size_t session{fair::mq::tools::UuidHash()};
+  size_t session{(size_t)getpid() * 1000 + 1};
   fair::mq::ProgOptions config;
   config.SetProperty<std::string>("session", std::to_string(session));
 
@@ -102,7 +102,7 @@ BOOST_AUTO_TEST_CASE(allocator_test)
 
 BOOST_AUTO_TEST_CASE(getMessage_test)
 {
-  size_t session{fair::mq::tools::UuidHash()};
+  size_t session{(size_t)getpid() * 1000 + 2};
   fair::mq::ProgOptions config;
   config.SetProperty<std::string>("session", std::to_string(session));
 
@@ -154,7 +154,7 @@ BOOST_AUTO_TEST_CASE(getMessage_test)
 
 BOOST_AUTO_TEST_CASE(adoptVector_test)
 {
-  size_t session{fair::mq::tools::UuidHash()};
+  size_t session{(size_t)getpid() * 1000 + 3};
   fair::mq::ProgOptions config;
   config.SetProperty<std::string>("session", std::to_string(session));
 
@@ -165,7 +165,7 @@ BOOST_AUTO_TEST_CASE(adoptVector_test)
 
   testData::nconstructions = 0;
 
-  //Create a bogus message
+  // Create a bogus message
   auto message = factoryZMQ->CreateMessage(3 * sizeof(testData));
   auto messageAddr = message.get();
   testData tmpBuf[3] = {3, 2, 1};

Detectors/CTP/macro/PlotPbLumi.C

@@ -25,7 +25,7 @@
 #include <iostream>
 #endif
 using namespace o2::ctp;
-void PlotPbLumiII(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-test.cern.ch:8080")
+void PlotPbLumi(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-test.cern.ch:8080")
 { //
   // what = 1: znc rate
   // what = 2: (TCE+TSC)/ZNC
@@ -173,4 +173,10 @@ void PlotPbLumiII(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-
   gr3->Draw("AP");
   c1->cd(4);
   gr4->Draw("AP");
+  // getRate test:
+  double tt = timeStamp / 1000.;
+  std::pair<double, double> r1 = scl->getRateGivenT(tt, 25, 7);
+  std::cout << "ZDC input getRateGivetT:" << r1.first / 28. << " " << r1.second / 28. << std::endl;
+  std::pair<double, double> r2 = scl->getRateGivenT(tt, tce, 1);
+  std::cout << "LM before TCE class getRateGivetT:" << r2.first << " " << r2.second << std::endl;
 }