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_ITSMFT_DIGIPARAMS_H
#define ALICEO2_ITSMFT_DIGIPARAMS_H
 
#include <vector>
#include <algorithm>
#include <Rtypes.h>
#include "ITSMFTSimulation/AlpideSignalTrapezoid.h"
#include "ITSMFTBase/DPLAlpideParam.h"
 
//                                                        //
// Simulation params for Alpide chip                      //
//                                                        //
// This is a provisionary implementation, until proper    //
// microscopic simulation and its configuration will      //
// be implemented                                         //
//                                                        //
 
namespace o2
{
namespace itsmft
{
 
class AlpideSimResponse;
 
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(int layer = -1) const { return layer < 0 ? mROFrameLengthInBC : mROFrameLayerLengthInBC[layer]; }
  void setROFrameLengthInBC(int n, int layer = -1) { layer < 0 ? mROFrameLengthInBC = n : mROFrameLayerLengthInBC[layer] = n; }
 
  void setROFrameLength(float ns, int layer = -1);
  float getROFrameLength(int layer = -1) const { return layer < 0 ? mROFrameLength : mROFrameLayerLength[layer]; }
  float getROFrameLengthInv(int layer = -1) const { return layer < 0 ? mROFrameLengthInv : mROFrameLayerLengthInv[layer]; }
 
  void setStrobeDelay(float ns) { mStrobeDelay = ns; }
  float getStrobeDelay(int layer = -1) const { return layer < 0 ? mStrobeDelay : mStrobeLayerDelay[layer]; }
 
  void setStrobeLength(float ns) { mStrobeLength = ns; }
  float getStrobeLength(int layer = -1) const { return layer < 0 ? mStrobeLength : mStrobeLayerLength[layer]; }
 
  void setTimeOffset(double sec) { mTimeOffset = sec; }
  double getTimeOffset() const { return mTimeOffset; }
 
  void setROFrameBiasInBC(int n, int layer = -1) { layer < 0 ? mROFrameBiasInBC = n : mROFrameLayerBiasInBC[layer] = n; }
  int getROFrameBiasInBC(int layer = -1) const { return layer < 0 ? mROFrameBiasInBC : 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::itsmft::AlpideSimResponse* getAlpSimResponse() const { return mAlpSimResponse; }
  void setAlpSimResponse(const o2::itsmft::AlpideSimResponse* par) { mAlpSimResponse = par; }
 
  const SignalShape& getSignalShape() const { return mSignalShape; }
  SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
 
  bool withStaggering() const noexcept { return !mROFrameLayerLength.empty(); }
  void addROFrameLayerLengthInBC(int len) { mROFrameLayerLengthInBC.push_back(len); }
  void addROFrameLayerBiasInBC(int len) { mROFrameLayerBiasInBC.push_back(len); }
  void addStrobeLength(float ns) { mStrobeLayerLength.push_back(ns); }
  void addStrobeDelay(float ns) { mStrobeLayerDelay.push_back(ns); }
 
  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 = 7;                      
  float mEnergyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
 
  float mVbb = 0.0;   
  float mIBVbb = 0.0; 
  float mOBVbb = 0.0; 
 
  std::vector<int> mROFrameLayerLengthInBC; 
  std::vector<int> mROFrameLayerBiasInBC;   
  std::vector<float> mROFrameLayerLength;   
  std::vector<float> mStrobeLayerLength;    
  std::vector<float> mStrobeLayerDelay;     
 
  o2::itsmft::AlpideSignalTrapezoid mSignalShape; 
 
  const o2::itsmft::AlpideSimResponse* mAlpSimResponse = nullptr; 
 
  // auxiliary precalculated parameters
  float mROFrameLengthInv = 0;               
  std::vector<float> mROFrameLayerLengthInv; // inverse length of RO frame in ns per layer
  float mNSimStepsInv = 0;                   
 
  ClassDef(DigiParams, 3);
};
} // namespace itsmft
} // namespace o2
 
#endif