TPC: Add simple raw data filter for krypton clusters

Author: wiechula

Detectors/TPC/calibration/include/TPCCalibration/DigitDump.h

@@ -77,6 +77,12 @@ class DigitDump : public CalibRawBase
   Int_t updateCRU(const CRU& cru, const Int_t row, const Int_t pad,
                   const Int_t timeBin, const Float_t signal) final;
 
+  /// Set a custom pedestal object
+  void setPedestals(const CalPad* pedestal) { mPedestal.reset(pedestal); }
+
+  /// Set a custom noise object
+  void setNoise(const CalPad* noise) { mNoise.reset(noise); }
+
   /// Get the pedestal calibration object
   ///
   /// \return pedestal calibration object
@@ -152,8 +158,8 @@ class DigitDump : public CalibRawBase
   void removeCEdigits(uint32_t removeNtimeBinsBefore = 10, uint32_t removeNtimeBinsAfter = 100, std::array<std::vector<Digit>, Sector::MAXSECTOR>* removedDigits = nullptr);
 
  private:
-  std::unique_ptr<CalPad> mPedestal{}; ///< CalDet object with pedestal information
-  std::unique_ptr<CalPad> mNoise{};    ///< CalDet object with noise
+  std::unique_ptr<const CalPad> mPedestal{}; ///< CalDet object with pedestal information
+  std::unique_ptr<const CalPad> mNoise{};    ///< CalDet object with noise
 
   TTree* mTree{nullptr};          ///< output tree
   std::unique_ptr<TFile> mFile{}; ///< output file

Detectors/TPC/calibration/src/DigitDump.cxx

@@ -156,8 +156,8 @@ void DigitDump::loadNoiseAndPedestal()
   f->GetObject("Pedestals", pedestal);
   f->GetObject("Noise", noise);
 
-  mPedestal = std::move(std::unique_ptr<CalPad>(pedestal));
-  mNoise = std::move(std::unique_ptr<CalPad>(noise));
+  mPedestal = std::move(std::unique_ptr<const CalPad>(pedestal));
+  mNoise = std::move(std::unique_ptr<const CalPad>(noise));
 }
 
 //______________________________________________________________________________

Detectors/TPC/workflow/CMakeLists.txt

