DigitContainer.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_DigitContainer_H_
#define ALICEO2_TPC_DigitContainer_H_
 
#include <deque>
#include <algorithm>
#include "TPCBase/CRU.h"
#include "DataFormatsTPC/Defs.h"
#include "TPCSimulation/DigitTime.h"
#include "CommonUtils/DebugStreamer.h"
#include "TPCBase/ParameterDetector.h"
#include "TPCBase/ParameterElectronics.h"
#include "TPCBase/ParameterGas.h"
 
namespace o2::tpc
{
 
class Digit;
 
 
class DigitContainer
{
 public:
  DigitContainer();
 
  ~DigitContainer() = default;
 
  void reset();
 
  void reserve(TimeBin eventTimeBin);
 
  void setStartTime(TimeBin time) { mFirstTimeBin = time; }
 
  void addDigit(const MCCompLabel& label, const CRU& cru, TimeBin timeBin, GlobalPadNumber globalPad, float signal);
 
  void fillOutputContainer(std::vector<Digit>& output, dataformats::MCTruthContainer<MCCompLabel>& mcTruth, std::vector<CommonMode>& commonModeOutput, const Sector& sector, TimeBin eventTimeBin = 0, bool isContinuous = true, bool finalFlush = false);
 
  size_t size() const { return mTimeBins.size(); }
 
 private:
  TimeBin mFirstTimeBin = 0;                                  
  TimeBin mEffectiveTimeBin = 0;                              
  TimeBin mTmaxTriggered = 0;                                 
  TimeBin mOffset;                                            
  std::deque<DigitTime*> mTimeBins;                           
  std::unique_ptr<DigitTime::PrevDigitInfoArray> mPrevDigArr; 
  o2::utils::DebugStreamer mStreamer;                         
 
  void reportSettings();
};
 
inline DigitContainer::DigitContainer()
{
  auto& detParam = ParameterDetector::Instance();
  auto& gasParam = ParameterGas::Instance();
  auto& eleParam = ParameterElectronics::Instance();
  mTmaxTriggered = detParam.TmaxTriggered;
 
  // always have 50 % contingency for the size of the container depending on the input
  mOffset = static_cast<TimeBin>(detParam.TPCRecoWindowSim * detParam.TPClength / gasParam.DriftV / eleParam.ZbinWidth);
  mTimeBins.resize(mOffset, nullptr);
}
 
inline void DigitContainer::reset()
{
  mFirstTimeBin = 0;
  mEffectiveTimeBin = 0;
  for (auto& time : mTimeBins) {
    if (time) {
      time->reset();
    }
  }
  if (mPrevDigArr) {
    std::fill(mPrevDigArr->begin(), mPrevDigArr->end(), PrevDigitInfo{});
  }
}
 
inline void DigitContainer::reserve(TimeBin eventTimeBin)
{
  const auto space = mOffset + eventTimeBin - mFirstTimeBin;
  if (mTimeBins.size() < space) {
    mTimeBins.resize(space);
  }
}
 
inline void DigitContainer::addDigit(const MCCompLabel& label, const CRU& cru, TimeBin timeBin, GlobalPadNumber globalPad,
                                     float signal)
{
  mEffectiveTimeBin = timeBin - mFirstTimeBin;
  if (mEffectiveTimeBin >= mTimeBins.size()) {
    // LOG(warning) << "Out of bound access to digit container .. dropping digit";
    return;
  }
 
  if (mTimeBins[mEffectiveTimeBin] == nullptr) {
    mTimeBins[mEffectiveTimeBin] = new DigitTime();
  }
 
  mTimeBins[mEffectiveTimeBin]->addDigit(label, cru, globalPad, signal);
}
 
} // namespace o2::tpc
 
#endif // ALICEO2_TPC_DigitContainer_H_