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 <array>
 
#include <Rtypes.h>
#include "ITSMFTSimulation/AlpideSignalTrapezoid.h"
#include "ITSMFTSimulation/AlpideSimResponse.h"
#include "TRKBase/AlmiraParam.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; }
 
  int getROFrameLengthInBC(int layer) const { return mROFrameLayerLengthInBC[layer]; }
  void setROFrameLengthInBC(int n, int layer) { mROFrameLayerLengthInBC[layer] = n; }
 
  void setROFrameLength(float ns, int layer);
  float getROFrameLength(int layer) const { return mROFrameLayerLength[layer]; }
  float getROFrameLengthInv(int layer) const { return mROFrameLayerLengthInv[layer]; }
 
  void setStrobeDelay(float ns, int layer) { mStrobeLayerDelay[layer] = ns; }
  float getStrobeDelay(int layer) const { return mStrobeLayerDelay[layer]; }
 
  void setStrobeLength(float ns, int layer) { mStrobeLayerLength[layer] = ns; }
  float getStrobeLength(int layer) const { return mStrobeLayerLength[layer]; }
 
  void setTimeOffset(double sec) { mTimeOffset = sec; }
  double getTimeOffset() const { return mTimeOffset; }
 
  void setROFrameBiasInBC(int n, int layer) { mROFrameLayerBiasInBC[layer] = n; }
  int getROFrameBiasInBC(int layer) const { return mROFrameLayerBiasInBC[layer]; }
 
  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* getResponse() const { return mResponse.get(); }
  void setResponse(const o2::itsmft::AlpideSimResponse*);
 
  const SignalShape& getSignalShape() const { return mSignalShape; }
  SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
 
  virtual void print() const;
 
 private:
  static constexpr double infTime = 1e99;
  float mNoisePerPixel = 1.e-7;          
  double mTimeOffset = -2 * infTime;     
  int mChargeThreshold = 75;             
  int mMinChargeToAccount = 7;           
  int mNSimSteps = 475;                  
  float mNSimStepsInv = 1. / mNSimSteps; 
 
  float mEnergyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
 
  float mVbb = 0.0;   
  float mIBVbb = 0.0; 
  float mOBVbb = 0.0; 
 
  std::array<int, o2::trk::AlmiraParam::getNLayers()> mROFrameLayerLengthInBC; 
  std::array<int, o2::trk::AlmiraParam::getNLayers()> mROFrameLayerBiasInBC;   
  std::array<float, o2::trk::AlmiraParam::getNLayers()> mROFrameLayerLength;   
  std::array<float, o2::trk::AlmiraParam::getNLayers()> mStrobeLayerLength;    
  std::array<float, o2::trk::AlmiraParam::getNLayers()> mStrobeLayerDelay;     
 
  o2::itsmft::AlpideSignalTrapezoid mSignalShape; 
 
  std::unique_ptr<o2::trk::ChipSimResponse> mResponse; 
 
  // auxiliary precalculated parameters
  std::array<float, o2::trk::AlmiraParam::getNLayers()> mROFrameLayerLengthInv; 
 
  //   ClassDef(DigiParams, 2);
};
} // namespace trk
} // namespace o2
 
#endif