commit 2: updated digitisation at the chip level (still need to figure out the proper way to clean up the extra digits)

Author: GiorgioAlbertoLucia

Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/include/DataFormatsIOTOF/Digit.h

@@ -19,6 +19,7 @@
 #ifndef ALICEO2_IOTOF_DIGIT_H
 #define ALICEO2_IOTOF_DIGIT_H
 
+#include "SimulationDataFormat/MCCompLabel.h"
 #include "DataFormatsITSMFT/Digit.h"
 
 namespace o2::iotof
@@ -28,7 +29,7 @@ class Digit : public o2::itsmft::Digit
  public:
   ~Digit() = default;
   Digit(UShort_t chipindex = 0, UShort_t row = 0, UShort_t col = 0, Int_t charge = 0, double time = 0.)
-    : o2::itsmft::Digit(chipindex, row, col, charge), mTime(time) {};
+    : o2::itsmft::Digit(chipindex, row, col, charge), mTime(time){};
 
   // Setters
   void setTime(double time) { mTime = time; }
@@ -46,5 +47,29 @@ class Digit : public o2::itsmft::Digit
   ClassDefNV(Digit, 1);
 };
 
+// McLabelRef is used to store the MC label of the hit contributing to a digit, and eventually link to extra contributions to the same pixel
+struct McLabelRef {
+  o2::MCCompLabel mLabel; ///< hit label
+  int mNext = -1;         ///< eventual next contribution to the same pixel
+  McLabelRef(o2::MCCompLabel label = 0, int next = -1) : mLabel(label), mNext(next) {}
+
+  ClassDefNV(McLabelRef, 1);
+};
+
+class LabeledDigit : public Digit
+{
+ public:
+  LabeledDigit(UShort_t chipindex = 0, UShort_t row = 0, UShort_t col = 0, Int_t charge = 0, double time = 0.,
+               o2::MCCompLabel label = 0)
+    : Digit(chipindex, row, col, charge, time), mLabel(label) {}
+
+  void setLabel(McLabelRef label) { mLabel = label; }
+  McLabelRef getLabel() const { return mLabel; }
+
+ private:
+  McLabelRef mLabel; ///< label of the hit contributing to the digit, and eventually reference to extra contributions to the same pixel
+  ClassDefNV(LabeledDigit, 1);
+};
+
 } // namespace o2::iotof
 #endif // ALICEO2_IOTOF_DIGIT_H

Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/src/DataFormatsIOTOFLinkDef.h

@@ -18,4 +18,10 @@
 #pragma link C++ class o2::iotof::Digit + ;
 #pragma link C++ class std::vector < o2::iotof::Digit> + ;
 
+#pragma link C++ class o2::iotof::McLabelRef + ;
+#pragma link C++ class std::vector < o2::iotof::McLabelRef> + ;
+
+#pragma link C++ class o2::iotof::LabeledDigit + ;
+#pragma link C++ class std::vector < o2::iotof::LabeledDigit> + ;
+
 #endif

Detectors/Upgrades/ALICE3/IOTOF/simulation/CMakeLists.txt

@@ -1,30 +1,35 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-# All rights not expressly granted are reserved.
+#Copyright 2019 - 2020 CERN and copyright holders of ALICE O2.
+#See https: // alice-o2.web.cern.ch/copyright for details of the copyright holders.
+#All rights not expressly granted are reserved.
 #
-# This software is distributed under the terms of the GNU General Public
-# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#This software is distributed under the terms of the GNU General Public
+#License v3(GPL Version 3), copied verbatim in the file "COPYING".
 #
-# In applying this license CERN does not waive the privileges and immunities
-# granted to it by virtue of its status as an Intergovernmental Organization
+#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(IOTOFSimulation
-               SOURCES src/Layer.cxx
-                       src/Detector.cxx
-                       src/Digitizer.cxx
-                       src/DPLDigitizerParam.cxx
-                      #  src/IOTOFServices.cxx
-                      src/Segmentation.cxx
-               PUBLIC_LINK_LIBRARIES O2::IOTOFBase
-                                     O2::DataFormatsIOTOF
-                                     O2::ITSMFTSimulation)
+                 SOURCES src /
+               Layer.cxx
+                 src /
+               Chip.cxx
+                 src /
+               Detector.cxx
+                 src /
+               Digitizer.cxx
+                 src /
+               DPLDigitizerParam.cxx
+#src / IOTOFServices.cxx
+                 src /
+               Segmentation.cxx
+                 PUBLIC_LINK_LIBRARIES O2::IOTOFBase
+                   O2::DataFormatsIOTOF
+                     O2::ITSMFTSimulation)
 