@@ -22,6 +22,7 @@ o2_add_library(TPCWorkflow
                        src/ClusterSharingMapSpec.cxx
                        src/CalDetMergerPublisherSpec.cxx
                        src/KryptonClustererSpec.cxx
+                       src/KryptonRawFilterSpec.cxx
                        src/IDCToVectorSpec.cxx
                        src/CalibdEdxSpec.cxx
                        src/CalibratordEdxSpec.cxx
@@ -137,6 +138,11 @@ o2_add_executable(krypton-clusterer
                   SOURCES src/tpc-krypton-clusterer.cxx
                   PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
 
+o2_add_executable(krypton-raw-filter
+                  COMPONENT_NAME tpc
+                  SOURCES src/tpc-krypton-raw-filter.cxx
+                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
+
 o2_add_executable(idc-to-vector
                   COMPONENT_NAME tpc
                   SOURCES src/tpc-idc-to-vector.cxx

Detectors/TPC/workflow/include/TPCWorkflow/FileWriterSpec.h

@@ -26,7 +26,7 @@ namespace tpc
 
 /// create a processor spec
 /// read simulated TPC clusters from file and publish
-o2::framework::DataProcessorSpec getFileWriterSpec(const std::string inputSpec);
+o2::framework::DataProcessorSpec getFileWriterSpec(const std::string inputSpec, const std::string branchType = "krypton");
 
 } // end namespace tpc
 } // end namespace o2

Detectors/TPC/workflow/include/TPCWorkflow/KryptonClustererSpec.h

@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// @file   RawToDigitsSpec.h
+/// @file   KryptonClustererSpec.h
 /// @author Jens Wiechula
 /// @since  2021-02-26
 /// @brief  Processor spec for running TPC Krypton cluster finder

Detectors/TPC/workflow/include/TPCWorkflow/KryptonRawFilterSpec.h

@@ -0,0 +1,32 @@
+// 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.
+
+/// @file   KryptonRawFilterSpec.h
+/// @author Jens Wiechula
+/// @since  2021-11-19
+/// @brief  Processor spec for filtering krypton raw data
+
+#ifndef TPC_KrRawFilterSpec_H_
+#define TPC_KrRawFilterSpec_H_
+
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2
+{
+namespace tpc
+{
+
+o2::framework::DataProcessorSpec getKryptonRawFilterSpec();
+
+} // end namespace tpc
+} // end namespace o2
+
+#endif // TPC_RAWTODIGITSSPEC_H_

Detectors/TPC/workflow/src/FileWriterSpec.cxx

@@ -47,13 +47,40 @@ using o2::dataformats::FileMetaData;
 using SubSpecificationType = DataAllocator::SubSpecificationType;
 using DetID = o2::detectors::DetID;
 
+enum class BranchType {
+  Krypton,
+  Digits,
+};
+
+const std::unordered_map<std::string, BranchType> BranchTypeMap{
+  {"krypton", BranchType::Krypton},
+  {"digits", BranchType::Digits},
+};
+
+const std::unordered_map<BranchType, std::string> BranchName{
+  {BranchType::Krypton, "TPCBoxCluster"},
+  {BranchType::Digits, "TPCDigit"},
+};
+
+const std::unordered_map<BranchType, std::string> TreeName{
+  {BranchType::Krypton, "Clusters"},
+  {BranchType::Digits, "o2sim"},
+};
+
 namespace o2::tpc
 {
 
 class FileWriterDevice : public Task
 {
  public:
-  FileWriterDevice() = default;
+  FileWriterDevice(const std::string branchType)
+  {
+    try {
+      mBranchType = BranchTypeMap.at(branchType);
+    } catch (std::out_of_range&) {
+      throw std::invalid_argument(std::string("invalid writer-type type: ") + branchType);
+    }
+  }
 
   void init(InitContext& ic) final
   {
@@ -68,6 +95,22 @@ class FileWriterDevice : public Task
     }
   }
 
+  template <typename T>
+  void fillBranch(int sector, InputRecord& inputs, const DataRef& inputRef)
+  {
+    auto inData = inputs.get<std::vector<T>>(inputRef);
+    auto dataPtr = &inData;
+
+    if (!mDataBranches[sector]) {
+      mDataBranches[sector] = mTreeOut->Branch(fmt::format("{}_{}", BranchName.at(mBranchType), sector).data(), &inData);
+    } else {
+      mDataBranches[sector]->SetAddress(&dataPtr);
+    }
+
+    mDataBranches[sector]->Fill();
+    mDataBranches[sector]->ResetAddress();
+  }
+
   void run(ProcessingContext& pc) final
   {
     const std::string NAStr = "NA";
@@ -79,8 +122,6 @@ class FileWriterDevice : public Task
     mPresentTF = dh->tfCounter;
     mFirstTForbit = dh->firstTForbit;
 
-    LOGP(info, "run: {}, TF: {}, Orbit: {} ({}), info branches: {}", mRun, mPresentTF, mFirstTForbit, oldOrbit, mInfoBranches.size());
-
     auto oldEnv = mEnvironmentID;
     {
       auto envN = pc.services().get<RawDeviceService>().device()->fConfig->GetProperty<std::string>("environment_id", NAStr);
@@ -92,6 +133,7 @@ class FileWriterDevice : public Task
       LOGP(WARNING, "RunNumber/Environment changed from {}/{} to {}/{}", oldRun, oldEnv, mRun, mEnvironmentID);
       closeTreeAndFile();
     }
+
     // check for the LHCPeriod
     if (mLHCPeriod.empty()) {
       auto LHCPeriodStr = pc.services().get<RawDeviceService>().device()->fConfig->GetProperty<std::string>("LHCPeriod", NAStr);
@@ -112,13 +154,11 @@ class FileWriterDevice : public Task
 
       for (auto br : mInfoBranches) {
         br->Fill();
-        LOGP(info, "Filling branch {}", br->GetName());
       }
       mTFOrbits.push_back(mFirstTForbit);
       ++mNTFs;
     }
 
-    bool hasData = false;
     for (auto const& inputRef : InputRecordWalker(pc.inputs())) {
       auto const* sectorHeader = DataRefUtils::getHeader<TPCSectorHeader*>(inputRef);
       if (sectorHeader == nullptr) {
@@ -127,30 +167,12 @@ class FileWriterDevice : public Task
       }
 
       const int sector = sectorHeader->sector();
-      auto inData = pc.inputs().get<std::vector<o2::tpc::KrCluster>>(inputRef);
-      auto dataPtr = &inData;
-
-      if (!mDataBranches[sector]) {
-        mDataBranches[sector] = mTreeOut->Branch(fmt::format("TPCBoxCluster_{}", sector).data(), &inData);
-      } else {
-        mDataBranches[sector]->SetAddress(&dataPtr);
+      if (mBranchType == BranchType::Krypton) {
+        fillBranch<KrCluster>(sector, pc.inputs(), inputRef);
+      } else if (mBranchType == BranchType::Digits) {
+        fillBranch<Digit>(sector, pc.inputs(), inputRef);
       }
-      mDataBranches[sector]->Fill();
-      mDataBranches[sector]->ResetAddress();
-
-      LOGP(info, "getting data for sector {}", sector);
-      hasData = true;
     }
-
-    //if (hasData && mTreeOut) {
-    //LOGP(info, "fill tree");
-    //mTreeOut->Fill();
-    //}
-    //for (auto br : mDataBranches) {
-    //if (br) {
-    //br->ResetAddress();
-    //}
-    //}
   }
 
   void endOfStream(EndOfStreamContext& ec) final
@@ -185,6 +207,7 @@ class FileWriterDevice : public Task
   bool mStoreMetaFile = false;                             ///< store the meata data file?
   bool mWrite = true;                                      ///< write data
   bool mCreateRunEnvDir = true;                            ///< create the output directory structure?
+  BranchType mBranchType;                                  ///< output branch type
 
   static constexpr std::string_view TMPFileEnding{".part"};
 
@@ -232,17 +255,11 @@ void FileWriterDevice::prepareTreeAndFile(const o2::header::DataHeader* dh)
     mCurrentFileName = o2::base::NameConf::getCTFFileName(mRun, dh->firstTForbit, dh->tfCounter, "tpc_krypton");
     mCurrentFileNameFull = fmt::format("{}{}", ctfDir, mCurrentFileName);
     mFileOut.reset(TFile::Open(fmt::format("{}{}", mCurrentFileNameFull, TMPFileEnding).c_str(), "recreate")); // to prevent premature external usage, use temporary name
-    mTreeOut = std::make_unique<TTree>("Clusters", "O2 tree");
+    mTreeOut = std::make_unique<TTree>(TreeName.at(mBranchType).data(), "O2 tree");
     mInfoBranches.emplace_back(mTreeOut->Branch("run", &mRun));
     mInfoBranches.emplace_back(mTreeOut->Branch("tfCounter", &mPresentTF));
     mInfoBranches.emplace_back(mTreeOut->Branch("firstOrbit", &mFirstTForbit));
     LOGP(info, "created {} info branches", mInfoBranches.size());
-    //for (int iSec = 0; iSec < Sector::MAXSECTOR; ++iSec) {
-    //std::vector<KrCluster> clusters;
-    //LOGP(info, "creating branch for sector {} on tree {} with name {}", iSec, (void*)mTreeOut.get(), fmt::format("TPCBoxCluster_{}", iSec).data());
-    //mDataBranches[iSec] = mTreeOut->Branch(fmt::format("TPCBoxCluster_{}", iSec).data(), &clusters);
-    //mDataBranches[iSec]->ResetAddress();
-    //}
     if (mStoreMetaFile) {
       mFileMetaData = std::make_unique<o2::dataformats::FileMetaData>();
     }
@@ -302,13 +319,13 @@ void FileWriterDevice::closeTreeAndFile()
   //removeLockFile();
 }
 
-DataProcessorSpec getFileWriterSpec(const std::string inputSpec)
+DataProcessorSpec getFileWriterSpec(const std::string inputSpec, const std::string branchType)
 {
   return DataProcessorSpec{
     "file-writer",
     select(inputSpec.data()),
     Outputs{},
-    AlgorithmSpec{adaptFromTask<FileWriterDevice>()},
+    AlgorithmSpec{adaptFromTask<FileWriterDevice>(branchType)},
     Options{
       {"output-dir", VariantType::String, "none", {" output directory, must exist"}},
       {"meta-output-dir", VariantType::String, "/dev/null", {" metadata output directory, must exist (if not /dev/null)"}},