Merge ad58743 into sapling-pr-archive-ktf

Author: ktf

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

@@ -53,7 +53,7 @@ class Cluster : public o2::BaseCluster<float>
 
   Cluster() = default;
 
-  Cluster(std::int16_t sensid, float x, float y, float z, float sy2, float sz2, float syz, double timeRaw, double time, float tot, int L0L1latency, int deltaBC);
+  Cluster(std::int16_t sensid, float x, float y, float z, float sy2, float sz2, float syz, double timeRaw, double time, float tot, int L0L1latency, int deltaBC, float geanttime = 0.0, double t0 = 0.0);
 
   ~Cluster() = default;
 
@@ -134,6 +134,10 @@ class Cluster : public o2::BaseCluster<float>
   int getDigitInfoCH(int idig) const { return mDigitInfoCh[idig]; }
   double getDigitInfoT(int idig) const { return mDigitInfoT[idig]; }
   float getDigitInfoTOT(int idig) const { return mDigitInfoTOT[idig]; }
+  float getTgeant() const { return mTgeant; }
+  void setTgeant(float val) { mTgeant = val; }
+  double getT0true() const { return mT0true; }
+  void setT0true(double val) { mT0true = val; }
 
  private:
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
@@ -153,8 +157,10 @@ class Cluster : public o2::BaseCluster<float>
   int mDigitInfoCh[6] = {0, 0, 0, 0, 0, 0};
   double mDigitInfoT[6] = {0., 0., 0., 0., 0., 0.};
   float mDigitInfoTOT[6] = {0., 0., 0., 0., 0., 0.};
+  float mTgeant = 0.0;
+  double mT0true = 0.0;
 
-  ClassDefNV(Cluster, 4);
+  ClassDefNV(Cluster, 5);
 };
 
 #ifndef GPUCA_GPUCODE

DataFormats/Detectors/TOF/src/Cluster.cxx

@@ -23,7 +23,7 @@ using namespace o2::tof;
 
 ClassImp(o2::tof::Cluster);
 
-Cluster::Cluster(std::int16_t sensid, float x, float y, float z, float sy2, float sz2, float syz, double timeRaw, double time, float tot, int L0L1Latency, int deltaBC) : o2::BaseCluster<float>(sensid, x, y, z, sy2, sz2, syz), mTimeRaw(timeRaw), mTime(time), mTot(tot), mL0L1Latency(L0L1Latency), mDeltaBC(deltaBC)
+Cluster::Cluster(std::int16_t sensid, float x, float y, float z, float sy2, float sz2, float syz, double timeRaw, double time, float tot, int L0L1Latency, int deltaBC, float geanttime, double t0) : o2::BaseCluster<float>(sensid, x, y, z, sy2, sz2, syz), mTimeRaw(timeRaw), mTime(time), mTot(tot), mL0L1Latency(L0L1Latency), mDeltaBC(deltaBC), mTgeant(geanttime), mT0true(t0)
 {
 
   // caching R and phi

DataFormats/Reconstruction/include/ReconstructionDataFormats/MatchInfoTOF.h

@@ -28,7 +28,7 @@ class MatchInfoTOF
   using GTrackID = o2::dataformats::GlobalTrackID;
 
  public:
-  MatchInfoTOF(int idLocal, int idxTOFCl, double time, float chi2, o2::track::TrackLTIntegral trkIntLT, GTrackID idxTrack, float dt = 0, float z = 0, float dx = 0, float dz = 0, float dy = 0) : mIdLocal(idLocal), mIdxTOFCl(idxTOFCl), mSignal(time), mChi2(chi2), mIntLT(trkIntLT), mIdxTrack(idxTrack), mDeltaT(dt), mZatTOF(z), mDXatTOF(dx), mDZatTOF(dz), mDYatTOF(dy){};
+  MatchInfoTOF(int idLocal, int idxTOFCl, double time, float chi2, o2::track::TrackLTIntegral trkIntLT, GTrackID idxTrack, float dt = 0, float z = 0, float dx = 0, float dz = 0, float dy = 0, float geanttime = 0.0, double t0 = 0.0) : mIdLocal(idLocal), mIdxTOFCl(idxTOFCl), mSignal(time), mChi2(chi2), mIntLT(trkIntLT), mIdxTrack(idxTrack), mDeltaT(dt), mZatTOF(z), mDXatTOF(dx), mDZatTOF(dz), mDYatTOF(dy), mTgeant(geanttime), mT0true(t0){};
   MatchInfoTOF() = default;
   void setIdxTOFCl(int index) { mIdxTOFCl = index; }
   void setIdxTrack(GTrackID index) { mIdxTrack = index; }
@@ -70,6 +70,10 @@ class MatchInfoTOF
   void setVz(float val) { mVz = val; }
   int getChannel() const { return mChannel; }
   void setChannel(int val) { mChannel = val; }
+  float getTgeant() const { return mTgeant; }
+  void setTgeant(float val) { mTgeant = val; }
+  double getT0true() const { return mT0true; }
+  void setT0true(double val) { mT0true = val; }
 
  private:
   int mIdLocal;                      // track id in sector of the pair track-TOFcluster
@@ -88,8 +92,10 @@ class MatchInfoTOF
   // Hit pattern information
   bool mHitUpDown = false;    ///< hit pattern in TOF up-down
   bool mHitLeftRight = false; ///< hit pattern in TOF left-right
+  float mTgeant = 0.0;        ///< geant time in MC
+  double mT0true = 0.0;       ///< t0true
 
-  ClassDefNV(MatchInfoTOF, 7);
+  ClassDefNV(MatchInfoTOF, 8);
 };
 } // namespace dataformats
 } // namespace o2

