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_TPC_Digitizer_H_
#define ALICEO2_TPC_Digitizer_H_
 
#include "TPCSimulation/DigitContainer.h"
#include "TPCSimulation/Point.h"
#include "TPCBase/Mapper.h"
 
#include <cmath>
 
class TTree;
class TH3;
 
namespace o2
{
namespace tpc
{
 
class DigitContainer;
 
template <class T>
class SpaceCharge;
 
enum class SCDistortionType : int;
 
 
class Digitizer
{
 public:
  using SC = SpaceCharge<float>;
 
  Digitizer();
 
  ~Digitizer();
 
  Digitizer(const Digitizer&) = delete;
  Digitizer& operator=(const Digitizer&) = delete;
 
  void init();
 
  void process(const std::vector<o2::tpc::HitGroup>& hits, const int eventID,
               const int sourceID = 0);
 
  void flush(std::vector<o2::tpc::Digit>& digits,
             o2::dataformats::MCTruthContainer<o2::MCCompLabel>& labels,
             std::vector<o2::tpc::CommonMode>& commonModeOutput, bool finalFlush = false);
 
  void setSector(Sector sec)
  {
    mSector = sec;
    mDigitContainer.reset();
  }
 
  void setStartTime(double time);
 
  void setOutputDigitTimeOffset(double offset) { mOutputDigitTimeOffset = offset; }
 
  void setEventTime(double time) { mEventTime = time; }
 
  void setContinuousReadout(bool isContinuous) { mIsContinuous = isContinuous; }
 
  bool isContinuousReadout() { return mIsContinuous; }
 
  void setUseSCDistortions(const SCDistortionType& distortionType, const TH3* hisInitialSCDensity);
  void setUseSCDistortions(SC* spaceCharge);
 
  void setSCDistortionsDerivative(SC* spaceCharge);
 
  void setUseSCDistortions(std::string_view finp);
 
  void setVDrift(float v) { mVDrift = v; }
  void setTDriftOffset(float t) { mTDriftOffset = t; }
 
  void setDistortionScaleType(int distortionScaleType) { mDistortionScaleType = distortionScaleType; }
  int getDistortionScaleType() const { return mDistortionScaleType; }
  void setLumiScaleFactor();
  void setMeanLumiDistortions(float meanLumi);
  void setMeanLumiDistortionsDerivative(float meanLumi);
 
  void recalculateDistortions();
 
 private:
  DigitContainer mDigitContainer;      
  std::unique_ptr<SC> mSpaceCharge;    
  std::unique_ptr<SC> mSpaceChargeDer; 
  Sector mSector = -1;                 
  double mEventTime = 0.f;             
  double mOutputDigitTimeOffset = 0;   
  float mVDrift = 0;                   
  float mTDriftOffset = 0;             
  bool mIsContinuous;                  
  bool mUseSCDistortions = false;      
  int mDistortionScaleType = 0;        
  float mLumiScaleFactor = 0;          
  bool mUseScaledDistortions = false;  
  ClassDefNV(Digitizer, 3);
};
} // namespace tpc
} // namespace o2
 
#endif // ALICEO2_TPC_Digitizer_H_