DigitTime.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_DigitTime_H_
#define ALICEO2_TPC_DigitTime_H_
 
#include "TPCBase/Mapper.h"
#include "TPCBase/CalDet.h"
#include "TPCSimulation/DigitGlobalPad.h"
#include "SimulationDataFormat/LabelContainer.h"
#include "CommonUtils/DebugStreamer.h"
#include "TPCSimulation/CommonMode.h"
 
namespace o2::tpc
{
 
class Digit;
 
 
class DigitTime
{
 public:
  using Streamer = o2::utils::DebugStreamer;
  using PrevDigitInfoArray = std::array<PrevDigitInfo, Mapper::getPadsInSector()>;
 
  DigitTime();
 
  ~DigitTime() = default;
 
  void reset();
 
  float getCommonMode(const GEMstack& gemstack) const;
 
  float getCommonMode(const CRU& cru) const { return getCommonMode(cru.gemStack()); }
 
  void addDigit(const MCCompLabel& label, const CRU& cru, GlobalPadNumber globalPad, float signal);
 
  template <DigitzationMode MODE>
  void fillOutputContainer(std::vector<Digit>& output, dataformats::MCTruthContainer<MCCompLabel>& mcTruth,
                           std::vector<CommonMode>& commonModeOutput, const Sector& sector, TimeBin timeBin,
                           PrevDigitInfoArray* prevTime = nullptr, Streamer* debugStream = nullptr,
                           const CalPad* itParams[2] = nullptr, const CalDet<bool>* deadMap = nullptr);
 
 private:
  std::array<float, GEMSTACKSPERSECTOR> mCommonMode;                 
  std::array<DigitGlobalPad, Mapper::getPadsInSector()> mGlobalPads; 
  int mDigitCounter = 0;                                             
 
  o2::dataformats::LabelContainer<std::pair<MCCompLabel, int>, false> mLabels;
  // std::deque<int> mOccupiedPads; // iterable container of occupied pads
};
 
inline DigitTime::DigitTime() : mCommonMode(), mGlobalPads()
{
  mCommonMode.fill(0.f);
  mLabels.reserve(Mapper::getPadsInSector() / 3);
}
 
inline void DigitTime::addDigit(const MCCompLabel& label, const CRU& cru, GlobalPadNumber globalPad, float signal)
{
  auto& paddigit = mGlobalPads[globalPad];
  if (paddigit.getID() == -1) {
    // this means we have a new digit
    paddigit.setID(mDigitCounter++);
    // could also register this pad in a vector of digits
  }
 
  // previous digit for CM and ToT calculation
  paddigit.addDigit(label, signal, mLabels);
  // mCommonMode[cru.gemStack()] += signal * 0.5; // TODO: Replace 0.5 by k-factor, take into account ion tail
}
 
inline void DigitTime::reset()
{
  for (auto& pad : mGlobalPads) {
    pad.reset();
  }
  mCommonMode.fill(0.f);
}
 
inline float DigitTime::getCommonMode(const GEMstack& gemstack) const
{
  const Mapper& mapper = Mapper::instance();
  const auto nPads = mapper.getNumberOfPads(gemstack);
  return mCommonMode[gemstack] / static_cast<float>(nPads);
}
 
template <DigitzationMode MODE>
inline void DigitTime::fillOutputContainer(std::vector<Digit>& output, dataformats::MCTruthContainer<MCCompLabel>& mcTruth,
                                           std::vector<CommonMode>& commonModeOutput, const Sector& sector, TimeBin timeBin,
                                           PrevDigitInfoArray* prevTime, Streamer* debugStream, const CalPad* padParams[3],
                                           const CalDet<bool>* deadMap)
{
  const auto& mapper = Mapper::instance();
  const auto& eleParam = ParameterElectronics::Instance();
 
  // at this point we only have the pure signals from tracks
  // loop over all pads to calculated ion tail, common mode and ToT for saturated signals
  for (size_t iPad = 0; iPad < mGlobalPads.size(); ++iPad) {
    auto& digit = mGlobalPads[iPad];
    if (prevTime) {
      auto& prevDigit = (*prevTime)[iPad];
      if (prevDigit.hasSignal()) {
        digit.foldSignal(prevDigit, sector.getSector(), iPad, timeBin, debugStream, padParams);
      }
      prevDigit.signal = digit.getChargePad(); // to make hasSignal() check work in next time bin
    }
    const CRU cru = mapper.getCRU(sector, iPad);
    const float cmKValue = (padParams[2]) ? padParams[2]->getValue(sector.getSector(), iPad) : 1.f;
    mCommonMode[cru.gemStack()] += digit.getChargePad() * eleParam.commonModeCoupling * cmKValue; // TODO: Add stack-by-stack variation?
  }
 
  // fill common mode output container
  for (size_t i = 0; i < mCommonMode.size(); ++i) {
    const float cm = getCommonMode(GEMstack(i));
    if (cm > 0.) {
      commonModeOutput.push_back({cm, timeBin, static_cast<unsigned char>(i)});
    }
  }
 
  for (size_t iPad = 0; iPad < mGlobalPads.size(); ++iPad) {
    auto& digit = mGlobalPads[iPad];
    if (eleParam.doNoiseEmptyPads || (digit.getChargePad() > 0.f)) {
      PrevDigitInfo prevDigit;
      if (prevTime) {
        prevDigit = (*prevTime)[iPad];
      }
      const CRU cru = mapper.getCRU(sector, iPad);
      digit.fillOutputContainer<MODE>(output, mcTruth, cru, timeBin, iPad, mLabels, getCommonMode(cru), prevDigit, debugStream, deadMap);
    }
  }
}
} // namespace o2::tpc
 
#endif // ALICEO2_TPC_DigitTime_H_