CDCDigitizerModule.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
//basf2 framework headers
#include <framework/core/Module.h>
#include <framework/datastore/StoreArray.h>
 
#include <simulation/dataobjects/SimClockState.h>
 
//cdc package headers
#include <mdst/dataobjects/MCParticle.h>
#include <cdc/dataobjects/CDCSimHit.h>
#include <cdc/dataobjects/CDCHit.h>
#include <cdc/dataobjects/WireID.h>
#include <cdc/geometry/CDCGeometryPar.h>
#include <cdc/geometry/CDCGeoControlPar.h>
#include <cdc/dbobjects/CDCFEElectronics.h>
#include <cdc/dbobjects/CDCDedxRunGain.h>
#include <cdc/dbobjects/CDCDedxScaleFactor.h>
#include <cdc/dbobjects/CDCDedxWireGain.h>
//#include <cdc/dbobjects/CDCEDepToADCConversions.h>
#include <cdc/dbobjects/CDCCrossTalkLibrary.h>
#include <cdc/dbobjects/CDCCorrToThresholds.h>
#include <cdc/dbobjects/CDCAlphaScaleFactorForAsymmetry.h>
 
//C++/C standard lib elements.
#include <string>
//#include <queue>
#include <limits>
 
namespace Belle2 {

  class CDCDigitizerModule : public Module {
 
  public:
    CDCDigitizerModule();

    void initialize() override;

    void event() override;

    void terminate() override
    {
      if (m_fEElectronicsFromDB) delete m_fEElectronicsFromDB;
      //      if (m_eDepToADCConversionsFromDB) delete m_eDepToADCConversionsFromDB;
      if (m_runGainFromDB) delete m_runGainFromDB;
      if (m_gain0FromDB) delete m_gain0FromDB;
      if (m_wireGainFromDB) delete m_wireGainFromDB;
      if (m_xTalkFromDB) delete m_xTalkFromDB;
      if (m_corrToThresholdFromDB) delete m_corrToThresholdFromDB;
    };
 
  private:
    double smearDriftLength(double driftLength, double dDdt);
 

    double getdDdt(double driftLength);
 

    double getDriftTime(double driftLength, bool addTof, bool addDelay);
 

    void makeSignalsAfterShapers(const WireID& wid, double edep, double dx, double costh, unsigned short& adcCount,
                                 double& convFactorForThreshold);

    double getPositiveT0(const WireID&);

    void setFEElectronics();

    double Polya(double xmax = 10);

    void setSemiTotalGain();


    double getSemiTotalGain(int clayer, int cell) const
    {
      return m_semiTotalGain[clayer][cell];
    }


    double getSemiTotalGain(const WireID& wireID) const
    {
      return m_semiTotalGain[wireID.getICLayer()][wireID.getIWire()];
    }

    void addXTalk();

    //    void setEDepToADCConversions();
 
    StoreArray<MCParticle> m_mcParticles; 
    StoreArray<CDCSimHit>  m_simHits;     
    StoreArray<CDCHit>     m_cdcHits;     
    StoreArray<CDCHit>     m_cdcHits4Trg; 
 
    std::string m_inputCDCSimHitsName;       
    std::string m_outputCDCHitsName;         
    std::string m_outputCDCHitsName4Trg;     
 
    std::string m_MCParticlesToSimHitsName;    
    std::string m_SimHitsTOCDCHitsName;      
 
    std::string m_OptionalFirstMCParticlesToHitsName;      
    std::string m_OptionalAllMCParticlesToHitsName;      
 
    bool m_useSimpleDigitization;            
    //--- Parameters for simple digitization -------------------------------------------------------------------------------------
    double m_fraction;          
    double m_mean1;             
    double m_resolution1;       
    double m_mean2;             
    double m_resolution2;       
    double m_tdcThreshold4Outer; 
    double m_tdcThreshold4Inner; 
    int    m_eDepInGasMode;     
    int    m_adcThreshold;      
    double m_tMin;              
    double m_tMaxOuter;         
    double m_tMaxInner;         
    //    unsigned short m_tdcOffset; /**< Offset of TDC count (in ns)*/
    double m_trigTimeJitter;   
 
    CDC::CDCGeometryPar* m_cdcgp;  
    CDC::CDCGeoControlPar* m_gcp;  
    CDCSimHit* m_aCDCSimHit;    
    WireID m_wireID;            
    unsigned short m_posFlag;   
    unsigned short m_boardID = 0; 
    B2Vector3D m_posWire;         
    B2Vector3D m_posTrack;        
    B2Vector3D m_momentum;        
    double m_driftLength;       
    double m_flightTime;        
    double m_globalTime;        
 
    double m_tdcBinWidth;       
    double m_tdcBinWidthInv;    
    double m_tdcResol;          
    double m_driftV;            
    double m_driftVInv;         
    double m_propSpeedInv;      
 
    double m_tdcThresholdOffset; 
    double m_analogGain;         
    double m_digitalGain;        
    double m_adcBinWidth;        
 
    double m_addFudgeFactorForSigma; 
    double m_totalFudgeFactor = 1.;  
 
