CommonModeCorrection.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_CommonModeCorrection_H_
#define AliceO2_TPC_CommonModeCorrection_H_
 
#include <gsl/span>
#include <string_view>
#include <vector>
 
#include "DataFormatsTPC/Digit.h"
#include "TPCBase/FEEConfig.h"
 
namespace o2::tpc
{
 
class CommonModeCorrection
{
 public:
  struct CMdata {
    std::vector<float> adcValues;
    std::vector<float> cmKValues;
    std::vector<float> pedestals;
 
    void resize(size_t newSize)
    {
      adcValues.resize(newSize);
      cmKValues.resize(newSize);
      pedestals.resize(newSize);
    }
 
    void clear()
    {
      adcValues.clear();
      cmKValues.clear();
      pedestals.clear();
    }
  };
 
  struct CMInfo {
    float cmValue{};        
    float cmValueStd{};     
    float cmValueCRU{};     
    float sumPos{};         
    float sumNeg{};         
    uint16_t nPadsUsed{};   
    uint16_t nNeg{};        
    uint16_t nOccupancy{};  
    uint16_t nSaturation{}; 
  };
 
  struct CMDebug {
    std::vector<uint8_t> nPadsOk{};
    std::vector<uint16_t> adcDist{};
  };
 
  using CalPadMapType = std::unordered_map<std::string, CalPad>;
 
  CMInfo getCommonMode(gsl::span<const float> values, gsl::span<const float> cmKValues, gsl::span<const float> pedestals, CMDebug* cmDebug = nullptr) const;
  CMInfo getCommonMode(const std::vector<float>& values, const std::vector<float>& cmKValues, const std::vector<float>& pedestals) const { return getCommonMode(gsl::span(values), gsl::span(cmKValues), gsl::span(pedestals)); }
 
  CMInfo getCommonMode(const CMdata& cmData) const { return getCommonMode(std::span(cmData.adcValues), std::span(cmData.cmKValues), std::span(cmData.pedestals)); }
 
  void setNPadsCompRandom(int n) { mNPadsCompRamdom = n; }
  int getNPadsCompRandom() const { return mNPadsCompRamdom; }
 
  void setNPadsCompMin(int n) { mNPadsCompMin = n; }
  int getNPadsCompMin() const { return mNPadsCompMin; }
 
  void setNPadsMinCM(int n) { mNPadsMinCM = n; }
  int getNPadsMinCM() const { return mNPadsMinCM; }
 
  void setQEmpty(float q) { mQEmpty = q; }
  float getQEmpty() const { return mQEmpty; }
 
  void setQComp(float q) { mQComp = q; }
  float getQComp() const { return mQComp; }
 
  void setQCompScaleThreshold(float q) { mQCompScaleThreshold = q; }
  float getQCompScaleThreshold() const { return mQCompScaleThreshold; }
 
  void setQCompScale(float q) { mQCompScale = q; }
  float getQCompScale() const { return mQCompScale; }
 
  void setSumPosThreshold(float threshold) { mSumPosThreshold = threshold; }
  float getSumPosThreshold() const { return mSumPosThreshold; }
 
  void setOccupancyThreshold(float threshold) { mOccupancyThreshold = threshold; }
  float getOccupancyThreshold() const { return mOccupancyThreshold; }
 
  void setPadMaps(CalPadMapType& padMaps) { mPadMaps = padMaps; }
 
  void loadCalPad(std::string_view fileName, std::string_view nameInFile, std::string_view namePadMap = "");
 
  void loadCMkValues(std::string_view fileName) { loadCalPad(fileName, "CMkValues"); }
 
  void loadPedestals(std::string_view fileName) { loadCalPad(fileName, "Pedestals"); }
 
  void setCalPad(const CalPad& calPad, std::string_view name) { mPadMaps[name.data()] = calPad; }
 
  float getCMkValue(int sector, int row, int pad) { return mPadMaps["CMkValues"].getValue(sector, row, pad); }
 