Detectors/CTP/workflowIO/src/DigitReaderSpec.cxx

@@ -17,7 +17,10 @@
 #include "DataFormatsCTP/LumiInfo.h"
 #include "Headers/DataHeader.h"
 #include "DetectorsCommonDataFormats/DetID.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "CommonUtils/NameConf.h"
+#include "CommonUtils/IRFrameSelector.h"
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 #include "Framework/ControlService.h"
@@ -50,6 +53,7 @@ class DigitReader : public Task
   std::unique_ptr<TTree> mTree;
 
   bool mUseMC = false; // use MC truth
+  bool mUseIRFrames = false; // selected IRFrames mode
   std::string mDigTreeName = "o2sim";
   std::string mDigitBranchName = "CTPDigits";
   std::string mLumiBranchName = "CTPLumi";
@@ -58,29 +62,78 @@ class DigitReader : public Task
 DigitReader::DigitReader(bool useMC)
 {
   if (useMC) {
-    LOG(info) << "CTP does not support MC truth at the moment";
+    LOG(info) << "CTP : truth = data as CTP inputs are already digital";
   }
 }
 
 void DigitReader::init(InitContext& ic)
 {
   auto filename = o2::utils::Str::concat_string(o2::utils::Str::rectifyDirectory(ic.options().get<std::string>("input-dir")),
                                                 ic.options().get<std::string>("ctp-digit-infile"));
+  if (ic.options().hasOption("ignore-irframes") && !ic.options().get<bool>("ignore-irframes")) {
+    mUseIRFrames = true;
+  }
   connectTree(filename);
 }
 
 void DigitReader::run(ProcessingContext& pc)
 {
-  auto ent = mTree->GetReadEntry() + 1;
-  assert(ent < mTree->GetEntries()); // this should not happen
-
-  mTree->GetEntry(ent);
-  LOG(info) << "DigitReader pushes " << mDigits.size() << " digits at entry " << ent;
-  pc.outputs().snapshot(Output{"CTP", "DIGITS", 0}, mDigits);
-  pc.outputs().snapshot(Output{"CTP", "LUMI", 0}, mLumi);
-  if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
-    pc.services().get<ControlService>().endOfStream();
-    pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+  gsl::span<const o2::dataformats::IRFrame> irFrames{};
+  // LOG(info) << "Using IRs:" << mUseIRFrames;
+  if (mUseIRFrames) {
+    irFrames = pc.inputs().get<gsl::span<o2::dataformats::IRFrame>>("driverInfo");
+  }
+  auto ent = mTree->GetReadEntry();
+  if (!mUseIRFrames) {
+    ent++;
+    assert(ent < mTree->GetEntries()); // this should not happen
+    mTree->GetEntry(ent);
+    LOG(info) << "DigitReader pushes " << mDigits.size() << " digits at entry " << ent;
+    pc.outputs().snapshot(Output{"CTP", "DIGITS", 0}, mDigits);
+    pc.outputs().snapshot(Output{"CTP", "LUMI", 0}, mLumi);
+    if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
+      pc.services().get<ControlService>().endOfStream();
+      pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+    }
+  } else {
+    std::vector<o2::ctp::CTPDigit> digitSel;
+    if (irFrames.size()) { // we assume the IRFrames are in the increasing order
+      if (ent < 0) {
+        ent++;
+      }
+      o2::utils::IRFrameSelector irfSel;
+      // MC  digits are already aligned
+      irfSel.setSelectedIRFrames(irFrames, 0, 0, 0, true);
+      const auto irMin = irfSel.getIRFrames().front().getMin(); // use processed IRframes for rough comparisons (possible shift!)
+      const auto irMax = irfSel.getIRFrames().back().getMax();
+      LOGP(info, "Selecting IRFrame {}-{}", irMin.asString(), irMax.asString());
+      while (ent < mTree->GetEntries()) {
+        if (ent > mTree->GetReadEntry()) {
+          mTree->GetEntry(ent);
+        }
+        if (mDigits.front().intRecord <= irMax && mDigits.back().intRecord >= irMin) { // THere is overlap
+          for (int i = 0; i < (int)mDigits.size(); i++) {
+            const auto& dig = mDigits[i];
+            // if(irfSel.check(dig.intRecord)) { // adding selected digit
+            if (dig.intRecord >= irMin && dig.intRecord <= irMax) {
+              digitSel.push_back(dig);
+              LOG(info) << "adding:" << dig.intRecord << " ent:" << ent;
+            }
+          }
+        }
+        if (mDigits.back().intRecord < irMax) { // need to check the next entry
+          ent++;
+          continue;
+        }
+        break; // push collected data
+      }
+    }
+    pc.outputs().snapshot(Output{"CTP", "DIGITS", 0}, digitSel);
+    pc.outputs().snapshot(Output{"CTP", "LUMI", 0}, mLumi); // add full lumi for this TF
+    if (!irFrames.size() || irFrames.back().isLast()) {
+      pc.services().get<ControlService>().endOfStream();
+      pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+    }
   }
 }
 

