DigitGlobalPad.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_DigitGlobalPad_H_
#define ALICEO2_TPC_DigitGlobalPad_H_
 
#include <map>
#include <vector>
#include <fmt/format.h>
 
#include "TTree.h" // for TTree destructor
 
#include "SimulationDataFormat/MCCompLabel.h"
#include "SimulationDataFormat/MCTruthContainer.h"
#include "SimulationDataFormat/LabelContainer.h"
#include "CommonUtils/DebugStreamer.h"
#include "DataFormatsTPC/Defs.h"
#include "DataFormatsTPC/Digit.h"
#include "TPCBase/Mapper.h"
#include "TPCBase/Sector.h"
#include "TPCBase/CalDet.h"
#include "TPCBase/IonTailSettings.h"
#include "TPCSimulation/SAMPAProcessing.h"
 
namespace o2::tpc
{
 
struct PrevDigitInfo {
  float signal{}; 
  float cumul{};  
  int tot{};      
 
  bool hasSignal() const { return signal != 0 || cumul != 0 || tot != 0; }
 
  ClassDefNV(PrevDigitInfo, 1);
};
 
 
class DigitGlobalPad
{
 public:
  using Streamer = o2::utils::DebugStreamer;
 
  DigitGlobalPad() = default;
 
  ~DigitGlobalPad() = default;
 
  void reset();
 
  float getChargePad() const { return mChargePad; }
 
  void addDigit(const MCCompLabel& label, float signal,
                o2::dataformats::LabelContainer<std::pair<MCCompLabel, int>, false>&);
 
  void foldSignal(PrevDigitInfo& prevDigit, const int sector, const int pad, const TimeBin time, Streamer* debugStream = nullptr, const CalPad* padParams[3] = nullptr);
 
  void setID(int id) { mID = id; }
  int getID() const { return mID; }
 
  template <DigitzationMode MODE>
  void fillOutputContainer(std::vector<Digit>& output, dataformats::MCTruthContainer<MCCompLabel>& mcTruth,
                           const CRU& cru, TimeBin timeBin,
                           GlobalPadNumber globalPad,
                           o2::dataformats::LabelContainer<std::pair<MCCompLabel, int>, false>& labelContainer,
                           float commonMode = 0.f, const PrevDigitInfo& prevDigit = PrevDigitInfo(), Streamer* debugStream = nullptr, const CalDet<bool>* deadMap = nullptr);
 
 private:
  bool compareMClabels(const MCCompLabel& label1, const MCCompLabel& label2) const;
 
