DigiParams.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_TRK_DIGIPARAMS_H
#define ALICEO2_TRK_DIGIPARAMS_H
 
#include <Rtypes.h>
#include <ITSMFTSimulation/AlpideSignalTrapezoid.h>
#include "TRKBase/TRKBaseParam.h"
#include "TRKBase/GeometryTGeo.h"
 
//                                                        //
// Simulation params for the TRK digitizer                //
//                                                        //
// This is a provisionary implementation, until proper    //
// microscopic simulation and its configuration will      //
// be implemented                                         //
//                                                        //
 
namespace o2
{
namespace trk
{
 
class ChipSimResponse;
 
class DigiParams
{
 
  using SignalShape = o2::itsmft::AlpideSignalTrapezoid;
 
 public:
  DigiParams();
  ~DigiParams() = default;
 
  void setNoisePerPixel(float v) { mNoisePerPixel = v; }
  float getNoisePerPixel() const { return mNoisePerPixel; }
 
  void setContinuous(bool v) { mIsContinuous = v; }
  bool isContinuous() const { return mIsContinuous; }
 
  int getROFrameLengthInBC() const { return mROFrameLengthInBC; }
  void setROFrameLengthInBC(int n) { mROFrameLengthInBC = n; }
 
  void setROFrameLength(float ns);
  float getROFrameLength() const { return mROFrameLength; }
  float getROFrameLengthInv() const { return mROFrameLengthInv; }
 
  void setStrobeDelay(float ns) { mStrobeDelay = ns; }
  float getStrobeDelay() const { return mStrobeDelay; }
 
  void setStrobeLength(float ns) { mStrobeLength = ns; }
  float getStrobeLength() const { return mStrobeLength; }
 
  void setTimeOffset(double sec) { mTimeOffset = sec; }
  double getTimeOffset() const { return mTimeOffset; }
 
  void setROFrameBiasInBC(int n) { mROFrameBiasInBC = n; }
  int getROFrameBiasInBC() const { return mROFrameBiasInBC; }
 
  void setChargeThreshold(int v, float frac2Account = 0.1);
  void setNSimSteps(int v);
  void setEnergyToNElectrons(float v) { mEnergyToNElectrons = v; }
 
  void setVbb(float v) { mVbb = v; }
  void setIBVbb(float v) { mIBVbb = v; }
  void setOBVbb(float v) { mOBVbb = v; }
 
  int getChargeThreshold() const { return mChargeThreshold; }
  int getMinChargeToAccount() const { return mMinChargeToAccount; }
  int getNSimSteps() const { return mNSimSteps; }
  float getNSimStepsInv() const { return mNSimStepsInv; }
  float getEnergyToNElectrons() const { return mEnergyToNElectrons; }
 
  float getVbb() const { return mVbb; }
  float getIBVbb() const { return mIBVbb; }
  float getOBVbb() const { return mOBVbb; }
 
  bool isTimeOffsetSet() const { return mTimeOffset > -infTime; }
 
  const o2::trk::ChipSimResponse* getAlpSimResponse() const { return mAlpSimResponse; }
  void setAlpSimResponse(const o2::trk::ChipSimResponse* par) { mAlpSimResponse = par; }
 
  const SignalShape& getSignalShape() const { return mSignalShape; }
  SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
 
  virtual void print() const;
 
 private:
  static constexpr double infTime = 1e99;
  bool mIsContinuous = false;        
  float mNoisePerPixel = 1.e-8;      
  int mROFrameLengthInBC = 0;        
  float mROFrameLength = 0;          
  float mStrobeDelay = 0.;           
  float mStrobeLength = 0;           
  double mTimeOffset = -2 * infTime; 
  int mROFrameBiasInBC = 0;          
  int mChargeThreshold = 150;        
  int mMinChargeToAccount = 15;      
  int mNSimSteps = 18;               
  float mNSimStepsInv = 0;           
 
  float mEnergyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
 
  float mVbb = 0.0;   
  float mIBVbb = 0.0; 
  float mOBVbb = 0.0; 
 
  o2::itsmft::AlpideSignalTrapezoid mSignalShape; 
 
  const o2::trk::ChipSimResponse* mAlpSimResponse = nullptr; 
 
  // auxiliary precalculated parameters
  float mROFrameLengthInv = 0; 
 
  //   ClassDef(DigiParams, 2);
};
} // namespace trk
} // namespace o2
 
#endif