Detectors/GlobalTracking/src/MatchTOF.cxx

@@ -967,6 +967,9 @@ void MatchTOF::doMatching(int sec)
           }
         }
 
+        // adjust accordingly to DeltaY
+        updateTL(trkLTInt[nStripsCrossedInPropagation - 1], -deltaPosTemp[1]);
+
         detId[nStripsCrossedInPropagation - 1][0] = detIdTemp[0];
         detId[nStripsCrossedInPropagation - 1][1] = detIdTemp[1];
         detId[nStripsCrossedInPropagation - 1][2] = detIdTemp[2];
@@ -1340,11 +1343,14 @@ void MatchTOF::doMatchingForTPC(int sec)
           for (int ii = 0; ii < 3; ii++) { // we need to change the type...
             posFloat[ii] = pos[ii];
           }
+
           while (deltaPosTemp2[1] < -0.05 && detIdTemp2[2] != -1 && nstep < maxnstep) { // continuing propagation if dy is negative and we are still inside the strip volume
             nstep++;
             xStop += 0.1;
             propagateToRefXWithoutCov(trefTrk, xStop, 0.1, mBz, posFloat);
 
+            posFloat[2] += ZshiftCurrent;
+
             Geo::getPadDxDyDz(posFloat, detIdTemp2, deltaPosTemp2, sec);
             if (detIdTemp2[2] != -1) { // if propation was succesful -> update params
               float dx = deltaPosTemp2[0] - deltaPosTemp[0];
@@ -1356,9 +1362,15 @@ void MatchTOF::doMatchingForTPC(int sec)
               detIdTemp[2] = detIdTemp2[2];
               detIdTemp[3] = detIdTemp2[3];
               detIdTemp[4] = detIdTemp2[4];
+              deltaPosTemp[0] = deltaPosTemp2[0];
+              deltaPosTemp[1] = deltaPosTemp2[1];
+              deltaPosTemp[2] = deltaPosTemp2[2];
             }
           }
 
