DigitDump.h

Go to the documentation of this file.

// 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.
 
#ifndef ALICEO2_TPC_DIGITDUMP_H_
#define ALICEO2_TPC_DIGITDUMP_H_
 
 
#include <string>
#include <vector>
#include <array>
#include <algorithm>
#include <memory>
 
#include "Rtypes.h"
#include "TFile.h"
 
#include "DataFormatsTPC/Defs.h"
#include "TPCBase/CalDet.h"
#include "TPCBase/CRU.h"
#include "TPCBase/Sector.h"
#include "DataFormatsTPC/Digit.h"
#include "TPCCalibration/CalibRawBase.h"
 
class TTree;
 
namespace o2
{
namespace tpc
{
 
 
class DigitDump : public CalibRawBase
{
 public:
  DigitDump(PadSubset padSubset = PadSubset::ROC) : CalibRawBase(padSubset) {}
 
  void setDigitFileName(std::string_view fileName) { mDigitFile = fileName; }
 
  void setPedestalAndNoiseFile(std::string_view fileName) { mPedestalAndNoiseFile = fileName; }
 
  ~DigitDump() override;
 
  void init();
 
  Int_t updateROC(const Int_t roc, const Int_t row, const Int_t pad,
                  const Int_t timeBin, const Float_t signal) final { return 0; }
 
  Int_t updateCRU(const CRU& cru, const Int_t row, const Int_t pad,
                  const Int_t timeBin, const Float_t signal) final;
 
  void setPedestals(const CalPad* pedestal) { mPedestal.reset(pedestal); }
 
  void setNoise(const CalPad* noise) { mNoise.reset(noise); }
 
  const CalPad& getPedestal() const { return *mPedestal.get(); }
 
  const CalPad& getNoise() const { return *mNoise.get(); }
 
  void addPadMask(int roc, int row, int pad) { mPadMask.push_back({roc, row, pad}); }
 
  void setNoiseThreshold(float noiseThreshold) { mNoiseThreshold = noiseThreshold; }
 
  void setADCRange(float minADC, float maxADC)
  {
    mADCMin = minADC;
    mADCMax = maxADC;
  }
 
  void setTimeBinRange(int first, int last)
  {
    mFirstTimeBin = first;
    mLastTimeBin = last;
  }
 
  void sortDigits();
 
  void clearDigits()
  {
    for (auto& digits : mDigits) {
      digits.clear();
    }
 
    std::fill(mTimeBinOccupancy.begin(), mTimeBinOccupancy.end(), 0);
  }
 
  void setInMemoryOnly(bool mode = true) { mInMemoryOnly = mode; }
 
  bool getInMemoryMode() const { return mInMemoryOnly; }
 
  std::vector<Digit>& getDigits(int sector) { return mDigits[sector]; }
 
  const auto& getDigits() const { return mDigits; }
  auto& getDigits() { return mDigits; }
 
  void addDigit(const CRU& cru, const float signal, const int rowInSector, const int padInRow, const int timeBin)
  {
    mDigits[cru.sector()].emplace_back(cru, signal, rowInSector, padInRow, timeBin);
  }
 
  void initInputOutput();
 
  void endEvent() final;
 
  void checkDuplicates(bool removeDuplicates = false);
 
  void removeCEdigits(uint32_t removeNtimeBinsBefore = 10, uint32_t removeNtimeBinsAfter = 100, std::array<std::vector<Digit>, Sector::MAXSECTOR>* removedDigits = nullptr);
 
 private:
  std::unique_ptr<const CalPad> mPedestal{}; 
  std::unique_ptr<const CalPad> mNoise{};    
 
  TTree* mTree{nullptr};          
  std::unique_ptr<TFile> mFile{}; 
 
  std::array<std::vector<Digit>, Sector::MAXSECTOR> mDigits; 
  std::string mDigitFile{};                                  
  std::string mPedestalAndNoiseFile{};                       
 
  std::vector<std::array<int, 3>> mPadMask; 
 
  std::vector<size_t> mTimeBinOccupancy; 
 
  int mFirstTimeBin{0};      
  int mLastTimeBin{1000};    
  float mADCMin{-100};       
  float mADCMax{1024};       
  float mNoiseThreshold{-1}; 
  bool mInMemoryOnly{false}; 
  bool mInitialized{false};  
 
  void setupOutputTree();
 
  void loadNoiseAndPedestal();
 
  void resetEvent() final {}
};
 
} // namespace tpc
 
} // namespace o2
#endif