-o2_target_root_dictionary(IOTOFSimulation
-                          HEADERS include/IOTOFSimulation/Detector.h
-                                  include/IOTOFSimulation/Layer.h
-                                  include/IOTOFSimulation/Digitizer.h
-                                  include/IOTOFSimulation/DPLDigitizerParam.h
-                                  # include/IOTOFSimulation/IOTOFServices.h
-                                  include/IOTOFSimulation/Segmentation.h
-                          )
+  o2_target_root_dictionary(IOTOFSimulation
+                              HEADERS include /
+                            IOTOFSimulation / Detector.h include / IOTOFSimulation / Chip.h include / IOTOFSimulation / Layer.h include / IOTOFSimulation / Digitizer.h include / IOTOFSimulation / DPLDigitizerParam.h
+#include / IOTOFSimulation / IOTOFServices.h
+                                                                                                                                                                                                      include /
+                            IOTOFSimulation / Segmentation.h)

Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Chip.h

@@ -0,0 +1,98 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// 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.
+
+//
+//  TOF Chip class: it will be used to store the digits at TOF that
+//  fall in the same Chip
+//
+
+////////////////////////////////////
+// To put in O2/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/Chip.h
+
+#ifndef ALICEO2_IOTOF_CHIP_H_
+#define ALICEO2_IOTOF_CHIP_H_
+
+#include <DataFormatsIOTOF/Digit.h>
+#include <TObject.h>
+#include <exception>
+#include <map>
+#include <sstream>
+#include <vector>
+#include "MathUtils/Cartesian.h"
+
+namespace o2::iotof
+{
+
+/// @class Chip
+/// @brief Container for similated points connected to a given TOF Chip
+/// This will be used in order to allow a more efficient clusterization
+/// that can happen only between digits that belong to the same Chip
+///
+
+class Chip
+{
+
+ public:
+  /// Default constructor
+  Chip() = default;
+
+  /// Destructor
+  ~Chip() = default;
+
+  /// Main constructor
+  /// @param Chipindex Index of the Chip
+  /// @param mat Transformation matrix
+  Chip(Int_t index);
+
+  /// Copy constructor
+  /// @param ref Reference for the copy
+  Chip(const Chip& ref) = default;
+
+  /// Empties the point container
+  /// @param option unused
+  void clear() { mDigits.clear(); }
+
+  std::map<ULong64_t, o2::iotof::LabeledDigit>& getDigits() { return mDigits; }
+  bool isEmpty() const { return mDigits.empty(); }
+
+  void setChipIndex(Int_t index) { mChipIndex = index; }
+  Int_t getChipIndex() const { return mChipIndex; }
+  
+  void disable(bool disable) { mDisabled = disable; }
+  bool isDisabled() const { return mDisabled; }
+  
+  /// Get the number of point assigned to the chip
+  /// @return Number of points assigned to the chip
+  Int_t getNumberOfDigits() const { return mDigits.size(); }
+
+  /// reset points container
+  o2::iotof::LabeledDigit* findDigit(ULong64_t key);
+
+  void addDigit(UShort_t row, UShort_t col, Int_t charge, double time);
+
+ protected:
+  Int_t mChipIndex = -1;                      ///< Chip ID
+  bool mDisabled = false;                      ///< Flag to indicate if the chip is disabled (e.g. due to dead channels)
+  std::map<ULong64_t, o2::iotof::LabeledDigit> mDigits; ///< Map of fired digits, possibly in multiple frames
+
+  ClassDefNV(Chip, 1);
+};
+
+inline o2::iotof::LabeledDigit* Chip::findDigit(ULong64_t key)
+{
+  // finds the digit corresponding to global key
+  auto digitentry = mDigits.find(key);
+  return digitentry != mDigits.end() ? &(digitentry->second) : nullptr;
+}
+
+} // namespace o2::iotof
+
+#endif /* defined(ALICEO2_IOTOF_CHIP_H_) */

Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Digitizer.h