  float mChargePad = 0.; 
  int mID = -1;          
};
 
inline void DigitGlobalPad::addDigit(const MCCompLabel& label, float signal,
                                     o2::dataformats::LabelContainer<std::pair<MCCompLabel, int>, false>& labels)
{
  bool isKnown = false;
  auto view = labels.getLabels(mID);
  for (auto& mcLabel : view) {
    if (compareMClabels(label, mcLabel.first)) {
      ++mcLabel.second;
      isKnown = true;
      break;
    }
  }
 
  //
  if (!isKnown) {
    std::pair<MCCompLabel, int> newlabel(label, 1);
    labels.addLabel(mID, newlabel);
  }
  mChargePad += signal;
}
 
inline void DigitGlobalPad::foldSignal(PrevDigitInfo& prevDigit, const int sector, const int pad, const TimeBin time, Streamer* debugStream, const CalPad* padParams[3])
{
  const auto& eleParam = ParameterElectronics::Instance();
  const auto& itSettings = IonTailSettings::Instance();
  const float kAmp = (padParams[0]) ? padParams[0]->getValue(sector, pad) * itSettings.ITMultFactor : itSettings.ITMultFactor * 0.1276;
  const float expLambda = (padParams[1]) ? padParams[1]->getValue(sector, pad) : std::exp(-itSettings.kTime);
  const PrevDigitInfo prevDigInf = prevDigit;
 
  // Saturation tail simulation
  if (eleParam.doSaturationTail) {
    if (prevDigit.signal > 1023.f) {
      prevDigit.tot += int(std::round(mChargePad * eleParam.adcToT));
    }
    if (prevDigit.tot > 0) {
      prevDigit.tot -= 1;
    }
  }
 
  // ion tail simulation
  // not done in case we are in the saturation tail
  float modCharge = mChargePad;
  if ((prevDigit.tot == 0) && (eleParam.doIonTail || eleParam.doIonTailPerPad)) {
    modCharge = mChargePad + kAmp * (1 - expLambda) * prevDigit.cumul;
    prevDigit.cumul += prevDigInf.signal;
    prevDigit.cumul *= expLambda;
    if (prevDigit.cumul < 0.1) {
      prevDigit.cumul = 0;
    }
  }
  prevDigit.signal = modCharge;
 
  if (debugStream && Streamer::checkStream(o2::utils::StreamFlags::streamDigitFolding)) {
    // debugStream->setStreamer("debug_digits", "UPDATE");
    float kAmpTmp = kAmp;
    float tailSlopeUnitTmp = expLambda;
    float cmKValue = (padParams[2]) ? padParams[2]->getValue(sector, pad) : 1.f;
    int sec = sector;
    int padn = pad;
    unsigned int timeBin = time;
    PrevDigitInfo prevDigInfTmp = prevDigInf;
 
    // debugStream->getStreamer() << debugStream->getUniqueTreeName("foldSignal").data()
    debugStream->getStreamer() << "foldSignal"
                               << "sector=" << sec
                               << "pad=" << padn
                               << "timeBin=" << timeBin
                               << "kAmp=" << kAmpTmp
                               << "tailSlopeUnit=" << tailSlopeUnitTmp
                               << "cmKValue=" << cmKValue
                               << "charge=" << mChargePad
                               << "prevDig=" << prevDigInfTmp
                               << "dig=" << prevDigit
                               << "\n";
  }
 
  mChargePad = modCharge;
 
  // TODO: propagate labels for ion tail?
}
 
inline void DigitGlobalPad::reset()
{
  mChargePad = 0;
}
 
inline bool DigitGlobalPad::compareMClabels(const MCCompLabel& label1, const MCCompLabel& label2) const
{
  // we compare directly on the bare label (in which eventID, labelID etc. are encoded)
  // this avoids any logical operator on the label; optimization motivated from an Intel VTune analysis
  // (note that this is also faster than using the operator= of MCCompLabel)
  return label1.getRawValue() == label2.getRawValue();
}
 
template <DigitzationMode MODE>
inline void DigitGlobalPad::fillOutputContainer(std::vector<Digit>& output,
                                                dataformats::MCTruthContainer<MCCompLabel>& mcTruth,
                                                const CRU& cru, TimeBin timeBin,
                                                GlobalPadNumber globalPad,
                                                o2::dataformats::LabelContainer<std::pair<MCCompLabel, int>, false>& labels,
                                                float commonMode, const PrevDigitInfo& prevDigit, Streamer* debugStream, const CalDet<bool>* deadMap)
{
  const Mapper& mapper = Mapper::instance();
  SAMPAProcessing& sampaProcessing = SAMPAProcessing::instance();
  const PadPos pad = mapper.padPos(globalPad);
  static std::vector<std::pair<MCCompLabel, int>> labelCollector; // static workspace container for sorting
 
 
  float noise, pedestal;
  const float mADC = sampaProcessing.makeSignal<MODE>(mChargePad, cru.sector(), globalPad, commonMode, pedestal, noise, prevDigit.tot);
  const bool isDead = (deadMap == nullptr) ? false : deadMap->getValue(cru.sector(), globalPad);
 
  if (debugStream && Streamer::checkStream(o2::utils::StreamFlags::streamDigits)) {
    int sector = cru.sector();
    float adc = mADC;
    PrevDigitInfo prevDigitTmp = prevDigit;
    // debugStream->getStreamer() << debugStream->getUniqueTreeName("digit").data()
    debugStream->getStreamer() << "digit"
                               << "sector=" << sector
                               << "pad=" << globalPad
                               << "timeBin=" << timeBin
                               << "charge=" << mChargePad
                               << "adc=" << adc
                               << "prevDig=" << prevDigitTmp
                               << "cm=" << commonMode
                               << "isDead=" << isDead
                               << "\n";
  }
 
  if (!isDead && (mADC > 0)) {
 
    const auto digiPos = output.size();
    output.emplace_back(cru, mADC, pad.getRow(), pad.getPad(), timeBin); 
 
    // if no id was assigned the digit is from IT, CM or saturation
    if (mID == -1) {
      mcTruth.addNoLabelIndex(digiPos);
    } else {
      auto labelview = labels.getLabels(mID);
      labelCollector.clear();
      for (auto& mcLabel : labelview) {
        labelCollector.push_back(mcLabel);
      }
      if (labelview.size() > 1) {
        using P = std::pair<MCCompLabel, int>;
        std::sort(labelCollector.begin(), labelCollector.end(), [](const P& a, const P& b) { return a.second > b.second; });
      }
      for (auto& mcLabel : labelCollector) {
        mcTruth.addElement(digiPos, mcLabel.first); 
      }
    }
  }
}
} // namespace o2::tpc
 
#endif // ALICEO2_TPC_DigitGlobalPad_H_