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_IOTOF_DIGITIZER_H
#define ALICEO2_IOTOF_DIGITIZER_H
 
#include <vector>
#include <deque>
#include <memory>
 
#include <TH2D.h>
#include <Rtypes.h>  // for Digitizer::Class
#include <TObject.h> // for TObject
 
#include "ITSMFTSimulation/Hit.h"
#include "DataFormatsIOTOF/Digit.h"
#include "IOTOFSimulation/Chip.h"
#include "DataFormatsITSMFT/ROFRecord.h"
#include "CommonDataFormat/InteractionRecord.h"
#include "SimulationDataFormat/MCCompLabel.h"
#include "SimulationDataFormat/MCTruthContainer.h"
#include "IOTOFBase/GeometryTGeo.h"
#include "IOTOFBase/Segmentation.h"
 
namespace o2::iotof
{
 
class Digitizer : public TObject
{
 public:
  void setDigits(std::vector<o2::iotof::Digit>* dig) { mDigits = dig; }
  void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
  void setROFRecords(std::vector<o2::itsmft::ROFRecord>* rec) { mROFRecords = rec; }
 
  void init();
 
  void process(const std::vector<o2::itsmft::Hit>* hits, int evID, int srcID);
 
  void setEventTime(const o2::InteractionTimeRecord& irt) { mEventTime = irt; }
  void setROFRecordIR(const o2::InteractionRecord& ir) { mROFRecordIR = ir; }
 
  void setContinuous(bool v) { mContinuous = v; }
  bool isContinuous() const { return mContinuous; }
 
  void fillOutputContainer();
 
  // Provide the common iotof::GeometryTGeo to access matrices and segmentation
  void setGeometry(const o2::iotof::GeometryTGeo* gm) { mGeometry = gm; }
 
 private:
  void processHit(const o2::itsmft::Hit& hit, int evID, int srcID);
 
  void registerDigits(Chip& chip, uint32_t roFrame, double time, int nROF,
                      uint16_t row, uint16_t col, int nElectrons, o2::MCCompLabel& label);
 
  void stepping(const o2::itsmft::Hit& hit, float**& respMatrix, float**& avgHitLocalX, float**& avgHitLocalZ, int& rowStart, int& colStart, int& rowSpan, int& colSpan);
 
  double smearTime(double time, const float x, const float z) const;
 
  int energyToCharge(float energyLoss) const;
 
  void loadMap(TH2D*& map, const std::string& path, const char* mapName);
 
  void prepareScaledResolutionMap();
 
  bool isEfficient(const float x, const float z) const;
 
  std::vector<o2::iotof::McLabelRef>* getExtraLabelBuffer(uint32_t roFrame)
  {
    // if (mROFrameMin > roFrame) {
    //   return nullptr; // nothing to do
    // }
    // int index = roFrame - mROFrameMin;
 
    int index = roFrame;
    while (index >= int(mExtraLabelBuffer.size())) {
      mExtraLabelBuffer.emplace_back(std::make_unique<std::vector<o2::iotof::McLabelRef>>());
    }
    return mExtraLabelBuffer[index].get();
  }
 
  static constexpr float ps2ns = 1e-3f; 
  static constexpr float sec2ns = 1e9f; 
  static constexpr float cm2um = 1e4f;  
 
  const o2::iotof::GeometryTGeo* mGeometry = nullptr; 
  TH2D* mEfficiencyMap = nullptr;                     
  TH2D* mResolutionMap = nullptr;                     
  TH2D* mScaledResolutionMap = nullptr;               
  TH2D* mTimeOfArrivalMap = nullptr;                  
 
  std::vector<o2::iotof::Chip> mChips;                                               
  std::deque<std::unique_ptr<std::vector<o2::iotof::McLabelRef>>> mExtraLabelBuffer; 
 
  std::vector<o2::iotof::Digit>* mDigits = nullptr;                        
  std::vector<o2::itsmft::ROFRecord>* mROFRecords = nullptr;               
  o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mMCLabels = nullptr; 
 
  o2::InteractionTimeRecord mEventTime; 
  o2::InteractionRecord mROFRecordIR;   
  bool mContinuous = true;              
 
  static o2::iotof::Segmentation* sSegmentation; 
 
  ClassDefNV(Digitizer, 1);
};
} // namespace o2::iotof
 
#endif