+          // adjust accordingly to DeltaY
+          updateTL(trkLTInt[ibc][nStripsCrossedInPropagation[ibc] - 1], -deltaPosTemp[1]);
+
           detId[ibc][nStripsCrossedInPropagation[ibc] - 1][0] = detIdTemp[0];
           detId[ibc][nStripsCrossedInPropagation[ibc] - 1][1] = detIdTemp[1];
           detId[ibc][nStripsCrossedInPropagation[ibc] - 1][2] = detIdTemp[2];
@@ -1671,6 +1683,10 @@ void MatchTOF::BestMatches(std::vector<o2::dataformats::MatchInfoTOFReco>& match
           if (std::abs(timeNew - timeOld) < 200) {
             // update time information averaging the two (the second one corrected for the difference in the track length)
             prevMatching.setSignal((timeNew + timeOld) * 0.5);
+            float geanttime = (TOFClusWork[matchingPair.getTOFClIndex()].getTgeant() + TOFClusWork[prevMatching.getTOFClIndex()].getTgeant() - deltaT * 1E-3) * 0.5;
+            double t0 = (TOFClusWork[matchingPair.getTOFClIndex()].getT0true() + TOFClusWork[prevMatching.getTOFClIndex()].getT0true()) * 0.5;
+            prevMatching.setTgeant(geanttime);
+            prevMatching.setT0true(t0);
             prevMatching.setChi2(0);                                                                // flag such cases with chi2 equal to zero
             matchedClustersIndex[matchingPair.getTOFClIndex()] = matchedTracksIndex[trkType][itrk]; // flag also the second cluster as already used
           }
@@ -1682,6 +1698,9 @@ void MatchTOF::BestMatches(std::vector<o2::dataformats::MatchInfoTOFReco>& match
     matchedTracksIndex[trkType][itrk] = matchedTracks[trkTypeSplitted].size();              // index of the MatchInfoTOF correspoding to this track
     matchedClustersIndex[matchingPair.getTOFClIndex()] = matchedTracksIndex[trkType][itrk]; // index of the track that was matched to this cluster
 
+    matchingPair.setTgeant(TOFClusWork[matchingPair.getTOFClIndex()].getTgeant());
+    matchingPair.setT0true(TOFClusWork[matchingPair.getTOFClIndex()].getT0true());
+
     // let's check if cluster has multiple-hits (noferini)
     if (TOFClusWork[matchingPair.getTOFClIndex()].getNumOfContributingChannels() > 1) {
       const auto& tofcl = TOFClusWork[matchingPair.getTOFClIndex()];

Detectors/TOF/base/include/TOFBase/Digit.h

@@ -32,8 +32,8 @@ class Digit
  public:
   Digit() = default;
 
-  Digit(Int_t channel, Int_t tdc, Int_t tot, uint64_t bc, Int_t label = -1, uint32_t triggerorbit = 0, uint16_t triggerbunch = 0);
-  Digit(Int_t channel, Int_t tdc, Int_t tot, uint32_t orbit, uint16_t bc, Int_t label = -1, uint32_t triggerorbit = 0, uint16_t triggerbunch = 0);
+  Digit(Int_t channel, Int_t tdc, Int_t tot, uint64_t bc, Int_t label = -1, uint32_t triggerorbit = 0, uint16_t triggerbunch = 0, float geanttime = 0, double t0 = 0);
+  Digit(Int_t channel, Int_t tdc, Int_t tot, uint32_t orbit, uint16_t bc, Int_t label = -1, uint32_t triggerorbit = 0, uint16_t triggerbunch = 0, float geanttime = 0, double t0 = 0);
   ~Digit() = default;
 
   /// Get global ordering key made of
@@ -66,7 +66,7 @@ class Digit
 
   void printStream(std::ostream& stream) const;
 
-  void merge(Int_t tdc, Int_t tot);
+  bool merge(Int_t tdc, Int_t tot);
 
   void getPhiAndEtaIndex(int& phi, int& eta) const;
 
@@ -93,6 +93,11 @@ class Digit
   void setTriggerBunch(uint16_t value) { mTriggerBunch = value; }
   uint16_t getTriggerBunch() const { return mTriggerBunch; }
 
+  float getTgeant() const { return mTgeant; }
+  void setTgeant(float val) { mTgeant = val; }
+  double getT0true() const { return mT0true; }
+  void setT0true(double val) { mT0true = val; }
+
  private:
   friend class boost::serialization::access;
 
@@ -107,8 +112,10 @@ class Digit
   uint16_t mTriggerBunch = 0;    //!< bunch id of trigger event
   Bool_t mIsUsedInCluster;       //!/< flag to declare that the digit was used to build a cluster
   Bool_t mIsProblematic = false; //!< flag to tell whether the channel of the digit was problemati; not persistent; default = ok
+  float mTgeant = 0.0;           ///< geant time in MC
+  double mT0true = 0.0;          ///< t0true
 
-  ClassDefNV(Digit, 4);
+  ClassDefNV(Digit, 5);
 };
 
 std::ostream& operator<<(std::ostream& stream, const Digit& dig);

Detectors/TOF/base/include/TOFBase/Strip.h

@@ -80,7 +80,7 @@ class Strip
   /// reset points container
   o2::tof::Digit* findDigit(ULong64_t key);
 
-  Int_t addDigit(Int_t channel, Int_t tdc, Int_t tot, uint64_t bc, Int_t lbl = 0, uint32_t triggerorbit = 0, uint16_t triggerbunch = 0); // returns the MC label
+  Int_t addDigit(Int_t channel, Int_t tdc, Int_t tot, uint64_t bc, Int_t lbl = 0, uint32_t triggerorbit = 0, uint16_t triggerbunch = 0, float geanttime = 0, double t0 = 0); // returns the MC label
 
   void fillOutputContainer(std::vector<o2::tof::Digit>& digits);
 

Detectors/TOF/base/src/Digit.cxx

@@ -17,14 +17,14 @@ using namespace o2::tof;
 
 ClassImp(o2::tof::Digit);
 
-Digit::Digit(Int_t channel, Int_t tdc, Int_t tot, uint64_t bc, Int_t label, uint32_t triggerorbit, uint16_t triggerbunch)
-  : mChannel(channel), mTDC(tdc), mTOT(tot), mIR(0, 0), mLabel(label), mTriggerOrbit(triggerorbit), mTriggerBunch(triggerbunch), mIsUsedInCluster(kFALSE)
+Digit::Digit(Int_t channel, Int_t tdc, Int_t tot, uint64_t bc, Int_t label, uint32_t triggerorbit, uint16_t triggerbunch, float geanttime, double t0)
+  : mChannel(channel), mTDC(tdc), mTOT(tot), mIR(0, 0), mLabel(label), mTriggerOrbit(triggerorbit), mTriggerBunch(triggerbunch), mIsUsedInCluster(kFALSE), mTgeant(geanttime), mT0true(t0)
 {
   mIR.setFromLong(bc);
 }
 //______________________________________________________________________
-Digit::Digit(Int_t channel, Int_t tdc, Int_t tot, uint32_t orbit, uint16_t bc, Int_t label, uint32_t triggerorbit, uint16_t triggerbunch)
-  : mChannel(channel), mTDC(tdc), mTOT(tot), mIR(bc, orbit), mLabel(label), mTriggerOrbit(triggerorbit), mTriggerBunch(triggerbunch), mIsUsedInCluster(kFALSE)
+Digit::Digit(Int_t channel, Int_t tdc, Int_t tot, uint32_t orbit, uint16_t bc, Int_t label, uint32_t triggerorbit, uint16_t triggerbunch, float geanttime, double t0)
+  : mChannel(channel), mTDC(tdc), mTOT(tot), mIR(bc, orbit), mLabel(label), mTriggerOrbit(triggerorbit), mTriggerBunch(triggerbunch), mIsUsedInCluster(kFALSE), mTgeant(geanttime), mT0true(t0)
 {
 }
 //______________________________________________________________________
@@ -44,16 +44,18 @@ std::ostream& operator<<(std::ostream& stream, const Digit& digi)
 
 //______________________________________________________________________
 
-void Digit::merge(Int_t tdc, Int_t tot)
+bool Digit::merge(Int_t tdc, Int_t tot)
 {
 
   // merging two digits
 
   if (tdc < mTDC) {
     mTDC = tdc;
+    return 1; // new came first
     // TODO: adjust TOT
   } else {
     // TODO: adjust TOT
+    return 0;
   }
 }
 

Detectors/TOF/base/src/Strip.cxx

@@ -34,7 +34,7 @@ Strip::Strip(Int_t index)
 {
 }
 //_______________________________________________________________________
-Int_t Strip::addDigit(Int_t channel, Int_t tdc, Int_t tot, uint64_t bc, Int_t lbl, uint32_t triggerorbit, uint16_t triggerbunch)
+Int_t Strip::addDigit(Int_t channel, Int_t tdc, Int_t tot, uint64_t bc, Int_t lbl, uint32_t triggerorbit, uint16_t triggerbunch, float geanttime, double t0)
 {
 
   // return the MC label. We pass it also as argument, but it can change in
@@ -44,10 +44,13 @@ Int_t Strip::addDigit(Int_t channel, Int_t tdc, Int_t tot, uint64_t bc, Int_t lb
   auto dig = findDigit(key);
   if (dig) {
     lbl = dig->getLabel(); // getting the label from the already existing digit
-    dig->merge(tdc, tot);  // merging to the existing digit
+    if (dig->merge(tdc, tot)) { // merging to the existing digit (if new came first upload also MC truth)
+      dig->setTgeant(geanttime);
+      dig->setT0true(t0);
+    }
     mDigitMerged++;
   } else {
-    mDigits.emplace(std::make_pair(key, Digit(channel, tdc, tot, bc, lbl, triggerorbit, triggerbunch)));
+    mDigits.emplace(std::make_pair(key, Digit(channel, tdc, tot, bc, lbl, triggerorbit, triggerbunch, geanttime, t0)));
   }
 
   return lbl;

Detectors/TOF/reconstruction/src/Clusterer.cxx

@@ -173,6 +173,8 @@ void Clusterer::buildCluster(Cluster& c, MCLabelContainer const* digitMCTruth)
   }
 
   c.setMainContributingChannel(mContributingDigit[0]->getChannel());
+  c.setTgeant(mContributingDigit[0]->getTgeant());
+  c.setT0true(mContributingDigit[0]->getT0true());
   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)