DigiReco.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.
 
#include <map>
#include <deque>
#include <gsl/span>
#include <TFile.h>
#include <TTree.h>
#include "Framework/Logger.h"
#include "ZDCBase/Constants.h"
#include "ZDCSimulation/ZDCSimParam.h"
#include "ZDCReconstruction/RecoParamZDC.h"
#include "ZDCReconstruction/ZDCTDCParam.h"
#include "ZDCReconstruction/ZDCTDCCorr.h"
#include "ZDCReconstruction/ZDCEnergyParam.h"
#include "ZDCReconstruction/ZDCTowerParam.h"
#include "ZDCReconstruction/BaselineParam.h"
#include "ZDCReconstruction/RecoConfigZDC.h"
#include "ZDCBase/ModuleConfig.h"
#include "CommonDataFormat/InteractionRecord.h"
#include "DataFormatsZDC/BCData.h"
#include "DataFormatsZDC/ChannelData.h"
#include "DataFormatsZDC/OrbitData.h"
#include "DataFormatsZDC/RecEvent.h"
#include "DataFormatsZDC/RecEventAux.h"
 
#ifndef ALICEO2_ZDC_DIGI_RECO_H
#define ALICEO2_ZDC_DIGI_RECO_H
 
//#define ALICEO2_ZDC_DIGI_RECO_DEBUG
#ifdef O2_ZDC_DEBUG
#ifndef ALICEO2_ZDC_DIGI_RECO_DEBUG
#define ALICEO2_ZDC_DIGI_RECO_DEBUG
#endif
#endif
 
namespace o2
{
namespace zdc
{
using O2_ZDC_DIGIRECO_FLT = float;
 
struct DigiRecoTDC {
  DigiRecoTDC(uint16_t myval, uint16_t myamp, o2::InteractionRecord myir)
  {
    val = myval;
    amp = myamp;
    ir = myir;
  }
  uint16_t val;
  uint16_t amp;
  o2::InteractionRecord ir;
};
 
class DigiReco
{
 public:
  DigiReco() = default;
  ~DigiReco() = default;
  void init();
  void prepareInterpolation();
  int process(const gsl::span<const o2::zdc::OrbitData>& orbitdata,
              const gsl::span<const o2::zdc::BCData>& bcdata,
              const gsl::span<const o2::zdc::ChannelData>& chdata);
  int write();
  void setVerbosity(int v)
  {
    mVerbosity = v;
  }
  int getVerbosity() const { return mVerbosity; }
  void setDebugOutput(bool state = true)
  {
    mTreeDbg = state;
  }
  void eor();
  uint8_t getTriggerCondition() { return mTriggerCondition; }
  void setTripleTrigger() { mTriggerCondition = 0x7; }
  void setDoubleTrigger() { mTriggerCondition = 0x3; }
  void setSingleTrigger() { mTriggerCondition = 0x1; }
 
  void setAlpha(double v) { mAlpha = v; };
  double getAlpha() { return mAlpha; };
 
  void setModuleConfig(const ModuleConfig* moduleConfig) { mModuleConfig = moduleConfig; };
  const ModuleConfig* getModuleConfig() { return mModuleConfig; };
  void setTDCParam(const ZDCTDCParam* param) { mTDCParam = param; };
  const ZDCTDCParam* getTDCParam() { return mTDCParam; };
  void setTDCCorr(const ZDCTDCCorr* param) { mTDCCorr = param; };
  const ZDCTDCCorr* getTDCCorr() { return mTDCCorr; };
  void setEnergyParam(const ZDCEnergyParam* param) { mEnergyParam = param; };
  const ZDCEnergyParam* getEnergyParam() { return mEnergyParam; };
  void setTowerParam(const ZDCTowerParam* param) { mTowerParam = param; };
  const ZDCTowerParam* getTowerParam() { return mTowerParam; };
  void setBaselineParam(const BaselineParam* param) { mPedParam = param; };
  const BaselineParam* getBaselineParam() { return mPedParam; };
  void setRecoConfigZDC(const RecoConfigZDC* cfg) { mRecoConfigZDC = cfg; };
  const RecoConfigZDC* getRecoConfigZDC() { return mRecoConfigZDC; };
  // Enable or disable low pass filtering
  void setLowPassFilter(bool val = true)
  {
    mLowPassFilter = val;
    mLowPassFilterSet = true;
    LOG(warn) << __func__ << " Configuration of low pass filtering: " << (mLowPassFilter ? "enabled" : "disabled");
  };
  bool getLowPassFilter() { return mLowPassFilter; };
  void setFullInterpolation(bool val = true)
  {
    mFullInterpolation = val;
    mFullInterpolationSet = true;
    LOG(warn) << __func__ << " Full waveform interpolation: " << (mFullInterpolation ? "enabled" : "disabled");
  };
  bool getFullInterpolation() { return mFullInterpolation; };
  // Enable or disable TDC corrections
  void setCorrSignal(bool val = true)
  {
    mCorrSignal = val;
    mCorrSignalSet = true;
    LOG(warn) << __func__ << " Configuration of TDC signal correction: " << (mCorrSignal ? "enabled" : "disabled");
  };
  bool getCorrSignal() { return mCorrSignal; };
  void setCorrBackground(bool val = true)
  {
    mCorrBackground = val;
    mCorrBackgroundSet = true;
    LOG(warn) << __func__ << " Configuration of TDC pile-up correction: " << (mCorrBackground ? "enabled" : "disabled");
  };
  bool getCorrBackground() { return mCorrBackground; };
  bool inError()
  {
    return mInError;
  }
 
