release-05-02-19/doxygen/CDCDigitizerModule_8h_source.html

/**************************************************************************

 * BASF2 (Belle Analysis Framework 2)                                     *

 * Copyright(C) 2010 - Belle II Collaboration                             *

 *                                                                        *

 * Author: The Belle II Collaboration                                     *

 * Contributors: Guofu Cao, Martin Heck, CDC group                        *

 *                                                                        *

 * This software is provided "as is" without any warranty.                *

 **************************************************************************/


#ifndef CDCDIGITIZER_H

#define CDCDIGITIZER_H


//basf2 framework headers

#include <framework/core/Module.h>

#include <framework/datastore/StoreArray.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 <reconstruction/dbobjects/CDCDedxRunGain.h>

//#include <cdc/dbobjects/CDCEDepToADCConversions.h>

#include <cdc/dbobjects/CDCCrossTalkLibrary.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_xTalkFromDB) delete m_xTalkFromDB;

    };


  private:

    double smearDriftLength(double driftLength, double dDdt);


    double getdDdt(double driftLength);


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


    //    unsigned short getADCCount(unsigned short layer, unsigned short cell, double edep, double dx, double costh);

    unsigned short getADCCount(const WireID& wid, double edep, double dx, double costh);


    double getPositiveT0(const WireID&);


    void setFEElectronics();


    void setRunGain();


    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;

    bool m_useSimpleDigitization;

    //--- Paramters for simple digitization -------------------------------------------------------------------------------------

    double m_fraction;

    double m_mean1;

    double m_resolution1;

    double m_mean2;

    double m_resolution2;

    double m_tdcThreshold4Outer;

    double m_tdcThreshold4Inner;

    double m_gasToGasWire;

    double m_scaleFac = 1.;

    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;

    TVector3 m_posWire;

    TVector3 m_posTrack;

    TVector3 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.;

    double m_runGain = 1.;

    double m_overallGainFactor = 1.;

    //--- 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;

//    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[nBoards] = {0};

    float m_uprEdgeOfTimeWindow[nBoards] = {0};

    float m_tdcThresh          [nBoards] = {0};

    float m_adcThresh          [nBoards] = {0};

    unsigned short m_widthOfTimeWindow  [nBoards] = {0};

    bool m_useDB4EDepToADC;

    bool m_useDB4RunGain;

    bool m_spaceChargeEffect;

    DBObjPtr<CDCDedxRunGain>* m_runGainFromDB = nullptr;

    //    DBObjPtr<CDCEDepToADCConversions>* m_eDepToADCConversionsFromDB = nullptr; /*!< Pointer to edep-to-ADC conv. params. from DB. */

    //    float m_eDepToADCParams[MAX_N_SLAYERS][4]; /*!< edep-to-ADC conv. params. */


    bool m_addXTalk;

    bool m_issue2ndHitWarning;

    bool m_includeEarlyXTalks;

    int  m_debugLevel4XTalk;

    DBObjPtr<CDCCrossTalkLibrary>* m_xTalkFromDB = nullptr;

    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


#endif // CDCDIGITIZER_H