Digitizer.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_EMCAL_FEEDIGITIZER_H
#define ALICEO2_EMCAL_FEEDIGITIZER_H
 
#include <array>
#include <memory>
#include <unordered_map>
#include <vector>
#include <list>
 
#include "Rtypes.h"  // for Digitizer::Class, Double_t, ClassDef, etc
#include "TObject.h" // for TObject
#include "TRandom3.h"
 
#include "DataFormatsEMCAL/Constants.h"
#include "DataFormatsEMCAL/Digit.h"
#include "EMCALBase/Hit.h"
#include "EMCALSimulation/SimParam.h"
#include "EMCALSimulation/LabeledDigit.h"
#include "EMCALSimulation/DigitsWriteoutBuffer.h"
#include "SimulationDataFormat/MCTruthContainer.h"
#include "DataFormatsEMCAL/TriggerRecord.h"
#include "CommonUtils/TreeStreamRedirector.h"
 
namespace o2
{
namespace utils
{
class TreeStreamRedirector;
}
namespace emcal
{
 
class Digitizer : public TObject
{
 public:
  Digitizer() = default;
  ~Digitizer() override = default;
  Digitizer(const Digitizer&) = delete;
  Digitizer& operator=(const Digitizer&) = delete;
 
  void init();
  void clear();
 
  void flush() { mDigits.flush(); }
 
  void finish() { mDigits.finish(); }
 
  void process(const std::vector<LabeledDigit>& labeledDigit);
 
  void setEventTime(o2::InteractionTimeRecord record, bool trigger);
  double getTriggerTime() const { return mDigits.getTriggerTime(); }
  double getEventTime() const { return mDigits.getEventTime(); }
  bool isLive(double t) const { return mDigits.isLive(t); }
  bool isLive() const { return mDigits.isLive(); }
 
  void setDebugStreaming(bool doStreaming) { mEnableDebugStreaming = doStreaming; }
 
  // function returns true if the collision occurs 600ns before the readout window is open
  bool preTriggerCollision() const { return mDigits.preTriggerCollision(); }
 
  void fillOutputContainer(std::vector<Digit>& digits, o2::dataformats::MCTruthContainer<o2::emcal::MCLabel>& labels);
 
  bool doSmearEnergy() const { return mSmearEnergy; }
  double smearEnergy(double energy);
  double smearTime(double time, double energy);
  bool doSimulateTimeResponse() const { return mSimulateTimeResponse; }
 
  void sampleSDigit(const Digit& sdigit);
 
  static double rawResponseFunction(double* x, double* par);
 
  const std::vector<o2::emcal::Digit>& getDigits() const { return mDigits.getDigits(); }
  const std::vector<o2::emcal::TriggerRecord>& getTriggerRecords() const { return mDigits.getTriggerRecords(); }
  const o2::dataformats::MCTruthContainer<o2::emcal::MCLabel>& getMCLabels() const { return mDigits.getMCLabels(); }
 
  static constexpr int getTOFSamplingBins() { return EMC_TOF_BINS; }
 
 private:
  using TimeSampleContainer = std::array<double, constants::EMCAL_MAXTIMEBINS>;
  static constexpr int EMC_PHASES = 4;                                                  
  static constexpr int EMC_TOF_BINS = 1500;                                             
  static constexpr double EMC_TOF_MIN = 0;                                              
  static constexpr double EMC_TOF_MAX = 1500.;                                          
  static constexpr double EMC_TOF_BINWITH = (EMC_TOF_MAX - EMC_TOF_MIN) / EMC_TOF_BINS; 
  short mEventTimeOffset = 0;                                                           
  short mPhase = 0;                                                                     
  UInt_t mROFrameMin = 0;                                                               
  UInt_t mROFrameMax = 0;                                                               
  bool mSmearEnergy = true;                                                             
  bool mSimulateTimeResponse = true;                                                    
  const SimParam* mSimParam = nullptr;                                                  
  bool mIsBeforeFirstRO = false;                                                        
  o2::InteractionRecord mIRFirstSampledTF;                                              
  double mTimeBCns;                                                                     
 
  std::vector<Digit> mTempDigitVector;     
  o2::emcal::DigitsWriteoutBuffer mDigits; 
 
  TRandom3* mRandomGenerator = nullptr; 
  std::array<std::array<TimeSampleContainer, EMC_TOF_BINS>, EMC_PHASES>
    mAmplitudeInTimeBins; 
 
  std::unique_ptr<o2::utils::TreeStreamRedirector> mDebugStream = nullptr;
  bool mEnableDebugStreaming = false;
 
  ClassDefOverride(Digitizer, 1);
};
} // namespace emcal
} // namespace o2
 
#endif /* ALICEO2_EMCAL_FEEDIGITIZER_H */