  const uint32_t* getTDCMask() const { return mTDCMask; }
  const uint32_t* getChMask() const { return mChMask; }
  const std::vector<o2::zdc::RecEventAux>& getReco() { return mReco; }
 
 private:
  const ModuleConfig* mModuleConfig = nullptr;              
  void updateOffsets(int ibun);                             
  void lowPassFilter();                                     
  int reconstructTDC(int seq_beg, int seq_end);             
  int reconstruct(int seq_beg, int seq_end);                
  int processTrigger(int itdc, int ibeg, int iend);         
  int processTriggerExtended(int itdc, int ibeg, int iend); 
  int interpolate(int itdc, int ibeg, int iend);            
  int fullInterpolation(int itdc, int ibeg, int iend);      
  void correctTDCPile();                                    
  bool mLowPassFilter = true;                               
  bool mLowPassFilterSet = false;                           
  bool mFullInterpolation = false;                          
  bool mFullInterpolationSet = false;                       
  int mFullInterpolationMinLength = 2;                      
  int mInterpolationStep = 25;                              
  bool mCorrSignal = true;                                  
  bool mCorrSignalSet = false;                              
  bool mCorrBackground = true;                              
  bool mCorrBackgroundSet = false;                          
  bool mInError = false;                                    
  int mAssignedTDC[NTDCChannels] = {0};                     
 
  int correctTDCSignal(int itdc, int16_t TDCVal, float TDCAmp, float& fTDCVal, float& fTDCAmp, bool isbeg, bool isend); 
  int correctTDCBackground(int ibc, int itdc, std::deque<DigiRecoTDC>& tdc);                                            
 
  O2_ZDC_DIGIRECO_FLT getPoint(int itdc, int ibeg, int iend, int i); 
  void setPoint(int itdc, int ibeg, int iend, int i);                
 
  void assignTDC(int ibun, int ibeg, int iend, int itdc, int tdc, float amp); 
  void findSignals(int ibeg, int iend);                                       
  const RecoParamZDC* mRopt = nullptr;
  bool mIsContinuous = true;                     
  uint8_t mTriggerCondition = 0x3;               
  int mNBCAHead = 0;                             
  const ZDCTDCParam* mTDCParam = nullptr;        
  const ZDCTDCCorr* mTDCCorr = nullptr;          
  const ZDCEnergyParam* mEnergyParam = nullptr;  
  const ZDCTowerParam* mTowerParam = nullptr;    
  const BaselineParam* mPedParam = nullptr;      
  uint32_t mTriggerMask = 0;                     
  uint32_t mTDCMask[NTDCChannels] = {0};         
  uint32_t mChMask[NChannels] = {0};             
  const RecoConfigZDC* mRecoConfigZDC = nullptr; 
  int32_t mVerbosity = DbgMinimal;
  O2_ZDC_DIGIRECO_FLT mTS[NTS];                     
  bool mTreeDbg = false;                            
  std::unique_ptr<TFile> mDbg = nullptr;            
  std::unique_ptr<TTree> mTDbg = nullptr;           
  gsl::span<const o2::zdc::OrbitData> mOrbitData;   
  gsl::span<const o2::zdc::BCData> mBCData;         
  gsl::span<const o2::zdc::ChannelData> mChData;    
  std::vector<o2::zdc::RecEventAux> mReco;          
  std::map<uint32_t, int> mOrbit;                   
  float mOffset[NChannels];                         
  uint32_t mOffsetOrbit = 0xffffffff;               
  uint8_t mSource[NChannels];                       
  static constexpr int mNSB = TSN * NTimeBinsPerBC; 
  RecEventAux mRec;                                 
  int mNBC = 0;
  int mNLonely = 0;
  int mLonely[o2::constants::lhc::LHCMaxBunches] = {0};
  int mLonelyTrig[o2::constants::lhc::LHCMaxBunches] = {0};
  uint32_t mMissingPed[NChannels] = {0};
  int16_t tdc_shift[NTDCChannels] = {0};                           
  float tdc_calib[NTDCChannels] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};  
  float tdc_offset[NTDCChannels] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 
  constexpr static uint16_t mMask[NTimeBinsPerBC] = {0x0001, 0x002, 0x004, 0x008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 0x0200, 0x0400, 0x0800};
  O2_ZDC_DIGIRECO_FLT mAlpha = 3; // Parameter of interpolation function
  // Configuration of interpolation for current TDC
  int mNbun;  // Number of adjacent bunches
  int mNsam;  // Number of acquired samples
  int mNtot;  // Total number of points in the interpolated arrays
  int mIlast; // Index of last acquired sample
  int mNint;  // Total points in the interpolation region (-1)
  O2_ZDC_DIGIRECO_FLT mFirstSample;
  O2_ZDC_DIGIRECO_FLT mLastSample;
};
} // namespace zdc
} // namespace o2
#endif