    bool m_gasGainSmearing = true;  
    double m_effWForGasGainSmearing = 0.0266;  
    double m_thetaOfPolya = 0.5;     
    bool m_extraADCSmearing = false; 
    //    double m_sigmaForExtraADCSmearing = 0.3;  /**< Gaussian sigma for extra ADC smearing */
    double m_runGain = 1.;  
    float m_semiTotalGain[c_maxNSenseLayers][c_maxNDriftCells] = {{}}; 
    double m_overallGainFactor = 1.;  
    double m_degOfSPEOnThreshold = 0; 
    //--- Parameters for alpha correction -------------------------------------------------------------------------------------
    bool m_alphaCorrection; 
    OptionalDBObjPtr<CDCAlphaScaleFactorForAsymmetry>
    m_alphaScaleFactorsFromDB; 
    //--- Universal digitization parameters -------------------------------------------------------------------------------------
    bool m_doSmearing; 
    bool m_addTimeWalk; 
    bool m_addInWirePropagationDelay; 
    bool m_addTimeOfFlight; 
    bool m_addInWirePropagationDelay4Bg; 
    bool m_addTimeOfFlight4Bg; 
    bool m_outputNegativeDriftTime;     
    bool m_output2ndHit;         
    bool m_align;             
    bool m_correctForWireSag;    
    bool m_treatNegT0WiresAsGood;    
    bool m_matchFirstMCParticles;    
    bool m_matchAllMCParticles;    
//    float m_eventTime;         /**< It is a timing of event, which includes a time jitter due to the trigger system */
 
    bool m_useDB4FEE;             
    DBArray<CDCFEElectronics>* m_fEElectronicsFromDB = nullptr; 
    float m_lowEdgeOfTimeWindow[c_nBoards] = {0}; 
    float m_uprEdgeOfTimeWindow[c_nBoards] = {0}; 
    float m_tdcThresh          [c_nBoards] = {0}; 
    float m_adcThresh          [c_nBoards] = {0}; 
    unsigned short m_widthOfTimeWindowInCount  [c_nBoards] = {0}; 
 
    bool m_useDB4EDepToADC;             
    bool m_useDB4RunGain;               
    bool m_spaceChargeEffect;           
 
    DBObjPtr<CDCDedxRunGain>* m_runGainFromDB = nullptr; 
    DBObjPtr<CDCDedxScaleFactor>* m_gain0FromDB = nullptr; 
    DBObjPtr<CDCDedxWireGain>* m_wireGainFromDB = nullptr; 
    //    DBObjPtr<CDCEDepToADCConversions>* m_eDepToADCConversionsFromDB = nullptr; /*!< Pointer to edep-to-ADC conv. params. from DB. */
    //    float m_eDepToADCParams[c_maxNSenseLayers][4]; /*!< edep-to-ADC conv. params. */
 
    bool m_addXTalk;           
    bool m_issue2ndHitWarning; 
    bool m_includeEarlyXTalks; 
    int  m_debugLevel      ;   
    int  m_debugLevel4XTalk;   
    DBObjPtr<CDCCrossTalkLibrary>* m_xTalkFromDB = nullptr; 
    DBObjPtr<CDCCorrToThresholds>* m_corrToThresholdFromDB = nullptr; 
 
    StoreObjPtr<SimClockState> m_simClockState; 
    bool m_synchronization = true; 
    bool m_randomization = true; 
    int m_tSimMode = 0; 
    int m_offsetForTriggerBin = 1; 
    int m_trgTimingOffsetInCount   = 4; 
    int m_shiftOfTimeWindowIn32Count = 153; 
    unsigned short m_trgDelayInCount[c_nBoards] = {0}; 

    struct SignalInfo {
      SignalInfo(int simHitIndex = 0, float driftTime = 0, float charge = 0, float maxDriftL = 0, float minDriftL = 0,
                 int simHitIndex2 = -1,
                 float driftTime2 = std::numeric_limits<float>::max(), int simHitIndex3 = -1, float driftTime3 = std::numeric_limits<float>::max()) :
        m_simHitIndex(simHitIndex), m_driftTime(driftTime), m_charge(charge), m_maxDriftL(maxDriftL), m_minDriftL(minDriftL),
        m_simHitIndex2(simHitIndex2), m_driftTime2(driftTime2),
        m_simHitIndex3(simHitIndex3), m_driftTime3(driftTime3) {}
      int            m_simHitIndex;   
      float          m_driftTime;     
      float          m_charge;        
      float          m_maxDriftL;      
      float          m_minDriftL;      
      int            m_simHitIndex2;   
      float          m_driftTime2;     
      int            m_simHitIndex3;   
      float          m_driftTime3;     
    };

    struct XTalkInfo {
      XTalkInfo(unsigned short tdc, unsigned short adc, unsigned short tot, unsigned short status) :
        m_tdc(tdc), m_adc(adc), m_tot(tot), m_status(status) {}
      unsigned short m_tdc; 
      unsigned short m_adc; 
      unsigned short m_tot; 
      unsigned short m_status; 
    };
  };

} // end of Belle2 namespace