  float getPedestalValue(int sector, int row, int pad) { return mPadMaps["Pedestals"].getValue(sector, row, pad); }
 
  void
    loadDefaultPadMaps(FEEConfig::Tags feeTag = FEEConfig::Tags::Physics30sigma);
 
  CMdata collectCMdata(const std::vector<Digit>& digits, int cru, int timeBin);
 
  int getCommonMode(std::vector<Digit>& digits, std::vector<std::vector<CMInfo>>& cmValues, bool negativeOnly = false, bool hasInjectedCMValue = false, std::vector<std::vector<CMDebug>>* cmDebug = nullptr, int minTimeBin = -1, int maxTimeBin = -1) const;
 
  int correctDigits(std::vector<Digit>& digits, std::vector<std::vector<CMInfo>>& cmValues, bool negativeOnly = false, bool hasInjectedCMValue = false, std::vector<std::vector<CMDebug>>* cmDebug = nullptr, int minTimeBin = -1, int maxTimeBin = -1) const;
 
  void correctDigits(std::string_view digiFileIn, Long64_t maxEntries = -1, std::string_view digitFileOut = "tpcdigit_cmcorr.root", std::string_view cmFileOut = "CommonModeValues.root", bool negativeOnly = false, int nThreads = 1, bool writeOnlyCM = false, bool writeDebug = false, bool hasInjectedCMValue = false, int minTimeBin = -1, int maxTimeBin = -1);
 
  void limitKFactorPrecision(bool limit = true) { mLimitKFactor = limit; }
  void limitPedestalPrecision(bool limit = true) { mLimitPedestal = limit; }
 
  static void setNThreads(const int nThreads) { sNThreads = nThreads; }
 
  static int getNThreads() { return sNThreads; }
 
  void addCommonMode(float cm) { mArtificialCM = cm; }
 
  void setCorrectOutputForPedestal(bool corret = true) { mCorrectOutputForPedestal = corret; }
  bool getCorrectOutputForPedestal() const { return mCorrectOutputForPedestal; }
 
  void setAddSubthreshold(bool addSubthreshold) { mSubthreshold = addSubthreshold; }
  bool getAddSubthreshold() const { return mSubthreshold; }
 
  static float decodeInjectedCMValue(float lower, float upper);
 
 private:
  inline static int sNThreads{1};        
  int mNPadsCompRamdom{10};              
  int mNPadsCompMin{7};                  
  int mNPadsMinCM{0};                    
  float mQEmpty{2};                      
  float mQComp{1};                       
  float mQCompScaleThreshold{0};         
  float mQCompScale{0};                  
  float mSumPosThreshold{2};             
  float mOccupancyThreshold{3};          
  bool mLimitKFactor{false};             
  bool mLimitPedestal{false};            
  int mSubthreshold{0};                  
  float mArtificialCM{};                 
  bool mCorrectOutputForPedestal{false}; 
 
  CalPadMapType mPadMaps; 
 
  struct pos {
    int row;
    int pad;
  };
 
  // positions of lower words per CRU in sector
  const std::array<pos, 10> mCMInjectIDLower{
    // row0 pad0 row1 pad1
    pos{0, 2},
    pos{20, 1},
    pos{32, 2},
    pos{51, 1},
    pos{63, 1},
    pos{84, 1},
    pos{97, 1},
    pos{116, 2},
    pos{127, 2},
    pos{142, 0},
  };
 
  // positions of upper words per CRU in sector
  const std::array<pos, 10> mCMInjectIDUpper{
    // row0 pad0 row1 pad1
    pos{0, 3},
    pos{20, 3},
    pos{32, 3},
    pos{51, 3},
    pos{63, 2},
    pos{84, 4},
    pos{97, 2},
    pos{115, 5},
    pos{127, 3},
    pos{142, 4},
  };
 
  float getCalPadValue(const std::string calibName, int icru, int pad) const;
 
  bool padMapExists(const std::string& calibName);
 
  ClassDefNV(CommonModeCorrection, 2);
};
 
} // namespace o2::tpc
#endif