DEDigitizer.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 O2_MCH_SIMULATION_DE_DIGITIZER_H
#define O2_MCH_SIMULATION_DE_DIGITIZER_H
 
#include <map>
#include <random>
#include <utility>
#include <vector>
 
#include "DataFormatsMCH/Digit.h"
#include "CommonDataFormat/InteractionRecord.h"
#include "MathUtils/Cartesian.h"
#include "MCHMappingInterface/Segmentation.h"
#include "MCHSimulation/Hit.h"
#include "MCHSimulation/Response.h"
#include "SimulationDataFormat/MCCompLabel.h"
#include "SimulationDataFormat/MCTruthContainer.h"
 
namespace o2::mch
{
 
class DEDigitizer
{
 public:
  using DigitsAndLabels = std::pair<std::vector<Digit>, dataformats::MCLabelContainer>;
 
  DEDigitizer(int deId, math_utils::Transform3D transformation, std::mt19937& random);
 
  void setFirstTFOrbit(uint32_t firstTFOrbit) { mFirstTFOrbit = firstTFOrbit; }
 
  void processHit(const Hit& hit, const InteractionRecord& collisionTime, int evID, int srcID);
 
  void addNoise(const InteractionRecord& firstIR, const InteractionRecord& lastIR);
 
  size_t digitize(std::map<InteractionRecord, DigitsAndLabels>& irDigitsAndLabels);
 
  void clear();
 
 private:
  struct Signal {
    InteractionRecord rofIR;
    uint8_t bcInROF;
    float charge;
    std::vector<MCCompLabel> labels;
    Signal(const InteractionRecord& ir, uint8_t bc, float q, const MCCompLabel& label)
      : rofIR{ir}, bcInROF{bc}, charge{q}, labels{label} {}
  };
 
  void addSignal(int padid, const InteractionRecord& collisionTime, float charge, const MCCompLabel& label);
  void addNoise(int padid, const InteractionRecord& rofIR);
  void addNoise(Signal& signal, uint32_t nSamples);
  void addTimeDispersion(Signal& signal);
  bool isAboveThreshold(float charge);
  DigitsAndLabels* addNewDigit(std::map<InteractionRecord, DigitsAndLabels>& irDigitsAndLabels,
                               int padid, const Signal& signal, uint32_t nSamples) const;
  void appendLastDigit(DigitsAndLabels* digitsAndLabels, const Signal& signal, uint32_t nSamples) const;
 
  int mDeId;                                   
  Response mResponse;                          
  o2::math_utils::Transform3D mTransformation; 
  mapping::Segmentation mSegmentation;         
 
  std::mt19937& mRandom;                            
  std::normal_distribution<float> mMinChargeDist;   
  std::normal_distribution<float> mTimeDist;        
  std::normal_distribution<float> mNoiseDist;       
  std::normal_distribution<float> mNoiseOnlyDist;   
  std::poisson_distribution<int> mNofNoisyPadsDist; 
  std::uniform_int_distribution<int> mPadIdDist;    
  std::uniform_int_distribution<int> mBCDist;       
 
  uint32_t mFirstTFOrbit; 
 
  std::vector<std::vector<Signal>> mSignals; 
};
 
} // namespace o2::mch
 
#endif