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/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() override;
 

    virtual void initialize() override;

    virtual void beginRun() override;

    virtual void event() 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