@@ -19,9 +19,16 @@
 #ifndef ALICEO2_IOTOF_DIGITIZER_H
 #define ALICEO2_IOTOF_DIGITIZER_H
 
+#include <vector>
+#include <deque>
+#include <memory>
+
+#include "Rtypes.h"  // for Digitizer::Class
+#include "TObject.h" // for TObject
+
 #include "ITSMFTSimulation/Hit.h"
-#include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsIOTOF/Digit.h"
+#include "IOTOFSimulation/Chip.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "CommonDataFormat/InteractionRecord.h"
 #include "SimulationDataFormat/MCCompLabel.h"
@@ -40,7 +47,7 @@ namespace o2::iotof
 /// - Converting energy loss to charge
 /// - Applying charge threshold
 /// - Managing readout frames (ROF)
-class Digitizer
+class Digitizer : public TObject
 {
  public:
   void setDigits(std::vector<o2::iotof::Digit>* dig) { mDigits = dig; }
@@ -81,6 +88,10 @@ class Digitizer
   /// Process a single hit
   void processHit(const o2::itsmft::Hit& hit, int evID, int srcID);
 
+  /// Register digits in a given chip
+  void registerDigits(Chip& chip, uint32_t roFrame, float timeInitROF, int nROF,
+                      uint16_t row, uint16_t col, int nElectrons, o2::MCCompLabel& label);
+
   /// Apply time smearing to simulate detector resolution
   double smearTime(double time) const;
 
@@ -90,10 +101,27 @@ class Digitizer
   /// Check if the hit passes efficiency cut
   bool isEfficient() const;
 
+  std::vector<o2::iotof::McLabelRef>* getExtraLabelBuffer(uint32_t roFrame)
+  {
+    // if (mROFrameMin > roFrame) {
+    //   return nullptr; // nothing to do
+    // }
+    // int index = roFrame - mROFrameMin;
+
+    int index = roFrame;
+    while (index >= int(mExtraLabelBuffer.size())) {
+      mExtraLabelBuffer.emplace_back(std::make_unique<std::vector<o2::iotof::McLabelRef>>());
+    }
+    return mExtraLabelBuffer[index].get();
+  }
+
   static constexpr float sec2ns = 1e9f; ///< seconds to nanoseconds conversion
 
   const o2::iotof::GeometryTGeo* mGeometry = nullptr; ///< IOTOF geometry
 
+  std::vector<o2::iotof::Chip> mChips;                                               //! Chips in the detector, indexed by chip ID
+  std::deque<std::unique_ptr<std::vector<o2::iotof::McLabelRef>>> mExtraLabelBuffer; //! buffer for multiple mc labels to the same pixel
+
   std::vector<o2::iotof::Digit>* mDigits = nullptr;                        //! output digits
   std::vector<o2::itsmft::ROFRecord>* mROFRecords = nullptr;               //! output ROF records
   o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mMCLabels = nullptr; //! output labels
@@ -108,6 +136,8 @@ class Digitizer
   float mEnergyToCharge = 3.6e-9f; ///< energy loss to electrons conversion (3.6 eV per e-h pair in Si)
 
   static o2::iotof::Segmentation* sSegmentation; ///< IOTOF segmentation instance (singleton)
+
+  ClassDefNV(Digitizer, 1);
 };
 } // namespace o2::iotof
 

Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Chip.cxx

@@ -0,0 +1,39 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// 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.
+
+//
+//  Chip.cxx: structure to store the TOF digits in Chips - useful
+// for clusterization purposes
+//  ALICEO2
+//
+#include <cstring>
+#include <tuple>
+
+#include <TMath.h>
+#include <TObjArray.h>
+
+#include "IOTOFSimulation/Chip.h"
+
+using namespace o2::iotof;
+
+ClassImp(o2::iotof::Chip);
+
+//_______________________________________________________________________
+Chip::Chip(Int_t index)
+  : mChipIndex(index)
+{
+}
+//_______________________________________________________________________
+void Chip::addDigit(UShort_t row, UShort_t col, Int_t charge, double time)
+{
+  ULong64_t key = Digit::getOrderingKey(mChipIndex, row, col);
+  mDigits.emplace(std::make_pair(key, LabeledDigit(mChipIndex, row, col, charge, time)));
+}