ECLDigitizerModule.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
 
/* ECL headers. */
#include <ecl/dbobjects/ECLCrystalCalib.h>
#include <ecl/dbobjects/ECLDigitWaveformParametersForMC.h>
#include <ecl/digitization/EclConfiguration.h>
#include <ecl/mapper/ECLChannelMapper.h>
 
/* Basf2 headers. */
#include <framework/core/Module.h>
#include <framework/dataobjects/EventMetaData.h>
#include <framework/database/DBArray.h>
#include <framework/database/DBObjPtr.h>
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
 
/* C++ headers. */
#include <vector>
 
class TTree;
 
namespace Belle2 {
  class ECLWaveformData;
  class ECLNoiseData;
  class ECLWFAlgoParams;
  class ECLHit;
  class ECLSimHit;
  class ECLDigit;
  class ECLDsp;
  class ECLDspWithExtraMCInfo;
  class ECLTrig;
  class ECLWaveforms;
 
  class ECLDigitizerModule : public Module {
  public:
 
    ECLDigitizerModule();
 
    ~ECLDigitizerModule();
 
 
    virtual void initialize() override;
 
    virtual void beginRun() override;
 
    virtual void event() override;
 
    virtual void endRun() override;
 
    virtual void terminate() override;
 
  private:
    using algoparams_t   = ECL::EclConfiguration::algoparams_t;   
    using fitparams_t    = ECL::EclConfiguration::fitparams_t;    
    using signalsample_t = ECL::EclConfiguration::signalsample_t; 
    using adccounts_t    = ECL::EclConfiguration::adccounts_t;    
    using int_array_192x16_t = fitparams_t::int_array_192x16_t; 
    using int_array_24x16_t  =
      fitparams_t::int_array_24x16_t;  
    using uint_pair_t        = std::pair<unsigned int, unsigned int>; 
    struct crystallinks_t {
      short unsigned int idn;
      short unsigned int inoise;
      short unsigned int ifunc;
      short unsigned int iss;
    };
 
    std::vector<crystallinks_t> m_tbl;
 
    std::vector<algoparams_t> m_idn; 
    std::vector<fitparams_t> m_fitparams; 
    std::vector<ECLNoiseData> m_noise; 
    std::vector<signalsample_t> m_ss; 
    std::vector<signalsample_t> m_ss_HadronShapeSimulations; 
    std::vector<adccounts_t> m_adc;  
    struct calibration_t {
      float ascale; 
      float tshift; 
    };
    std::vector<calibration_t> m_calib;
 
    std::vector<double> m_Awave;
 
    unsigned char m_ttime[ECL::ECL_CRATES] = {};
 
    void shapeFitterWrapper(const int j, const int* FitA, const int m_ttrig,
                            int& m_lar, int& m_ltr, int& m_lq, int& m_chi) const ;
 
    bool m_loadOnce = true;
 
    void callbackHadronSignalShapes();
 
    void readDSPDB();
    void shapeSignals();
    void makeWaveforms();
    void repack(const ECLWFAlgoParams&, algoparams_t&);
    void getfitparams(const ECLWaveformData&, const ECLWFAlgoParams&, fitparams_t&);
    void makeElectronicNoiseAndPedestal(int j, int* FitA);
 
    DBObjPtr<ECLDigitWaveformParametersForMC> m_waveformParametersMC;
 
    DBObjPtr<TTree> m_waveformParameters;
 
    DBObjPtr<TTree> m_algoParameters;
 
    DBObjPtr<TTree> m_noiseParameters;
 
    DBObjPtr<ECLCrystalCalib> m_CrystalElectronics{"ECLCrystalElectronics"};
 
    DBObjPtr<ECLCrystalCalib> m_CrystalEnergy{"ECLCrystalEnergy"};
 
    DBObjPtr<ECLCrystalCalib> m_CrystalElectronicsTime{"ECLCrystalElectronicsTime"};
 
    DBObjPtr<ECLCrystalCalib> m_CrystalTimeOffset{"ECLCrystalTimeOffset"};
 
    DBObjPtr<ECLCrystalCalib> m_CrateTimeOffset{"ECLCrateTimeOffset"};
 
    DBObjPtr<ECLCrystalCalib> m_MCTimeOffset{"ECLMCTimeOffset"};
 
    DBObjPtr<ECLCrystalCalib> m_FPGAWaveform{"ECL_FPGA_StoreWaveform"};
 
    StoreObjPtr<EventMetaData> m_EventMetaData;
 
    /* Input arrays. */
 
    StoreArray<ECLHit> m_eclHits;
 
    StoreArray<ECLHit> m_eclDiodeHits;
 
    StoreArray<ECLSimHit> m_eclSimHits;
 
    StoreObjPtr<ECLWaveforms> m_eclWaveforms;
 
    StoreArray<ECLDigit> m_eclDigits;
 
    StoreArray<ECLDsp> m_eclDsps;
 
    StoreArray<ECLDspWithExtraMCInfo> m_eclDspsWithExtraMCInfo;
 
    StoreArray<ECLTrig> m_eclTrigs;
 
    ECL::ECLChannelMapper m_eclMapper; 
    bool m_background;  
    bool m_calibration;  
    bool m_inter; 
    bool m_waveformMaker; 
    bool m_storeDspWithExtraMCInfo;  
    unsigned int m_compAlgo; 
    int m_ADCThreshold; 
    double m_WaveformThresholdOverride; 
    double m_DspWithExtraMCInfoThreshold;  
    bool m_trigTime; 
    std::string m_eclWaveformsName;   
    bool m_HadronPulseShape; 
    bool m_dspDataTest; 
    bool m_useWaveformParameters;
    double m_unitscale;
  };
}//Belle2